C语言实现排序算法：直接插入排序，冒泡排序，希尔排序，折半插入查找排序，快速排序，双向起泡排序，简单选择排序，堆排序(建立大根堆)，归并排序

摩尔曼斯克的海

于 2023-08-23 23:37:35 发布

阅读量333

点赞数 2

分类专栏： C语言文章标签：排序算法 c语言算法

本文链接：https://blog.csdn.net/qq_62740668/article/details/132462933

版权

C语言专栏收录该内容

9 篇文章 1 订阅

订阅专栏

直接插入排序

代码实现

使用哨兵

//直接插入（哨兵）
void InsertSort(SSTable* A){
	int i,j;
	for(i = 2;i<= A->len;i++){//使用哨兵方法，数组的0位置一定要是空
		if(A->elem[i] < A->elem[i-1]){
			A->elem[0] = A->elem[i];
			for(j = i - 1;A->elem[0]<A->elem[j];--j){
				A->elem[j+1] = A->elem[j];
			}
			A->elem[j+1] = A->elem[0];
			//j指向的是从后往前第一个小于排序数字的元素，要插在j后面
		}
	}
}

使用临时变量

//直接插入（临时变量）
void Insert(SSTable* A){
	int temp = 0;
	int i,j;
	for(i = 1;i<= A->len;i++){
		temp = A->elem[i];
		for(j = A->len - i;temp < A->elem[j];j--){
			A->elem[j+1] = A->elem[j];
		}
		A->elem[j+1] = temp;//j+1是一个可以覆盖的数
	}
}

冒泡排序

代码实现

//冒泡排序
void BubbleSort(SSTable* p){
	for(int i = 1;i < p->len;i++){//趟数
		for(int j = 1;j<p->len - i;j++){//每次从第1位开始往后比较到倒数第i位
			if(p->elem[j] > p->elem[j+1]){
				int temp = p->elem[j];
				p->elem[j] = p->elem[j+1];
				p->elem[j+1] = temp;
			}
		}
	}
}

希尔排序

代码实现

//希尔排序
void ShellSort(SSTable* p){
	int dk,i,j;
	for(dk = p->len/2;dk >=1;dk = dk/2){
		for(i = dk+1;i <= p->len;++i){
			if(p->elem[i] < p->elem[i-dk]){
				p->elem[0] = p->elem[i];
				for(j = i - dk;j > 0&&p->elem[0] < p->elem[j];j-=dk){
					p->elem[j+dk] = p->elem[j];//每隔dk个位置的记录后移，找到插入位置
				}
				p->elem[j+dk] = p->elem[0]; //插入
			}
		}
	}
}

折半插入查找排序

代码实现

//折半插入排序
void Insertpart(SSTable* p){
	int i,j,low,high,mid;
	for(i = 2;i <= p->len;i++){
		p->elem[0] = p->elem[i];
		low = 1;high = i - 1;//查找目前指针指向的元素之前的表中这个元素插在哪
		while(low <= high){
			mid = (low + high)/2;
			if(p->elem[mid] > p->elem[0])
				high = mid - 1;
			else
				low = mid + 1;
		}
		for(j = i - 1;j >= high + 1;j--){
			p->elem[j+1] = p->elem[j];
		}
		p->elem[high+1] = p->elem[0];
	}
}

快速排序

代码实现

将当前表的第一个元素设为轴对表进行划分

//快速排序
int Partition(SSTable* p,int low ,int high){
	Element pivot = p->elem[low];
	//将当前表的第一个元素设为轴对表进行划分
	while(low < high){
		while(low < high && p->elem[high] > pivot){
			--high;
		}
		p->elem[low] = p->elem[high];
		while(low < high && p->elem[low] < pivot){
			low++;
		}
		p->elem[high] = p->elem[low];
	}
	p->elem[low] = pivot;
	return low;
}


void QuickSort(SSTable* p,int low ,int high){
	if(low < high){
		int pivotpos = Partition(p,low,high);
		QuickSort(p,low,pivotpos-1);
		QuickSort(p,pivotpos+1,high);
	}
}

轴不是第一个元素而是随机

//快速排序（另一种方法：轴不是第一个元素而是随机）
int Partition2(SSTable* p,int low ,int high){
	int randp = low + rand()%(high - low + 1);
	int temp = p->elem[randp];
	p->elem[randp] = p->elem[low];
	p->elem[low] = temp;
	Element pivot = p->elem[low];
	//printf("%d \n",pivot);
	int i = low;
	for(int j = low + 1;j <= high;j++){
		if(p->elem[j] < pivot){
			int tem = p->elem[i + 1];
			p->elem[i + 1] = p->elem[j];
			p->elem[j] = tem;
			i++;
		}
	}
	int te = p->elem[i];
	p->elem[i] = p->elem[low];
	p->elem[low] = te;
	return i;
}

void QuickSort2(SSTable* p,int low ,int high){
	if(low < high){
		int pivotpos = Partition2(p,low,high);
		QuickSort(p,low,pivotpos-1);
		QuickSort(p,pivotpos+1,high);
	}
}

双向起泡排序

双向起泡就是。奇数趟时，从前向后比较相邻元素的关键字，遇到逆序即交换,
直到把序列中关键字最大的元素移动到序列尾部。偶数趟时，从后往前比较相邻元素的关键字，遇到逆序即交换，直到把序列中关键字最小的元素移动到序列前端。

代码实现

//双向起泡排序
void BubbleDouble(SSTable* p){
	int low = 1,high = p->len;
	bool flag = true;
	int i;
	while(low < high && flag){
		flag = false;
		for( i = low;i < high;i++){
			if(p->elem[i] > p->elem[i+1]){
				int temp = p->elem[i];
				p->elem[i] = p->elem[i+1];
				p->elem[i+1] = temp;
				flag = true;
			}
		}
		high--;
		for(i = high;i > low;i--){
			if(p->elem[i] < p->elem[i-1]){
				int temp = p->elem[i];
				p->elem[i] = p->elem[i-1];
				p->elem[i-1] = temp;
				flag = true;
			}
		}
		low++;
	}
}

总实现（一）

使用的顺序表

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define maxsize 5
typedef int Element;
typedef struct SSTable{
	Element *elem;
	int len;
}SSTable;

SSTable* Create(int m){
	SSTable* p = (SSTable*)malloc(sizeof(SSTable));
	if(p == NULL){
		return NULL;
	}else{
		p->elem = (Element*)malloc(sizeof(Element));
		if(p->elem){
			p->len = 0;
			return p;
		}else{
			return NULL;
		}
	}
}


void Writer(SSTable* p){
	printf("请输入表长度:");
	scanf("%d",&(p->len));
	printf("请输入%d个数据:",p->len);
	for(int i = 1;i <= p->len;i++){
		scanf("%d",&p->elem[i]);
	}
}

void Print(SSTable p){
	for(int i = 1;i <= p.len;i++){
		printf("%d  ",p.elem[i]);
	}
}

//直接插入（哨兵）
void InsertSort(SSTable* A){
	int i,j;
	for(i = 2;i<= A->len;i++){//使用哨兵方法，数组的0位置一定要是空
		if(A->elem[i] < A->elem[i-1]){
			A->elem[0] = A->elem[i];
			for(j = i - 1;A->elem[0]<A->elem[j];--j){
				A->elem[j+1] = A->elem[j];
			}
			A->elem[j+1] = A->elem[0];
			//j指向的是从后往前第一个小于排序数字的元素，要插在j后面
		}
	}
}
//直接插入（临时变量）
void Insert(SSTable* A){
	int temp = 0;
	int i,j;
	for(i = 1;i<= A->len;i++){
		temp = A->elem[i];
		for(j = A->len - i;temp < A->elem[j];j--){
			A->elem[j+1] = A->elem[j];
		}
		A->elem[j+1] = temp;//j+1是一个可以覆盖的数
	}
}

//折半插入排序
void Insertpart(SSTable* p){
	int i,j,low,high,mid;
	for(i = 2;i <= p->len;i++){
		p->elem[0] = p->elem[i];
		low = 1;high = i - 1;//查找目前指针指向的元素之前的表中这个元素插在哪
		while(low <= high){
			mid = (low + high)/2;
			if(p->elem[mid] > p->elem[0])
				high = mid - 1;
			else
				low = mid + 1;
		}
		for(j = i - 1;j >= high + 1;j--){
			p->elem[j+1] = p->elem[j];
		}
		p->elem[high+1] = p->elem[0];
	}
}

//希尔排序
void ShellSort(SSTable* p){
	int dk,i,j;
	for(dk = p->len/2;dk >=1;dk = dk/2){
		for(i = dk+1;i <= p->len;++i){
			if(p->elem[i] < p->elem[i-dk]){
				p->elem[0] = p->elem[i];
				for(j = i - dk;j > 0&&p->elem[0] < p->elem[j];j-=dk){
					p->elem[j+dk] = p->elem[j];//每隔dk个位置的记录后移，找到插入位置
				}
				p->elem[j+dk] = p->elem[0]; //插入
			}
		}
	}
}

//冒泡排序
void BubbleSort(SSTable* p){
	for(int i = 1;i < p->len;i++){//趟数
		for(int j = 1;j<p->len - i;j++){//每次从第1位开始往后比较到倒数第i位
			if(p->elem[j] > p->elem[j+1]){
				int temp = p->elem[j];
				p->elem[j] = p->elem[j+1];
				p->elem[j+1] = temp;
			}
		}
	}
}
//双向起泡排序
void BubbleDouble(SSTable* p){
	int low = 1,high = p->len;
	bool flag = true;
	int i;
	while(low < high && flag){
		flag = false;
		for( i = low;i < high;i++){
			if(p->elem[i] > p->elem[i+1]){
				int temp = p->elem[i];
				p->elem[i] = p->elem[i+1];
				p->elem[i+1] = temp;
				flag = true;
			}
		}
		high--;
		for(i = high;i > low;i--){
			if(p->elem[i] < p->elem[i-1]){
				int temp = p->elem[i];
				p->elem[i] = p->elem[i-1];
				p->elem[i-1] = temp;
				flag = true;
			}
		}
		low++;
	}
}





//快速排序
int Partition(SSTable* p,int low ,int high){
	Element pivot = p->elem[low];
	//将当前表的第一个元素设为轴对表进行划分
	while(low < high){
		while(low < high && p->elem[high] > pivot){
			--high;
		}
		p->elem[low] = p->elem[high];
		while(low < high && p->elem[low] < pivot){
			low++;
		}
		p->elem[high] = p->elem[low];
	}
	p->elem[low] = pivot;
	return low;
}


void QuickSort(SSTable* p,int low ,int high){
	if(low < high){
		int pivotpos = Partition(p,low,high);
		QuickSort(p,low,pivotpos-1);
		QuickSort(p,pivotpos+1,high);
	}
}
//快速排序（另一种方法：轴不是第一个元素而是随机）
int Partition2(SSTable* p,int low ,int high){
	int randp = low + rand()%(high - low + 1);
	int temp = p->elem[randp];
	p->elem[randp] = p->elem[low];
	p->elem[low] = temp;
	Element pivot = p->elem[low];
	//printf("%d \n",pivot);
	int i = low;
	for(int j = low + 1;j <= high;j++){
		if(p->elem[j] < pivot){
			int tem = p->elem[i + 1];
			p->elem[i + 1] = p->elem[j];
			p->elem[j] = tem;
			i++;
		}
	}
	int te = p->elem[i];
	p->elem[i] = p->elem[low];
	p->elem[low] = te;
	return i;
}

void QuickSort2(SSTable* p,int low ,int high){
	if(low < high){
		int pivotpos = Partition2(p,low,high);
		QuickSort(p,low,pivotpos-1);
		QuickSort(p,pivotpos+1,high);
	}
}




int main(){
	SSTable* p = Create(9);
	Writer(p);
	Print(*p);
//	printf("\n");
//	InsertSort(p);
//	Print(*p);
	printf("\n");
//	InsertSort(p);
//	Insertpart(p);
//	ShellSort(p);
//	BubbleSort(p);
//	QuickSort(p,1,p->len);
//	BubbleDouble(p);
	QuickSort2(p,1,p->len);
	Print(*p);
	printf("\n");
	return 0;
}

简单选择排序

代码实现

//简单选择排序
void SelectSort(Element A[],int n)
{
	for(int i = 0;i < n-1;i++){//进行n-1趟
		int min = i;
		for(int j = i + 1;j < n;j++){//在A[i+1]到A[n-1]中选择最小的元素
			if(A[j] < A[min]){
				min = j;
			}
		}
		if(min != i){
			Swap(&A[i],&A[min]);
		}
	}
}

堆排序(建立大根堆)

代码实现


//堆排序(建立大根堆)
void HeadAdjust(Element A[],int k,int len){
	A[0] = A[k];//存储以k为根的子树
	for(int i = 2*k;i <= len;i = 2*i ){//找左孩子
		if(i < len && A[i] < A[i+1]){//对比左孩子和右孩子大小
			i++;
		}
		if(A[0] >= A[i])//对比根节点与左右孩子中大的那个结点谁大
			break;
		else{
			A[k] = A[i];//将孩子结点的值放入k
			k = i;//记住孩子结点的位置
		}
	}
	A[k] = A[0];//将之前k位置的值放入孩子结点
}
void BuildMaxHeap(Element A[],int len){//数组从1开始存储
	for(int i = len/2;i > 0;i--){
		HeadAdjust(A,i,len);
	}
}
void HeapSort(Element A[],int len){
	BuildMaxHeap(A,len);
	for(int i = len ;i > 1;i--){//n-1趟
		Swap(&A[i],&A[1]);
		HeadAdjust(A,1,i-1);
	}
}

归并排序

代码实现

//归并排序
static Element B[9] = {0};
//辅助数组B
void Merge(Element A[],int low,int mid,int high){
	//A分成两个表进行排序，起点分别是low和mid+1
	int i,j,k;
	for(k = low;k <= high;k++){
		B[k] = A[k];//将A的数据复制到B
	}
	for(i = low,j = mid +1,k = i;i<= mid&&j<=high;k++){
		//i和j是存储B中比较的位置，k为A中存储的位置
		if(B[i] <= B[j]){
			A[k] = B[i++];
		}else{
			A[k] = B[j++];
		}
	}
	while(i <= mid){
		A[k++] = B[i++];
	}
	while(j <= high){
		A[k++] = B[j++];
	}
}

void MergeSort(Element A[],int low,int high){
	if(low < high){
		int mid = (low + high)/2;
		MergeSort(A,low,mid);
		MergeSort(A,mid+1,high);
		Merge(A,low,mid,high);
	}
}

总实现（二）

直接使用的数组

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int Element;
void Swap(Element *a,Element *b){
	Element temp = *a;
	*a = *b;
	*b = temp;
}
//简单选择排序
void SelectSort(Element A[],int n)
{
	for(int i = 0;i < n-1;i++){//进行n-1趟
		int min = i;
		for(int j = i + 1;j < n;j++){//在A[i+1]到A[n-1]中选择最小的元素
			if(A[j] < A[min]){
				min = j;
			}
		}
		if(min != i){
			Swap(&A[i],&A[min]);
		}
	}
}

void Print(Element A[],int n){
	int i;
	for(i = 0;i < n;i++){
		printf("%d ",A[i]);
	}
}

//堆排序(建立大根堆)
void HeadAdjust(Element A[],int k,int len){
	A[0] = A[k];//存储以k为根的子树
	for(int i = 2*k;i <= len;i = 2*i ){//找左孩子
		if(i < len && A[i] < A[i+1]){//对比左孩子和右孩子大小
			i++;
		}
		if(A[0] >= A[i])//对比根节点与左右孩子中大的那个结点谁大
			break;
		else{
			A[k] = A[i];//将孩子结点的值放入k
			k = i;//记住孩子结点的位置
		}
	}
	A[k] = A[0];//将之前k位置的值放入孩子结点
}
void BuildMaxHeap(Element A[],int len){//数组从1开始存储
	for(int i = len/2;i > 0;i--){
		HeadAdjust(A,i,len);
	}
}
void HeapSort(Element A[],int len){
	BuildMaxHeap(A,len);
	for(int i = len ;i > 1;i--){//n-1趟
		Swap(&A[i],&A[1]);
		HeadAdjust(A,1,i-1);
	}
}

//归并排序
static Element B[9] = {0};
//辅助数组B
void Merge(Element A[],int low,int mid,int high){
	//A分成两个表进行排序，起点分别是low和mid+1
	int i,j,k;
	for(k = low;k <= high;k++){
		B[k] = A[k];//将A的数据复制到B
	}
	for(i = low,j = mid +1,k = i;i<= mid&&j<=high;k++){
		//i和j是存储B中比较的位置，k为A中存储的位置
		if(B[i] <= B[j]){
			A[k] = B[i++];
		}else{
			A[k] = B[j++];
		}
	}
	while(i <= mid){
		A[k++] = B[i++];
	}
	while(j <= high){
		A[k++] = B[j++];
	}
}

void MergeSort(Element A[],int low,int high){
	if(low < high){
		int mid = (low + high)/2;
		MergeSort(A,low,mid);
		MergeSort(A,mid+1,high);
		Merge(A,low,mid,high);
	}
}

int main(){
	Element A[8] = {3,1,8,2,9,0,4,6};
	SelectSort(A,8);
	Print(A,8);
	printf("\n");
	Element C[9] = {0,3,1,8,2,9,0,4,6};
	HeapSort(C,8);
	Print(C,9);
	printf("\n");
	Element D[8] = {3,1,8,2,9,0,4,6};
	MergeSort(D,0,7);
	Print(D,8);
	printf("\n");


	return 0;
}