超全排序C语言实现

排序

文章目录

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

插入排序

直接插入排序

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

基本思路:

  1. 将第一个元素作为一个有序序列,从第二个开始依次添加元素到有序序列中
  2. 现假设要添加第i个元素到有序序列中去,有序序列最后一个元素下标为i-1,我们只需要确定第i个元素在有序序列中的位置即可
  3. 在确定位置时,应满足如果要插入的元素小于前一个元素,那么前一个元素往后移,直到遇到插入元素大于等于前一个元素为止
  4. 要插入元素有n-1个,因此外循环为n-1;内循环是为当前元素找插入位置,判断条件为前面元素大于插入元素
c 复制代码
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;
    }
}

折半查找插入排序

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

基本思路:

  1. 在有序序列中找插入元素的位置
c 复制代码
// 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;
    }
}

希尔排序

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

基本步骤:

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

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

    c 复制代码
    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开始,第一个元素有序,这样是正确的。然后依次轮到第一组的第二个元素,第二组的第二个元素,第三组的第二个元素,第四组的第二个元素。

选择排序

简单选择排序

c 复制代码
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,否则没有右孩子。

设计堆

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

数据结构
c 复制代码
#define MAXSIZE_HEAP 100 
typedef struct Heap{
    int *arr;
    int Size;//堆的大小
    int usedSize;//现有多少个元素
}MyHeap;
堆的维护
  1. 向上调整

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

    基本步骤:

    • 不断和父节点作比较,判断是否交换,一直到根节点
    c 复制代码
    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. 向下调整

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

    c 复制代码
    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;
            }
        }
    }
堆的初始化
c 复制代码
//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++;
    }
}
创建堆

基本步骤:

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

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

c 复制代码
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);
}
删除一个元素

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

c 复制代码
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);
    }
    
}
返回有效元素的个数
c 复制代码
int size(MyHeap* heap){
    return heap->usedSize;
}
获得优先级最高的元素
c 复制代码
int peek(MyHeap* heap){
    if(heap->usedSize>0){
       return heap->arr[0];
    }else{
        printf("Heap is empty.");
        exit(1);
    }
}
全部代码
c 复制代码
#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;
}
二、使用堆进行排序
c 复制代码
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);
}

交换排序

冒泡排序

c 复制代码
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;
        }
    }
}

快速排序

相关推荐
搬砖的小码农_Sky1 小时前
C语言:数组
c语言·数据结构
Swift社区2 小时前
LeetCode - #139 单词拆分
算法·leetcode·职场和发展
Kent_J_Truman3 小时前
greater<>() 、less<>()及运算符 < 重载在排序和堆中的使用
算法
先鱼鲨生3 小时前
数据结构——栈、队列
数据结构
一念之坤3 小时前
零基础学Python之数据结构 -- 01篇
数据结构·python
IT 青年3 小时前
数据结构 (1)基本概念和术语
数据结构·算法
熬夜学编程的小王3 小时前
【初阶数据结构篇】双向链表的实现(赋源码)
数据结构·c++·链表·双向链表
Dong雨4 小时前
力扣hot100-->栈/单调栈
算法·leetcode·职场和发展
SoraLuna4 小时前
「Mac玩转仓颉内测版24」基础篇4 - 浮点类型详解
开发语言·算法·macos·cangjie
liujjjiyun4 小时前
小R的随机播放顺序
数据结构·c++·算法