1. 首页
  2. 文章资讯

超全排序C语言实现

23 阅读 0 评论

排序

文章目录


下面针对排序都是升序，且排序的元素都是整型。

插入排序

直接插入排序

原理：将无序的元素插入到有序的序列

基本思路：

  1. 将第一个元素作为一个有序序列，从第二个开始依次添加元素到有序序列中
  2. 现假设要添加第i个元素到有序序列中去，有序序列最后一个元素下标为i-1，我们只需要确定第i个元素在有序序列中的位置即可
  3. 在确定位置时，应满足如果要插入的元素小于前一个元素，那么前一个元素往后移，直到遇到插入元素大于等于前一个元素为止
  4. 要插入元素有n-1个，因此外循环为n-1；内循环是为当前元素找插入位置，判断条件为前面元素大于插入元素
void InsertSort(int* arr,int n){
    //i为第几个元素插入到有序序列中，j为遍历有序序列的下标
    //temp保存当前插入元素的值，因为前面元素要向后移动，覆盖插入元素的值，所以要保存
    int i,j,temp;
    for(i=1;i<n;i++){
        //从有序序列最后一个开始
        j=i-1;
        temp=arr[i];
        while(j>=0 && arr[j]>temp){
            //后移
            arr[j+1]=arr[j];
            j--;
        }
        //arr[j]<=temp
        arr[j+1]=temp;
    }
}
image-20241113124112064

折半查找插入排序

原理：和直接插入排序相似，只是在找插入位置时，使用折半查找，减少了比较次数，但是元素移动次数没有改变

基本思路：

  1. 在有序序列中找插入元素的位置
// 1 2 4 5 7 9   e==6
//mid=2,4<6,low=mid+1=3
//mid=4,7>e,high=mid-1=3

初始化低位和高位：low = 0，high = len - 1，表示查找的初始范围是数组的从头到尾。
避免加法溢出：mid = low + (high - low) / 2;，避免 low + high 可能导致的溢出问题。
查找过程：
如果 arr[mid] < e，则说明目标元素 e 应该插入到 mid 的右边，即更新 low = mid + 1。
如果 arr[mid] > e，则目标元素 e 应该插入到 mid 的左边，即更新 high = mid - 1。
如果 arr[mid] == e，说明目标元素已经存在，可以直接返回当前位置+1。
返回插入位置：
当 low 大于 high 时，目标元素没有找到，low 位置就是元素 e 应该插入的位置。
int BinarySearchInsertPosition(int* arr, int len, int e) {
    int low = 0, high = len - 1;
    
    // 避免加法溢出，防止 high + low 可能导致溢出
    int mid = low + (high - low) / 2;
    
    // 查找插入位置
    while (low <= high) {
        if (arr[mid] < e) {
            // 如果中间元素小于目标元素，则查找右半部分
            low = mid + 1;
        } else if (arr[mid] > e) {
            // 如果中间元素大于目标元素，则查找左半部分
            high = mid - 1;
        } else {
            // 如果中间元素等于目标元素，返回当前的 mid，表示可以插入到该位置
            return mid + 1;
        }
        
        // 重新计算中间索引
        mid = low + (high - low) / 2;
    }
    
    // 如果没有找到相等的元素，low 就是应该插入的位置
    return low;
}

void Bsearch_InsertSort(int* arr,int n){
    int i,j,temp;
    for(i=1;i<n;i++){
        j=i-1;
        temp=arr[i];
        //查找应插入位置
        int pos=BinarySearchInsertPosition(arr,n,temp);
        
        //移动元素
        for(int k=i;k>pos;k--){
            arr[k]=arr[k-1];
        }
        arr[pos]=temp;
    }
}
image-20241113132116845

希尔排序

原理：希尔排序又叫缩小增量排序法，设置一个增量dx，将待排序序列进行分组，如果dx=5的话，那么待排序序列足够长的话，会被分为5组，即[(0,5,10,15…)，(1,6,11,16…)…(4,9,14,19)]（这里的数字都是下标），在这5组在组内分别排序后，每次从这5个分组按序取一个元素，直到所有元素取完；之后dx=2，再次分组排序，最后dx=1，就是直接插入排序。

基本步骤：

  1. 初始化步长，通常设置为数组长度的一半

  2. 对每个分组进行插入排序

    void ShellSort(int* arr,int n){
    int i,j,temp;
    for(int gap=n/2;gap>0;gap/=2){
        for(i=gap;i<n;i++){
            temp=arr[i];
            j=i;
            while(j>=gap&&arr[j-gap]>temp){
                arr[j]=arr[j-gap];
                j-=gap;
            }
            arr[j]=temp;
        }
    }
}
解释：
    假设数组的长度为16，第一次时，gap=8，i从8到15，分为了8组，依次和前面的i-gap进行比较排序
    第二次时，gap=4，i从4到15，每次从第二个元素开始排序。要保证下一个元素排序时，前面的元素是有序的，如果从12到15排序，前面3个元素不一定是有序的
    因此必须从gap开始，第一个元素有序，这样是正确的。然后依次轮到第一组的第二个元素，第二组的第二个元素，第三组的第二个元素，第四组的第二个元素。
    image-20241113154216849

选择排序

简单选择排序

void SelectionSort(int* arr,int n){
    int i,j,temp;
    //每次选择一个小的元素到序列最前面，只需选择n-1个元素就可以让序列有序
    for(i=0;i<n-1;i++){
        //j从i开始
        for(j=i;j<n;j++){
            if(arr[i]>arr[j]){
                temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
}

堆排序

一、构建堆

堆排序要利用一个数据结构——堆，根据堆顶元素的不同意义，分为大顶堆和小顶堆。所以下面先介绍堆的性质和如何创建堆等。

堆有以下性质：

  • 堆中某个节点的值不大于或不小于其父节点的值

  • 堆总是一棵完全二叉树（因此可以使用数组来存储）

堆的存储方式：

从堆的概念可知，堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储。

  • 假设i为节点在数组中的下标，则有：

  • 如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2。

  • 如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子。

  • 如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子。

设计堆

​ 下面我们都以大顶堆为例。

数据结构
#define MAXSIZE_HEAP 100 
typedef struct Heap{
    int *arr;
    int Size;//堆的大小
    int usedSize;//现有多少个元素
}MyHeap;
堆的维护

  1. 向上调整

    向上调整主要用于新元素添加到堆中去时，用于和父节点进行比较交换，以维护堆的性质。

    基本步骤：

    • 不断和父节点作比较，判断是否交换，一直到根节点
    void shiftUp(MyHeap* heap,int child){
    //获得父节点的下标
    int parent=(child-1)/2;
    while(child>0){
        if(heap->arr[parent]>=heap->arr[child]){
            //满足大顶堆的性质，结束调整
            break;
        }else{
            //做交换
            int temp=heap->arr[parent];
            heap->arr[parent]=heap->arr[child];
            heap->arr[child]=temp;
            
            //交换之后影响上面的树，继续调整
            child=parent;
            parent=(child-1)/2;
        }
    }
}

  2. 向下调整

    向下调整主要用于堆的创建和堆顶元素发生改变时。

    void shiftDown(MyHeap* heap,int parent){
    //有孩子的话，左孩子一定有
    int child=2*parent+1;
    while(child<heap->usedSize){
        if(child+1<heap->usedSize&&heap->arr[child+1]>heap->arr[child]){
            //如果右孩子存在且大于左孩子的值,获得要和孩子节点交换的下标
            child=child+1;
        }
        if(heap->arr[parent]>=heap->arr[child]){
            //如果父节点大于等于孩子节点，满足大顶堆性质
            break;
        }else{
            //交换
            int temp=heap->arr[parent];
            heap->arr[parent]=heap->arr[child];
            heap->arr[child]=temp;
            
            //交换之后可能会影响下面的子树，如果交换的这个孩子节点有孩子的话，调整这棵子树。
            parent=child;
            child=2*parent+1;
        }
    }
}
堆的初始化
//Size为指定的初始化堆的大小
void InitHeap(MyHeap* heap, int* arr, int len, int Size) {
    heap->arr = (int*)malloc(sizeof(int) * Size);
    heap->Size = Size;
    heap->usedSize = 0;
    for (int i = 0; i < len; i++) {
        heap->arr[i] = arr[i];
        heap->usedSize++;
    }
}
创建堆

基本步骤：

  • 找到最后一个非叶子节点
  • 不断向下调整，直到到达根节点，全部调整完成，堆也就创建好了
void CreateHeap(MyHeap* heap){
    //找到最后一个叶子节点的父节点，从这里开始向下调整，这时，整棵树还是比较乱的
    int StartRoot=(heap->usedSize-1-1)/2;
    for(;StartRoot>=0;StartRoot--){
        shiftDown(heap,StartRoot);
    }
}
插入一个元素

插入元素都从最后一个位置插入

void offer(MyHeap* heap,int e){
    //先判断堆是否还可以添加元素
    if(heap->usedSize==heap->Size){
        //堆满了，扩容
        int* temp=(int*)malloc(sizeof(int)*2*heap->Size);
        for(int i=0;i<heap->Size;i++){
            temp[i]=heap->arr[i];
        }
        free(heap->arr);
        heap->arr=temp;
        heap->Size=2*heap->Size;
    }
    heap->arr[(heap->usedSize)++]=e;
    //插入元素后，进行向上调整
    shiftUp(heap,heap->usedSize-1);
}
删除一个元素

删除元素一定是堆顶元素，因为我们总是获得优先级最高的元素。

int poll(MyHeap* heap){
    if(heap->usedSize>0){
     	int ret=heap->arr[0];
   	 	heap->arr[0]=heap->arr[heap->usedSize-1];
    	//向下调整
    	shiftDown(heap,0);
    	(heap->usedSize)--;
    	return ret;
    }else{
        printf("Heap is empty.");
        exit(1);
    }
    
}
返回有效元素的个数
int size(MyHeap* heap){
    return heap->usedSize;
}
获得优先级最高的元素
int peek(MyHeap* heap){
    if(heap->usedSize>0){
       return heap->arr[0];
    }else{
        printf("Heap is empty.");
        exit(1);
    }
}
全部代码
#define MAXSIZE_HEAP 100 
typedef struct Heap{
    int *arr;
    int Size;//堆的大小
    int usedSize;//现有多少个元素
}MyHeap;

void shiftUp(MyHeap* heap,int child);
void shiftDown(MyHeap* heap,int parent);
void InitHeap(MyHeap* heap,int* arr,int len,int Size);
void CreateHeap(MyHeap* heap);
void offer(MyHeap* heap,int e);
int poll(MyHeap* heap);
int size(MyHeap* heap);
int peek(MyHeap* heap);




//--------------------------------------------------------------
void shiftUp(MyHeap* heap,int child){
    //获得父节点的下标
    int parent=(child-1)/2;
    while(child>0){
        if(heap->arr[parent]>=heap->arr[child]){
            //满足大顶堆的性质，结束调整
            break;
        }else{
            //做交换
            int temp=heap->arr[parent];
            heap->arr[parent]=heap->arr[child];
            heap->arr[child]=temp;
            
            //交换之后影响上面的树，继续调整
            child=parent;
            parent=(child-1)/2;
        }
    }
}

void shiftDown(MyHeap* heap,int parent){
    //有孩子的话，左孩子一定有
    int child=2*parent+1;
    while(child<heap->usedSize){
        if(child+1<heap->usedSize&&heap->arr[child+1]>heap->arr[child]){
            //如果右孩子存在且大于左孩子的值,获得要和孩子节点交换的下标
            child=child+1;
        }
        if(heap->arr[parent]>=heap->arr[child]){
            //如果父节点大于等于孩子节点，满足大顶堆性质
            break;
        }else{
            //交换
            int temp=heap->arr[parent];
            heap->arr[parent]=heap->arr[child];
            heap->arr[child]=temp;
            
            //交换之后可能会影响下面的子树，如果交换的这个孩子节点有孩子的话，调整这棵子树。
            parent=child;
            child=2*parent+1;
        }
    }
}

//Size为指定的初始化堆的大小
void InitHeap(MyHeap* heap, int* arr, int len, int Size) {
    heap->arr = (int*)malloc(sizeof(int) * Size);
    heap->Size = Size;
    heap->usedSize = 0;
    for (int i = 0; i < len; i++) {
        heap->arr[i] = arr[i];
        heap->usedSize++;
    }
}

void CreateHeap(MyHeap* heap){
    //找到最后一个叶子节点的父节点，从这里开始向下调整，这时，整棵树还是比较乱的
    int StartRoot=(heap->usedSize-1-1)/2;
    for(;StartRoot>=0;StartRoot--){
        shiftDown(heap,StartRoot);
    }
}

void offer(MyHeap* heap,int e){
    //先判断堆是否还可以添加元素
    if(heap->usedSize==heap->Size){
        //堆满了，扩容
        int* temp=(int*)malloc(sizeof(int)*2*heap->Size);
        for(int i=0;i<heap->Size;i++){
            temp[i]=heap->arr[i];
        }
        free(heap->arr);
        heap->arr=temp;
        heap->Size=2*heap->Size;
    }
    heap->arr[(heap->usedSize)++]=e;
    //插入元素后，进行向上调整
    shiftUp(heap,heap->usedSize-1);
}

int poll(MyHeap* heap){
    if(heap->usedSize>0){
     	int ret=heap->arr[0];
   	 	heap->arr[0]=heap->arr[heap->usedSize-1];
    	//向下调整
    	shiftDown(heap,0);
    	(heap->usedSize)--;
    	return ret;
    }else{
        printf("Heap is empty.");
        exit(1);
    }
    
}

int peek(MyHeap* heap){
    if(heap->usedSize>0){
       return heap->arr[0];
    }else{
        printf("Heap is empty.");
        exit(1);
    }
}

int size(MyHeap* heap){
    return heap->usedSize;
}
二、使用堆进行排序
void HeapSort(int* arr,int len){
    MyHeap heap;
    //初始化堆的数据
    InitHeap(&heap,arr,len,len);
    //构建大顶堆
    CreateHeap(&heap);
    //对于n个元素，要进行poll操作n-1次
    for(int i=1;i<len;i++){
        arr[len-i]=poll(&heap);
    }
    arr[0]=peek(&heap);
}
image-20241113233306569

交换排序

冒泡排序

void Bubble(int* arr,int n){
    int i,j,temp;
    //i控制轮数，每次会将一个大的元素，只需要移动n-1个元素之后，整个序列就有序了
    for(i=0;i<n-1;i++){
        int flag=1;
        for(j=0;j<n-1-i;j++){
            if(arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
                flag=0;
            }
        }
        if(flag==1){
            //表明所有元素有序
            break;
        }
    }
}

快速排序

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处： 免费源码网-免费的源码资源网站 » 超全排序C语言实现

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

 发表
评论 返回
顶部