蓝桥杯专题-真题版含答案-【排序法 - 改良的选择排序】【插补搜寻法】【稀疏矩阵】【欧拉与鸡蛋】

Unity3D特效百例	案例项目实战源码	Android-Unity实战问题汇总
游戏脚本-辅助自动化	Android控件全解手册	再战Android系列
Scratch编程案例	软考全系列	Unity3D学习专栏
蓝桥系列	ChatGPT和AIGC

👉关于作者

专注于Android/Unity和各种游戏开发技巧，以及各种资源分享（网站、工具、素材、源码、游戏等）
有什么需要欢迎底部卡片私我，获取更多支持，交流让学习不再孤单。

👉实践过程

😜排序法 - 改良的选择排序

说明
选择排序法的概念简单，每次从未排序部份选一最小值，插入已排序部份的后端，其时间主要花费于在整个未排序部份寻找最小值，如果能让搜寻最小值的方式加 快，选择排序法的速率也就可以加快，Heap排序法让搜寻的路径由树根至最后一个树叶，而不是整个未排序部份，因而称之为改良的选择排序法。
解法
Heap排序法使用Heap Tree（堆积树），树是一种资料结构，而堆积树是一个二元树，也就是每一个父节点最多只有两个子节点（关于树的详细定义还请见资料结构书籍），堆积树的 父节点若小于子节点，则称之为最小堆积（Min Heap），父节点若大于子节点，则称之为最大堆积（Max Heap），而同一层的子节点则无需理会其大小关系，例如下面就是一个堆积树：

可以使用一维阵列来储存堆积树的所有元素与其顺序，为了计算方便，使用的起始索引是1而不是0，索引1是树根位置，如果左子节点储存在阵列中的索引为s，则其父节点的索引为s/2，而右子节点为s+1，就如上图所示，将上图的堆积树转换为一维阵列之后如下所示：

首先必须知道如何建立堆积树，加至堆积树的元素会先放置在最后一个树叶节点位置，然后检查父节点是否小于子节点（最小堆积），将小的元素不断与父节点交换，直到满足堆积树的条件为止，例如在上图的堆积加入一个元素12，则堆积树的调整方式如下所示：

建立好堆积树之后，树根一定是所有元素的最小值，您的目的就是：
将最小值取出
然后调整树为堆积树

不断重复以上的步骤，就可以达到排序的效果，最小值的取出方式是将树根与最后一个树叶节点交换，然后切下树叶节点，重新调整树为堆积树，如下所示：

调整完毕后，树根节点又是最小值了，于是我们可以重覆这个步骤，再取出最小值，并调整树为堆积树，如下所示：

如此重覆步骤之后，由于使用一维阵列来储存堆积树，每一次将树叶与树根交换的动作就是将最小值放至后端的阵列，所以最后阵列就是变为已排序的状态。

其实堆积在调整的过程中，就是一个选择的行为，每次将最小值选至树根，而选择的路径并不是所有的元素，而是由树根至树叶的路径，因而可以加快选择的过程， 所以Heap排序法才会被称之为改良的选择排序法。

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
#define MAX 10 
#define SWAP(x,y) {int t; t = x; x = y; y = t;} 

void createheap(int[]); 
void heapsort(int[]); 

int main(void) { 
    int number[MAX+1] = {-1}; 
    int i, num;  

    srand(time(NULL)); 

    printf("排序前："); 
    for(i = 1; i <= MAX; i++) { 
        number[i] = rand() % 100; 
        printf("%d ", number[i]); 
    } 

    printf("\n建立堆积树："); 
    createheap(number); 
    for(i = 1; i <= MAX; i++) 
        printf("%d ", number[i]); 
    printf("\n"); 

    heapsort(number); 

    printf("\n"); 

    return 0; 
} 

void createheap(int number[]) { 
    int i, s, p; 
    int heap[MAX+1] = {-1}; 

    for(i = 1; i <= MAX; i++) { 
        heap[i] = number[i]; 
        s = i; 
        p = i / 2; 
        while(s >= 2 && heap[p] > heap[s]) { 
            SWAP(heap[p], heap[s]); 
            s = p; 
            p = s / 2; 
        } 
    } 

    for(i = 1; i <= MAX; i++) 
        number[i] = heap[i]; 
    
} 

void heapsort(int number[]) { 
    int i, m, p, s; 

    m = MAX; 
    while(m > 1) { 
        SWAP(number[1], number[m]); 
        m--; 

        p = 1; 
        s = 2 * p; 

        while(s <= m) { 
            if(s < m && number[s+1] < number[s]) 
                s++; 
            if(number[p] <= number[s]) 
                break; 
            SWAP(number[p], number[s]); 
            p = s; 
            s = 2 * p; 
        } 

        printf("\n排序中："); 
        for(i = MAX; i > 0; i--) 
            printf("%d ", number[i]); 
    } 
}

😜插补搜寻法

说明
如果却搜寻的资料分布平均的话，可以使用插补（Interpolation）搜寻法来进行搜寻，在搜寻的对象大于500时，插补搜寻法会比 二分搜寻法 来的快速。
解法
插补搜寻法是以资料分布的近似直线来作比例运算，以求出中间的索引并进行资料比对，如果取出的值小于要寻找的值，则提高下界，如果取出的值大于要寻找的 值，则降低下界，如此不断的减少搜寻的范围，所以其本原则与二分搜寻法是相同的，至于中间值的寻找是透过比例运算，如下所示，其中K是指定要寻找的对象， 而m则是可能的索引值：

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
#define MAX 10 
#define SWAP(x,y) {int t; t = x; x = y; y = t;} 

void quicksort(int[], int, int); 
int intsrch(int[], int); 

int main(void) { 
    int number[MAX] = {0}; 
    int i, find; 

    srand(time(NULL)); 

    for(i = 0; i < MAX; i++) { 
        number[i] = rand() % 100; 
    } 

    quicksort(number, 0, MAX-1); 

    printf("数列："); 
    for(i = 0; i < MAX; i++) 
        printf("%d ", number[i]); 

    printf("\n输入寻找对象："); 
    scanf("%d", &find); 

    if((i = intsrch(number, find)) >= 0) 
        printf("找到数字于索引 %d ", i); 
    else 
        printf("\n找不到指定数"); 
    
    printf("\n"); 

    return 0; 
} 

int intsrch(int number[], int find) { 
    int low, mid, upper; 

    low = 0; 
    upper = MAX - 1; 

    while(low <= upper) { 
        mid = (upper-low)* 
            (find-number[low])/(number[upper]-number[low]) 
            + low; 
        if(mid < low || mid > upper) 
            return -1; 

        if(find < number[mid]) 
            upper = mid - 1; 
        else if(find > number[mid]) 
            low = mid + 1; 
        else 
            return mid; 
     } 

     return -1;
} 

void quicksort(int number[], int left, int right) { 
    int i, j, k, s; 

    if(left < right) { 
        s = number[(left+right)/2]; 
        i = left - 1; 
        j = right + 1; 

        while(1) { 
            while(number[++i] < s) ;  // 向右找 
            while(number[--j] > s) ;  // 向左找 
            if(i >= j) 
                break; 
            SWAP(number[i], number[j]); 
        } 

        quicksort(number, left, i-1);   // 对左边进行递回 
        quicksort(number, j+1, right);  // 对右边进行递回 
    } 
} 

😜稀疏矩阵

说明
如果在矩阵中，多数的元素并没有资料，称此矩阵为稀疏矩阵（sparse matrix），由于矩阵在程式中常使用二维阵列表示，二维阵列的大小与使用的记忆体空间成正比，如果多数的元素没有资料，则会造成记忆体空间的浪费，为 此，必须设计稀疏矩阵的阵列储存方式，利用较少的记忆体空间储存完整的矩阵资讯。
解法
在这边所介绍的方法较为简单，阵列只储存矩阵的行数、列数与有资料的索引位置及其值，在需要使用矩阵资料时，再透过程式运算加以还原，例如若矩阵资料如下 ，其中0表示矩阵中该位置没有资料：
0 0 0 0 0 0
0 3 0 0 0 0
0 0 0 6 0 0
0 0 9 0 0 0
0 0 0 0 12 0

这个矩阵是5X6矩阵，非零元素有4个，您要使用的阵列第一列记录其列数、行数与非零元素个数：
5 6 4

阵列的第二列起，记录其位置的列索引、行索引与储存值：
1 1 3
2 3 6
3 2 9
4 4 12

所以原本要用30个元素储存的矩阵资讯，现在只使用了15个元素来储存，节省了不少记忆体的使用。

#include <stdio.h> 
#include <stdlib.h> 

int main(void) { 
    int num[5][3] = {{5, 6, 4}, 
                     {1, 1, 3}, 
                     {2, 3, 6}, 
                     {3, 2, 9}, 
                     {4, 4, 12}}; 
    int i, j, k = 1; 

    printf("sparse matrix：\n"); 
    for(i = 0; i < 5; i++) { 
        for(j = 0; j < 3; j++) { 
            printf("%4d", num[i][j]); 
        } 
        putchar('\n'); 
    } 

    printf("\nmatrix还原：\n"); 
    for(i = 0; i < num[0][0]; i++) { 
        for(j = 0; j < num[0][1]; j++) { 
            if(k < num[0][2] && 
               i == num[k][0] && j == num[k][1]) { 
                printf("%4d ", num[k][2]); 
                k++; 
            } 
            else 
                printf("%4d ", 0); 
        } 
        putchar('\n'); 
    } 

    return 0; 
}

😜欧拉与鸡蛋

大数学家欧拉在集市上遇到了本村的两个农妇，每人跨着个空篮子。
她们和欧拉打招呼说两人刚刚卖完了所有的鸡蛋。
欧拉随便问：“卖了多少鸡蛋呢？”
不料一个说：“我们两人自己卖自己的，一共卖了150个鸡蛋，虽然我们卖的鸡蛋有多有少，
但刚好得了同样的钱数。你猜猜看！”
欧拉猜不出。
另一个补充道：“如果我按她那样的价格卖，可以得到32元；如果她按我的价格卖，可以得到24.5元”。
欧拉想了想，说出了正确答案。

我们不是数学家，懒得列出公式来分析。但计算机可以“暴力破解”，
就是把所有可能情况都试验一遍，撞上为止！
请写出每人鸡蛋的数目（顺序不限），用逗号隔开。

public class T11 {  
    public static void main(String[] args) {  
        for(int i=0;i<150;i++){  
            int x = i;      // 得到两个数 x, y   
            int y = 150 - i;  
              
            double priceX = 24.5/y; // 得到 x的单价   
            double priceY = 32.0/x; // 得到 y的单价   
              
            double moneyX = priceX * x; // x卖的总钱总   
            double moneyY = priceY * y; // y卖的总钱总   
              
            if(Math.abs(moneyX-moneyY)<0.000001){    // 浮点数相等比较   
                System.out.println(i+" "+(150-i));  
            }  
        }  
    }  
} 

👉其他

📢作者：小空和小芝中的小空
📢转载说明-务必注明来源：https://zhima.blog.csdn.net/
📢这位道友请留步??，我观你气度不凡，谈吐间隐隐有王者霸气💚，日后定有一番大作为📝！！！旁边有点赞👍收藏🌟今日传你，点了吧，未来你成功??，我分文不取，若不成功??，也好回来找我。

温馨提示：点击下方卡片获取更多意想不到的资源。