C 数据结构之十大排序 三大查找

本文gif图片来自 一像素

排序问题相关描述

 

排序问题： 整理文件中的记录，使之按关键字递增或递减的顺序排列起来。

排序算法的稳定性： 若排序对象中存在多个关键字相同的记录，经过排序后，相同关键字的记录之间的相对次序保持不变，则该排序方法是稳定的，若次序发生变化(哪怕只有两条记录之间)，则该排序方法是不稳定的。不稳定的排序有选择排序、希尔排序、堆排序和快速排序。

排序方法的分类： 若排序过程中，所有的文件都是放在内存中处理的，不涉及数据的内外存交换，则称该排序算法是内部排序算法; 若排序过程中涉及内外存交换，则是外部排序。内部排序适合小文间，外部排序适用于不能一次性把所有记录放入内存的大文件。

排序算法的评价指标： 主要看时间复杂度和空间复杂度（排序所需辅助空间），以及算法本身的复杂度。

时间复杂度： 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得T(n)/f(n)的极限值（当n趋近于无穷大时）为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

空间复杂度：空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，它是问题规模n的函数，记做S(n)=O(f(n))。比如直接插入排序的时间复杂度是O(n^2),空间复杂度是O(1) 。而一般的递归算法就要有O(n)的空间复杂度了，因为每次递归都要存储返回信息，需要辅助空间的大小随着n的增大线性增大。

就地排序(In-PlaceSort)：若一个排序算法所需的辅助空间并不依赖于问题的规模n，即时间复杂度是O(1),则称该排序算法为就地排序。非就地排序算法的时间复杂度一般为O(n)。

非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。
线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

算法复杂度

 

一. 冒泡排序（Bubble Sort）

 

重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

 

 

冒泡排序是通过集合内相邻两个元素两两比较来排序的，每一次比较都是从位于集合内的前两个元素开始的，只不过每次需要比较的长度减1。如果比较两个元素相等，则不进行交换，冒泡排序是一种稳定排序。

 

第一次排序的比较次数： n-1  n个元素相邻两两比较，需要n-1次比较;
第二次排序的比较次数： n-2  第一次排序后最后一个元素可以确定为最大值，不再需要参与第二次排序;
第三次排序的比较次数： n-3  同理，最后两个数已经确定，不再需要参与排序;
第 n-1 次排序的比较次数： 1 ;
总的比较次数为 （n-1） + （n-2） + （n-3） + …+1 = n*(n-1)/2 ,所以冒泡排序的时间复杂度是 O(n^2)。 空间复杂度是 O(1) 。

 

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

//冒泡排序
void bubbleSort(int *arr, int length){    
    for(int i =0;i<length-1;i++){
        for(int j =0;j<length-i-1;j++){
            if(arr[j]>arr[j+1]){
                int temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;    
            }
        }
    }
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}

int main(){
    int arr[10]={3,5,2,10,8,9,6,4,7,1};
    int length = sizeof(arr)/sizeof(int);
    length = 10;
    bubbleSort(arr,length);
    printArr(arr,length);
    return 0;
}

注：

• 1. 整型数组不像字符数组那样有结尾字符，需要小心控制访问下标，不要越界。
• 2. sizeof(数组名)和sizeof(指针)区别： sizeof(数组名)，返回数组中所有元素占有的内存空间的总字节数; sizeof(指针)，返回计算机系统的地址的字节数，32位机是4, 64位机是8。
• 3. 数组名arr称作为参数传入函数后，数组名arr就退化成一个指针，所以不能在函数内部用sizeof(arr)，求入参arr数组的总字节数。

冒泡排序的改进——鸡尾酒排序

鸡尾酒排序又叫定向冒泡排序，鸡尾酒搅拌排序，搅拌排序，是冒泡排序的一种变形。

鸡尾酒排序与冒泡排序的不同处在于排序时是以首尾双向在序列中进行排序。

1.     先对数组从左到右进行升序的冒泡排序；
2.     再对数组进行从右到左的降序的冒泡排序；
3.     以此类推，持续的、依次的改变冒泡的方向，并不断缩小没有排序的数组范围；

鸡尾酒排序的优点是能够在特定条件下（如集合中大部分元素有序），减少排序的回合数。

实现鸡尾酒排序需要分别定义一个从最左边开始的index_left和从最右边开始的index_reight，当两个index相等的时候循环结束。

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

//鸡尾酒排序
void cocktailSort(int* arr, int length){
    int left = 0, right=length-1;
    while(left<right){
        for(int i=left;i<right-1;i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=temp;
            }           
            right-=1;
            for(int j=right;j>left;j--){
                if(arr[j]<arr[j-1]){
                    int temp = arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }
            }
            left+=1;
        }
    }    
}

void cocktailSort1(int* arr, int length){
    for(int i=0; i<length/2;i++){
        for(int j=i;j<length-i-1;j++){
            if(arr[j+1]<arr[j]){
                arr[j+1]^=arr[j];
                arr[j]^=arr[j+1];
                arr[j+1]^=arr[j];
            } 
        }
        for(int k=length-i-1;k>=i+1;k--){
              if(arr[k-1]>arr[k]){
                  arr[k-1]^=arr[k];
                  arr[k]^=arr[k-1];
                  arr[k-1]^=arr[k];
              }
        }
    }
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}

int main(){
    int arr[10]={3,5,2,10,8,9,6,4,7,1};
    int length = sizeof(arr)/sizeof(int);
    length = 10;   
    cocktailSort(arr,length);
    printArr(arr,length);
    return 0;
}

 

 

二. 选择排序（Selection Sort）

 

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：

1.     首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置;
2.     然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾;
3.     以此类推，直到所有元素均排序完毕。

 

选择排序每次从未排序集合中选择出最小的，放到已经排序的元素队尾。

第一次排序的比较次数： n-1  n个元素相邻比较，需要n-1次比较，取出最小值;
第二次排序的比较次数： n-2  n-1个元素相邻比较，需要n-2次比较，取出最小值;
第三次排序的比较次数： n-3  同理，需要n-3次比较;
第 n-1 次排序的比较次数： 1 ;

选择排序时间复杂度是 O(n^2)。 空间复杂度是 O(1) 。

 

定义一个index，用来存放每轮循环中在未排序元素中找到的最小值的位置，在当前轮结束之后，交换index指向的元素和未排序队首元素，同时未排序下标加1。

 

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

//选择排序
void select_Sort(int* arr, int length){
    int min_index;
    int temp;
    for(int i=0;i<length-1;i++){
        min_index=i;
        for(int j=i+1;j<length;j++){
            if(arr[min_index]>arr[j]){
                min_index = j;
            }
        }
        if(min_index!=i){  //如果最小位置不是首元素则交换
            temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;    
        }
    }
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}

int main(){
    int arr[10]={3,5,2,10,8,9,6,4,7,1};
    int length = sizeof(arr)/sizeof(int);
    length = 10;   
    select_Sort(arr,length);
    printArr(arr,length);
    return 0;
}

 

三. 插入排序（Insertion Sort）

 

插入排序是一种简单直观的排序算法，工作原理为构建有序序列，对于未排序元素，在已排序序列中从后向前扫描，找到相应位置并插入。

 

第1个元素，需要进行 0 次比较;
第2个元素，需要进行 1 次比较;
第3个元素，需要进行 2 次比较;
第n个元素，需要进行n-1次比较;

所以插入排序的时间复杂度是O(n^2)，空间复杂度是O(1)。

 

把需要排序的元素取出，该位置空出来，用于前边元素的移动（碰到大于当前元素的情况下），并且替换该位置为移动元素的位置，作为下一次移动的目标位置。

 

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

//插入排序
void insert_Sort(int* arr, int length){
    int temp,i,j;
    for(i=1;i<length;i++){
        temp = arr[i];  //保存要比较的值
        for(j=i-1;j>=0&&arr[j]>temp;j--){ //对前i个已经排好序的列表里插入temp
            arr[j+1] = arr[j]; //依次移动                         
            }
        arr[j+1] = temp; //插入,此处的arr[j+1]其实是上边的“arr[j]”，执行了一个j--操作
    }
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}


int main(){
    int arr[10]={3,5,2,10,8,9,6,4,7,1};
    int length = sizeof(arr)/sizeof(int);
    length = 10;   
    insert_Sort(arr,length);    
    printArr(arr,length);
    return 0;
}

 

四. 希尔排序（Shell Sort）

 

希尔排序是第一个突破O(n^2)的排序算法，是简单插入排序的优化，实质是分组的简单插入排序。它与插入排序的不同之处在于，它会优先比较距离较远的元素(每次取相隔一定间隔gap的元素作为一组，在组内执行简单插入排序)。希尔排序又叫缩小增量排序（不断减小间隔gap的数组，直到gap=1）。

希尔排序的基本思想是： 先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

 

因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

例如对于1，2，3，4，5，6，7，8，9，10
若取间隔gap为 5,则分组是 1、6,  2、7,  3、8,  4、9,  5、10; 一共有5组。
若取间隔gap为 2,则分组是 1、3、5、7、9, 2、4、6、8、10; 一共有2组。

可见，间隔gap是多少，就有多少分组。

希尔排序过程中不断缩小gap值，分组越来越少，当分组为1时，对整个序列执行一次简单插入排序（此时的序列已经基本有序，插入排序效率较高），完成最终排序。 所以应该以gap为最外层，gap=0为循环终止条件。

 

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

//希尔排序
void shell_Sort(int* arr,int length){
    int i,j,gap,temp;
    for(gap = length/2;gap>0;gap/=2){
        for(i=gap;i<length;i+=gap){
            temp = arr[i];
            for(j = i-gap;j>=0&&arr[j]>temp;j-=gap){
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
   
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}


int main(){
    int arr[10]={3,5,2,10,8,9,6,4,7,1};
    int length = sizeof(arr)/sizeof(int);
    length = 10;   
    shell_Sort(arr,length);    
    printArr(arr,length);
    return 0;
}

 

 

五. 归并排序（Merge Sort）

归并概念： 将两个的有序数列合并成一个有序数列，我们称之为"归并"（二路归并）。

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用分治策略，先把n个元素分成若干组，在组内执行排序，之后再两两归并这些组，直到组成最后的一个组，完成排序。

 

 

下图描述的归并排序过程更清晰些：

归并排序的效率是比较高，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)。 空间复杂度是O(n)。

因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N*logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的，仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。

 

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

//合并两个有序序列（即归并）
// A： 待合并的序列（含两个子序列，排在一起）
// Temp： 辅助空间
// L: 左边序列起点下标
// R: 右边序列起点下标，
// RightEnd： 右边序列终点下标
void Merge(int A[], int Temp[], int L, int R, int RightEnd){
    int LeftEnd = R-1;
    int p=L,i;
    int num=RightEnd-L+1;

    //先合并最短序列的长度的个数个元素
    while(L<=LeftEnd&&R<=RightEnd){

        if(A[L]<=A[R])
            Temp[p++]=A[L++];
        else
            Temp[p++]=A[R++];
    }

    //判断如果是左侧序列还有剩余
    while(L<=LeftEnd)
        Temp[p++]=A[L++];
    //判断如果是右侧序列还有剩余
    while(R<=RightEnd)
        Temp[p++]=A[R++];
    // 将辅助空间中的值拷贝到原列表中，完成排序
    for(i=0;i<num;i++,RightEnd--)
        A[RightEnd]=Temp[RightEnd];
}


//递归拆分，递归归并
void m_sort(int* arr, int* temp, int L, int right_end){
    int center;
    if(L<right_end){
        center = (L+right_end)/2;
        m_sort(arr,temp,L,center);
        m_sort(arr,temp,center+1,right_end);
        Merge(arr,temp,L,center+1,right_end);
    }
}

//归并排序
void merge_Sort(int* arr,int length){
    int *temp=(int* )malloc(length*sizeof(int));  //申请辅助空间
    if(temp==NULL){
        return;
    }
    m_sort(arr,temp,0,length-1);
    free(temp);
    temp=NULL;
}


//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}


int main(){
    int arr[10]={3,5,2,10,8,9,6,4,7,1};
    int length = sizeof(arr)/sizeof(int);
    length = 10;   
    merge_Sort(arr,length);    
    printArr(arr,length);
    return 0;
}

 

 

六. 快速排序（Quick Sort）

 

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

 

如初始序列为  5, 7, 3, 8 ，6，3, 1, 0，9
取第一个元素为base基准，先从最右边元素开始比（查找比base小的），比中后再换从最左侧元素开始比（查找比base大的）;
右侧第一次比中后排序 0, 7, 3, 8, 6, 3, 1, x， 9; 左侧下标+1，此时右侧比较的起始位置是x前的一位
左侧第一次比中后排序 0, x， 3, 8, 6, 3, 1, 7, 9; 右侧下标-1， 此时左侧比较的起始位置是x后的一位
右侧第二次比中后排序 0, 1, 3，8, 6, 3, x， 7, 9;
左侧第二次比中后排序 0, 1, 3, x， 6, 3, 8, 7, 9;
右侧第三次比中后排序 0, 1, 3, 3, 6, x， 8, 7, 9;
左侧第三次比中后排序 0, 1, 3, 3, x， 6, 8, 7, 9;
此时左右指针值相逢到x处，此处填上base值5：
                    0, 1, 3, 3, 5, 6, 8, 7, 9;

如此比完一个循环，再以base为分界点，左边的执行以上循环，右边的也执行以上循环，直到最小的区间只有一个数字，完成最终排序。

 

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


//快速排序
//arr是待排序序列， left是最左侧下标0, right是最右侧下标 length
void quick_Sort(int *arr, int left, int right){
    if(left>=right){
    return;    
    }

    int i=left, j=right;
    int base=arr[left]; //基准base
    while(i<j){
        while(i<j && arr[j]>= base){ //从最右侧开始查找小于base的元素
            j--;    
        }
        if(i<j){  //表示在右侧找到了比base小的元素,依据上边的判定，如果没有找到则有i<j
            arr[i++]=arr[j]; //把找到的值移动到原来base的位置，同时下标+1
        }
        while(i<j && arr[i]<=base){
            i++;
        }
        if(i<j){ //表示在左侧找到了比base大的元素
            arr[j--]=arr[i];
        }
    }
    arr[i] = base; //i=j时， 将base填入到中间的位置
    quick_Sort(arr, left, i-1); //左侧递归调用
    quick_Sort(arr, i+1, right); //右侧递归调用
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}


int main(){
    int arr[]={3,5,2,10,8,9,6,4,7,19,5,43,56,3,24,98,76,123,456,76,432,987,12};
    int length = sizeof(arr)/sizeof(int);   
    quick_Sort(arr,0,length);    
    printArr(arr,length);
    return 0;
}

 

 

七. 堆排序（Heap Sort）

 

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆排序（Heap Sort）就是利用堆（如大顶堆）进行排序的方法，基本思想是： 将待排序的序列构成一个大顶堆（此时，整个序列的最大值就是堆顶的根结点），将根结点移走，然后将剩余的n-1个序列重新构成一个堆，再取出根结点，以此类推。可见堆排序是利用了堆这种特殊的完全二叉树结构，每次取出序列的最大值（或最小值）完成排序。堆排序的时间复杂度是O(nlogn)。

 

 

堆排序首先用到了“堆”这种数据结构，每次构建一个大顶堆，根结点都大于它的左右分支，这样根结点就是最大值了; 第二个是用到了递归的思想，将根结点上最大的值移走，再把剩下的元素组成大顶堆，依次执行，直到剩下最后一个元素，就是最小值了。

 

堆排序基本思想：
1. 初始化堆： 将数列a[1……n]构造成大顶堆（即根结点最大，左右结点均小于根结点）;
2. 交换数据： 将a[1](根结点)和a[n](最后一个数据，不一定是最小值)互换，使得a[n]是数列中的最大值;  然后再将a[1……n-1]构造大顶堆，交换a[1]和a[n-1]; 再将a[1……n-2]构造成大顶堆，等等，直到剩下一个元素，就是序列的最小值; 此时整个序列就按从小到大排列好了。

这里的大顶堆是以数组形式存储的，按层（行）存储，第一个元素是顶堆，第2个元素是左子树第一个分支结点，第3个元素是右子树第一个分支结点，第4个元素是第3层左边第一个结点，等等，有如下性质（根结点的索引是0）：

• 性质一：索引为i的左孩子的索引是 (2*i+1);
• 性质二：索引为i的右孩子的索引是 (2*i+2);

 

 

#include<stdio.h>
#include<stdlib.h> 
 
//数据交换
void Swap(int *a, int* b){
    int temp = *a;
    *a = *b;
    *b = temp;
}
 
//构造大顶堆
void heap_down(int* arr,int i, int N){
    int child;
    int temp;
    for(temp=arr[i]; 2*i+1<N;i=child){ //temp是当前结点的值
        child = 2*i+1; //当前结点i的左孩子的位置（在数组中的下标）
        if(child!=N-1 && arr[child+1]>arr[child]){  //child+1是当前结点的右孩子的位置，判断右孩子是否大于左孩子
            child++;  
        }
        if(temp<arr[child]){    //判断根结点是否小于它的左右两个跟结点，如果小于，则交换大的为根结点
            arr[i]=arr[child]; 
            arr[child]=temp; 
        }
        else{
            break;
        }
    }    
}
 
 
//堆排序
void heap_Sort(int *arr, int length){
    int i;
    //从length/2到0依次遍历，最终得到的数组是一个大顶堆
    //最后叶子结点2×i+2=length,i=length/2-1是最后一个父节点
    for(i=length/2;i>=0;i--){
        heap_down(arr, i, length);
    }
    for(i=length-1;i>0;i--){
        Swap(&arr[0],&arr[i]);  //交换最大值a[0]到队列末尾
        heap_down(arr,0,i);  //执行去掉最大值的[0~n-1]个元素的大顶堆，
    }
} 
 
//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
} 
 
int main(){
    int arr[]={3,5,2,10,8,9,6,4,7,19,5,43,56,3,24,98,76,123,456,76,432,987,12};
    int length = sizeof(arr)/sizeof(int);   
    heap_Sort(arr,length);    
    printArr(arr,length);
    return 0;
}

 

八. 计数排序（Counting Sort）

 

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。

 

 

计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。

例如，如果输入序列中只有17个元素的值小于x的值，则x可以直接存放在输出序列的第18个位置上。当然，如果有多个元素具有相同的值时，我们不能将这些元素放在输出序列的同一个位置上，有重复时需要特殊处理（保证稳定性），需要在最后反向填充目标数组，并将每个数字的统计减去1。

计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。

当序列的最大值是M时，需要辅助空间的长度是M，所以不太适合数据量很大，或者最大值很大，或者数据分布很离散的场合下。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

 

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

//计数排序  length: 带排序元素个数  max_num: 待排序元素中最大值
void counting_Sort(int* arr, int length){
    int *c, *b;
    int i, min_num,max_num,range;
    min_num=max_num=arr[0];
    //先求出序列最大最小值
    for(i=1;i<length;i++){
        if(arr[i]>max_num){
            max_num=arr[i];
        }
        if(arr[i]<min_num){
            min_num = arr[i];
        }
    }
    
    range = max_num - min_num +1;
    c = (int*)malloc(sizeof(int)*range);   //辅助排序数组，长度是元素的最大值-最小值+1
    b = (int*)malloc(sizeof(int)*length);
    if(c==NULL || b == NULL){return;}
    for(i=0;i<range;i++){
        c[i]=0;  //辅助数组初始化
    }
    for(i=0;i<length;i++){
        c[arr[i]-min_num]+=1; //统计数组arr中每个值为i的元素出现次数
    }
    for(i =1; i<range;i++){
        c[i]=c[i-1]+c[i];  //确定值为i的元素在数组c中出现的位置
    }
    for(i=length-1;i>=0;i--){
        //对原序列arr中的每一个元素，从后向前依次确定每个元素所在的最终位置，
        //先放入辅助数组b中（再拷回原始arr中）
        c[arr[i]]-=1;
        b[c[arr[i]-min_num]]=arr[i];
      
    }
    for(i = 0; i<length;i++){
        arr[i]=b[i]; //拷回原始arr中
    }
    free(c);
    c = NULL;
    free(b);
    b = NULL;
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}


int main(){    
    int arr[] ={3,5,7,2,1,0,4,65,7,89,5,3,2,5,45,3,2,54,4,543,3,33,2,34,45,5};
    int length = sizeof(arr)/sizeof(int);   
    counting_Sort(arr,length);    
    //printf("%d\n\n",length);
    printArr(arr,length);
    return 0;
}

 

九. 桶排序（Bucket Sort）

 

桶排序的基本思想是将一个数据表分割成许多buckets，然后每个bucket各自排序，或用不同的排序算法，或者递归的使用bucket sort算法。也是典型的divide-and-conquer分而治之的策略。它是一个分布式的排序，当要被排序的数组内的数值是均匀分配的时候，桶排序时间复杂度是O(0)，桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。

 

 

1. 建立一定数量的数组当作空桶；

2. 遍历原始数组，并将数据放入到对应的桶中；

3. 对非空的桶进行排序；

4. 按照顺序遍历这些非空的桶并放回到原始数组中即可构成排序后的数组。

桶排序关键要确定当前数据和桶的映射关系函数，即一个数据应该放到哪个桶里边。

 

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

//桶排序
void bucket_Sort(int* arr, int length){
    int i,j,max_num=arr[0];
    int* bucket;
    //先求出序列最大值
    for(i=1;i<length;i++){
        if(arr[i]>max_num){
            max_num=arr[i];
        }       
    }
    max_num++;  //最大值加1
    if(arr==NULL || length<=1){
        return;
    }
    if((bucket = (int*)malloc(sizeof(int)*max_num))==NULL){return;}
    for(i=0;i<max_num;i++){
        bucket[i]=0;   //空桶数组初始化
    }
    for(i=0;i<length;i++){ // 寻访序列，把元素一个一个放入对应的桶里
        bucket[arr[i]]+=1;   
    }
    for(i=0,j=0;i<max_num;i++){
        while((bucket[i])>0){  //对每个不是空的桶子进行排序
            arr[j]=i;   //从不是空的桶子里把项目再放回原来的序列中
            j++;
            bucket[i]--;
        }
    }
    free(bucket);
    bucket = NULL;    
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}


int main(){    
    int arr[] ={3,5,7,2,1,0,4,65,7,89,5,3,2,5,45,3,2,54,4,543,3,33,2,34,45,5};
    int length = sizeof(arr)/sizeof(int);   
    bucket_Sort(arr,length);    
    //printf("%d\n\n",length);
    printArr(arr,length);
    return 0;
}

 

十. 基数排序（Radix Sort）

 

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

将所有待排序的非负整数统一为位数相同的整数，位数较少的前面补零。

从最低位开始，依次进行一次稳定排序。这样从最低位一直到最高位排序完成以后，整个序列就变成了一个有序序列。如果队列中最大数字的位数是k位，则进行k次基数排序（从低位到高位）完成排序。

 

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

//求数字位数
int bit_num(int num){
    if(num/10==0){
        return 1;
    }
    return 1+bit_num(num/10);
}

//求序列最大值
int max_list(int *arr, int length){
    int max_num = arr[0];
    for(int i=1;i<length;i++){
        if(arr[i]>max_num){
            max_num = arr[i];
        }
    }
    return max_num;
}

//找到一个num从低位到高位的第pos位的数据，数据最右侧最低位pos=1
int get_num_pos(int num, int pos){
    if(pos<=0){return -1;};
    int pow_num = 1;
    for(int i=0;i<pos-1;i++){pow_num*=10;}   
    return (num/pow_num)%10;    
}

//基数排序
void base_Sort(int* arr, int length){
    int max_num, key_num;
    int *base_arr[10]; //十进制的10个桶
    max_num = max_list(arr,length);  
   
    key_num = bit_num(max_num);
   
    for(int i=0; i<10;i++){
        base_arr[i]=(int *)malloc(sizeof(int)*(length+1));
        base_arr[i][0] = 0; //桶中第一个位置记录桶中元素的数量
    }
    for(int pos = 1; pos<= key_num;pos++){ //需要执行最大位数次
        for(int i=0;i<length;i++){
            int num = get_num_pos(arr[i],pos);
            int index = ++base_arr[num][0];
            base_arr[num][index]=arr[i];
        }
        for(int i=0,j=0;i<10;i++){
            for(int k=1; k<=base_arr[i][0];k++){
                arr[j++] = base_arr[i][k];
            }
            base_arr[i][0]=0;
        }
    }
 
}

//打印元素
void printArr(int *arr,int length){
    for(int i=0;i<length;i++){
        printf("%d\n",arr[i]);
    }
}


int main(){    
    int arr[] ={3,5,7,2,1,0,4,65,7,89,5,3,2,5,45,3,2,54,4,543,3,33,2,34,45,5};
    int length = sizeof(arr)/sizeof(int);   
    base_Sort(arr,length);    
    printArr(arr,length);
    return 0;
}

计数排序、桶排序、基数排序区别

基数排序和计数排序都可以看作是一种特殊的桶排序;

计数排序是按照元素出现的次数划分桶，桶排序是按值区间划分桶，基数排序是按数位来划分桶;

 

三大查找

查找概念： 根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。若找到，返回关键字下标，若没有找到，返回-1,表示查找失败。

 

一. 二分查找

 

二分查找就是将查找的键和子数组的中间键作比较，如果被查找的键小于中间键，就在左子数组继续查找；如果大于中间键，就在右子数组中查找，否则中间键就是要找的元素。

元素必须是有序的，如果是无序的则要先进行排序操作。

 

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

//有序表的二分查找,非递归实现
int binary_Search(int* arr, int length, int key){
    int left =0;
    int right = length-1;
    while(left<=right){
        int mid = (left+right)/2;
        if(arr[mid]==key){
            return mid;      
        }
        else if(arr[mid]>key){
            right = mid-1;     //左侧查找
        }
        else{
            left=mid+1;        //右侧查找
        }
    }
    return -1;
}

//有序表的二分查找，递归实现
int binary_Search_rec(int* arr, int low, int high, int key){
    int left,right,mid;
    left = low; right = high-1; mid = (left+right)/2;
    if(low>high){
        return -1;
    }
    if(low == high){
        return arr[mid]==key?mid:-1;
    }
    if(arr[mid]==key){return mid;}
    else if(arr[mid]<key){
        left = mid+1;
        right = high;
        return binary_Search_rec(arr,left,right,key);
    }
    else{
        left = low;
        right = high-1;
        return binary_Search_rec(arr,left,right,key);
    }    
}


int main(){    
    int arr[] ={3,5,7,8,12,15,17,19,21,67,98,123,543};
    int length = sizeof(arr)/sizeof(int);   
    //int pos = binary_Search(arr,length,98);   //非递归
    int pos = binary_Search_rec(arr,0,length,5);  //递归
    printf("%d\n",pos);
    return 0;
}

 

二. 分块查找（索引查找）

 

分块查找是二分查找和顺序查找的一种改进方法，分块查找要求把一个大的线性表分解成若干块，每块中的节点可以任意存放，但块与块之间必须排序。

分块查找要建立一个索引表（占用额外内存空间），把每块中的最大关键码值作为索引表的关键码值，按块的顺序存放到一个辅助数组中，显然这个辅助数组是按关键码值费递减排序的。

查找时，首先在索引表中进行查找，确定要找的节点所在的块。由于索引表是排序的，因此，对索引表的查找可以采用顺序查找或折半查找；然后，在相应的块中采用顺序查找，即可找到对应的节点。

分块查找查找流程：

• 1. 建立索引表（顺序排列的）;
• 2. 根据索引表查找到key所在的块;
• 3. 在快内采用顺序查找方法找到对应节点;

 

三. 哈希查找（散列查找）

 

哈希技术是在记录的存储位置和记录的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)。查找时，根据这个确定的对应关系找到给定值的映射f(key),若查找集合中存在这个记录，则必定在f(key)的位置上。 哈希技术既是一种存储方法，也是一种查找方法。

哈希表也是一种数据结构，理想情况下可以不需要任何比较，一次存取便能得到所查记录。所以它的优点就是查找特定记录的速度快。但因为哈希表是基于数组的，所以创建后就难于扩展，而且不利于遍历数据。

c中散列表使用struct结构实现，包含两个元素，一个是int型的amount，表示当前散列表中包含的元素个数; 一个是type* 类型的arr，用来实际存放数据;

构建散列表之前需要定义散列函数，定义 key和存储地址之间的映射关系，根据映射结果，把key存放到对应的arr下标位置上。
查找的时候，直接使用key和散列函数，对应出在散列表中的位置信息，从arr中取出即可。

 

#include<stdio.h>
#include<stdlib.h>
 
#define HASHSIZE 12
#define NULLKEY -32768

typedef struct
{
    int *elem;
    int count;
}HashTable;

int m=0;
 
//初始化散列表
int InitHashTable(HashTable *H)
{
    int i;
    m=HASHSIZE;
    H->count=m;
    H->elem=(int*)malloc(m*sizeof(int));
    for(i=0;i<m;i++)
        H->elem[i]=NULLKEY;
    return 1;
 }

 //散列函数，定义 key和存储地址之间的对应关系
 int Hash(int key)
 {
     return key%m;
 }

  //插入关键字进入散列表
  void InsertHash(HashTable *H,int key)
  {
      int addr=Hash(key);
      while(H->elem[addr]!=NULLKEY)
          addr=(addr+1)%m;
      H->elem[addr]=key;
   }
   
//散列表查找关键字
int SearchHash(HashTable H,int key,int *addr)
{
    *addr=Hash(key);
    while(H.elem[*addr]!=key)
    {
        *addr=(*addr+1)%m;
        if(H.elem[*addr]==NULLKEY||*addr==Hash(key))
        {
            return -1;
        }
    }
    return *addr;
 }
 
int main()
{
    int a[12]={12,67,56,16,25,37,22,29,15,47,48,34};
    HashTable H;
    int i;
    InitHashTable(&H);
    for(i=0;i<m;i++)
        InsertHash(&H,a[i]);
    printf("插入之后的哈希表为：");
    for(i=0;i<m;i++)
        printf("%d,",H.elem[i]);
    int addr,j;
    j=SearchHash(H,a[5],&addr);
    printf("搜索到 %d 在散列表中的地址是：%d",a[5],j);
}