《数据结构》八大排序算法

是我来晚了！

已于 2022-06-08 11:15:57 修改

阅读量527

点赞数 3

CC 4.0 BY-SA版权

分类专栏：数据结构与C 文章标签：数据结构排序算法算法

于 2022-06-07 19:20:11 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_51927215/article/details/125171061

数据结构与C 专栏收录该内容

40 篇文章

订阅专栏

本文详细介绍了多种排序算法，包括冒泡排序、直接插入排序、折半插入排序、希尔排序、简单选择排序、快速排序、堆排序和归并排序。每种算法都有清晰的代码实现，便于理解和学习。通过对这些排序算法的理解，可以提升编程能力，更好地解决实际问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序

// 交换函数（交换地址） 
void swap(int *a, int *b){
	int temp = *a;
	*a = *b;
	*b = temp; 
}

// 每一次冒泡将当前的最大元素找出来并放于数组最后面 
void BubbleSort(int a[], int len, int select=1){
	int key;
	for(int i = 0; i < len; i++){  // 最多冒泡的躺数 
		key = 0;
		if(select){
			// 正序冒泡 
			for(int j = 1; j < len-i; j++){  // 每一躺冒泡的处理过程 
				if(a[j-1] > a[j]){
					key = 1;  // 代表该躺排序是有意义的 
					swap(&a[j-1], &a[j]);
				}
			}		
		}else{
			// 逆序冒泡 
			for(int j = 1; j < len-i; j++){  // 每一躺冒泡的处理过程 
				if(a[j-1] < a[j]){
					key = 1;  // 代表该躺排序是有意义的 
					swap(&a[j-1], &a[j]);
				}
			}
		}
		if(key == 0) break; 
	}
}

直接插入排序

void InsetSort(int a[], int len){
	int k, temp;
	for(int i = 1; i < len; i++){
		if(a[i] < a[i-1]){
			temp = a[i];  // 用来保存当前待插入量
			k = i-1;
			while(k >= 0 && temp < a[k]){
				a[k+1] = a[k];
				k--;
			}
			a[k+1] = temp;
		}
	} 
}

折半插入排序

void BanInsetSort(int a[], int len){
	int temp, left, right, mid;
	for(int i = 1; i < len; i++){
		// 利用折半查找找到插入位置
		temp = a[i];
		left = 0, right = i-1;
		while(left <= right){
			mid = (left+right)/2;
			if(temp < a[mid]){
				right = mid-1;
			}else{
				left = mid+1;
			}
		}
		for(int j = i; j > left; j--){
			a[j] = a[j-1];
		}
		a[left] = temp;
	}
}

希尔排序

void ShellSort(int a[], int len){
	int k, temp;
	for(int gap = len/2; gap > 0; gap /= 2){
		for(int i = 0; i < gap; i++){
			for(int j = i+gap; j < len; j += gap){
				temp = a[j];
				k = j-gap;
				while(k >= 0 && temp < a[k]){
					a[k+gap] = a[k];
					k -= gap;
				}
				a[k+gap] = temp;
			}
		}
	}
}

简单选择排序

void swap(int *a, int *b){
	int temp = *a;
	*a = *b;
	*b = temp; 
}

void SelectSort(int a[], int len){
	for(int i = 0; i < len; i++){
		for(int j = i+1; j < len; j++){
			if(a[i] > a[j]){
				swap(&a[i], &a[j]);
			}
		}
	}
}

快速排序

void QSort(int a[], int start, int end){
	int i, j;
	i = start, j = end;  
	a[0] = a[start];  // 基准值
	while(i < j){
		while(i<j && a[j]>=a[0]) j--;
		if(i<j){a[i] = a[j];i++;}
		while(i<j && a[i]<=a[0]) i++;
		if(i<j){a[j] = a[i];j--;}
	}
	a[i] = a[0];
	
	if(start < i) QSort(a, start, i-1);
	if(end > i) QSort(a, i+1, end);
} 

int main(void){
	int array[] = {0, 2, 1, 4, 6, 5};  // 第一个索引位保存基准值 
	int length = sizeof(array)/sizeof(array[0]);
	QSort(array, 1, length-1);
	for(int i = 1; i < length; i++) printf("%d ", array[i]);
	return 0;
}

堆排序

#include <stdio.h>
#include <stdlib.h>
#define MAX 9  // 最大存储 8个结点（也就是能排序的最大数组长度为 8） 

typedef struct{
    int key;
} SqNode;

typedef struct{
    SqNode r[MAX];
    int length;
} SqList;

// 交换两个记录的位置
void Swap(SqNode *a, SqNode *b){
    int key = a->key;
    a->key = b->key;
    b->key = key;
}

// 将以 r[s]为根结点的子树构成堆，堆中每个根结点的值都比其孩子结点的值大
void HeapAdjust(SqList *H, int s, int m){
    // 先对操作位置上的结点数据进行保存，防止后续移动元素丢失
	SqNode rc = H->r[s];
    // 对于第 s个结点，筛选一直到叶子结点结束
    for(int j=2*s; j<=m; j*=2){
        // 找到值最大的孩子结点
        if(j+1<m && (H->r[j].key < H->r[j+1].key)) {
            j++;
        }
        // 如果当前结点比最大的孩子结点的值还大，则不需要对此结点进行筛选，直接略过
        if(!(rc.key < H->r[j].key)) break; 
        // 如果当前结点的值比孩子结点中最大的值小，则将最大的值移至该结点
        // 由于 rc记录着该结点的值，所以该结点的值不会丢失
        H->r[s] = H->r[j];
        // s相当于指针的作用，指向其孩子结点，继续进行筛选
		s = j;
    }
    // 最终需将 rc的值添加到正确的位置
    H->r[s]=rc;
}

void HeapSort(SqList *H){
    // 构建堆的过程
    for(int i=H->length/2; i>0; i--){
        // 对于有孩子结点的根结点进行筛选
        HeapAdjust(H, i, H->length);
    }
    // 通过不断地筛选出最大值，同时不断地进行筛选剩余元素
    for(int i=H->length; i>1; i--){
        // 交换过程，即为将选出的最大值进行保存后，同时用最后位置上的元素进行替换，为下一次筛选做准备
        Swap(&(H->r[1]), &(H->r[i]));
        //进行筛选次最大值的工作
        HeapAdjust(H, 1, i-1);
    }
}

int main() {
	// 初始化完全二叉树的结点 
    SqList *L=(SqList*)malloc(sizeof(SqList));
    int array[] = {49, 38, 65, 97, 76, 13, 27, 49};
    int len = sizeof(array)/sizeof(array[0]);
    for(int i = 1; i <= len; i++) L->r[i].key = array[i-1];
    L->length = len;
    
    // 堆排序 
    HeapSort(L);
    
	// 输出 
    for(int i=1; i<=L->length; i++){
        printf("%d ", L->r[i].key);
    }
    return 0;
}

归并排序

#include <stdio.h>

// 自定义实现一次归并排序的函数
int merge(int r[], int s[], int x1, int x2, int x3){
    int i, j, k;
    i = x1;  // 第一部分的开始位置
    j = x2+1;  // 第二部分的开始位置
    k = x1;
    
    // 当 i和 j都在两个要合并的部分中时
    while((i<=x2)&&(j<=x3)){
    	// 筛选两部分中较小的元素放到数组 s中
		if(r[i]<=r[j]){
            s[k++] = r[i++];
        }else{
            s[k++] = r[j++];
        }
	}
    //将 x1~x2范围内未比较的数顺次加到数组 r中
    while(i<=x2) s[k++]=r[i++];
    //将 x2+1~x3范围内未比较的数顺次加到数组 r中
    while(j<=x3) s[k++]=r[j++];
    return 0;
}

// 归并函数 
int merge_sort(int r[], int s[], int m, int n){
    int p, t[20]; 
    if(m==n){
    	s[m] = r[m];
	}else{
        p = (m+n)/2;
        // 递归调用 merge_soit()函数将 r[m]~r[p]归并成有序的 t[m]~t[p]
        merge_sort(r, t, m, p);
        // 递归调用 merge_sort()函数将 r[p+1]~r[n]归并成有序的 t[p+1]~t[n]
        merge_sort(r, t, p+1, n);
		// 调用函数将前两部分归并到 s[m]~s[n] 
        merge(t, s, m, p, n);    
    }
    return 0;
}

int main(){
    int a[11];
    printf("请输入10个数：");
    for(int i=1; i<=10; i++) scanf("%d", &a[i]);
    
    // 调用 merge_sort()函数进行归并排序
    merge_sort(a, a, 1, 10);
	
    printf("排序后的顺序是：");
    for(int j=1; j<=10; j++) printf("%d ", a[j]);
    return 0;
}

基数排序

#include <stdio.h>
#include <stdlib.h> 
 
#define Max 10
#define KEYNUM 4  // 比较数值的最大位数 

// 找到 num的从低到高的第 pos位的数据
// 数值位不够则返回 0；例如 33，pos=3时，返回 0 
int GetNumInPos(int num, int pos){
	int temp = 1;
	for(int i=0; i<pos-1; i++) temp*=10;
	return (num/temp)%10;
}

// 基数排序
void RadixSort(int *a, int len){
	// 1. 完成 0~9排序桶的处理（每个桶中的第一位记录每个桶内的元素数量） 
	int *bucket[10];
	for(int i = 0; i < 10; i++){
		bucket[i] = (int*)malloc(sizeof(int)*(len+1));
		bucket[i][0] = 0;
	}
	// {50, 123, 543, 187, 49, 30, 0, 2, 11, 100}
	// 2. 从个位到百位 
	for(int pos = 1; pos <= KEYNUM; pos++){  // 此处数值位最高位 3 
		// 3. 根据各个数的不同位将其入桶 
		for(int i = 0; i < len; i++){
			int num = GetNumInPos(a[i], pos);
			bucket[num][++bucket[num][0]] = a[i];
		}
		// 4. 将桶内的数重新整理后排序（从索引为 0的桶到索引为 9的桶） 
		for(int i = 0, j = 0; i < 10; i++){
			for(int k = 1; k <= bucket[i][0]; k++) a[j++] = bucket[i][k];
			bucket[i][0] = 0;  // 将记录每个桶内的元素数量的变量置 0 
		}
	}
}

int main(){
    int array[Max] = {50, 123, 1143, 187, 49, 30, 0, 2, 11, 100}; 
    int length = sizeof(array)/sizeof(array[0]);
    // 基数排序 
    RadixSort(array, Max);
    for(int i = 0; i < length; i++) printf("%d ", array[i]);
    return 0;
}