数据结构排序算法小结

仅供自用

排序算法

一、插入排序

1、直接插入排序

• 时间复杂度:O(n^2)
• 空间复杂度:O(1)
• 稳定性:稳定

#include<stdio.h>
#include<stdlib.h>
void InsertSort(int a[],int n);
int main(){
	int a[8] = {49,38,65,97,76,13,27,49};
	InsertSort(a,8); //直接插入排序 
	for(int i = 0; i < 8; i++){
		printf("%d ",a[i]);
	}
} 
void InsertSort(int a[],int n){
	int j;
	for(int i = 1; i < n; i++){
		int temp = a[i];
		for(j = i-1; j>= 0&&a[j] > temp;j--){
			a[j+1] = a[j];
		}
		a[j+1] = temp;	
	} 
}

2、折半插入排序

• 时间复杂度:O(n^2)
• 空间复杂度:O(1)
• 稳定性:稳定

#include<stdio.h>
#include<stdlib.h>
void InsertSort(int a[],int n);
int main(){
	int a[8] = {49,38,65,97,76,13,27,49};
	InsertSort(a,8); //折半插入排序 
	for(int i = 0; i < 8; i++){
		printf("%d ",a[i]);
	}
} 
void InsertSort(int a[],int n){
	int left,right;
	for(int i = 1; i < n; i++){
		left = 0; right = i-1;
		int temp = a[i];
		while(left <= right){
			int mid = (left + right)/2;
			if(a[mid] > temp)  right = mid - 1;
			else  left = mid + 1;
		}
		for(int j = i-1; j >= right+1;j--){
			a[j+1] = a[j];
		}
		a[right+1] = temp;
	}
}

结果：13 27 38 49 49 65 76 97

3、哈希排序

• 时间复杂度:O(n^2)
• 空间复杂度:O(1)
• 稳定性:不稳定

#include<stdio.h>
#include<stdlib.h>
void ShellSort(int a[],int n);
int main(){
	int a[10] = {49,38,65,97,76,13,27,49,55,4};
	ShellSort(a,10); //哈希排序 
	for(int i = 0; i < 10; i++){
		printf("%d ",a[i]);
	}
} 
void ShellSort(int a[],int n){
	int j;
	for(int d = n/2; d >= 1; d=d/2){//步长5 3 1
		for(int i =d+1;i<=n;i++){	//从步长+1开始遍历
			int temp = a[i];
            //（直接插入排序）注意就j = j- d;
			for(j = i - d;j>=0 && a[j] > temp; j=j-d){	
				a[j+d] = a[j];
			}
			a[j+d] = temp; 
		}
	}
}

结果：4 13 27 38 49 49 55 65 76 97

二、交换排序

1、冒泡排序

• 时间复杂度:O(n^2)
• 空间复杂度:O(1)
• 稳定性:稳定

#include<stdio.h>
#include<stdlib.h>
void BubbleSort(int a[],int n);
void swap(int &a,int &b);
int main(){
	int a[10] = {49,38,65,97,76,13,27,49,55,4};
	BubbleSort(a,10); //冒泡排序 升序排列 
	for(int i = 0; i < 10; i++){
		printf("%d ",a[i]);
	}
} 
void BubbleSort(int a[],int n){
	bool isexchange = false;
	for(int i = 0; i < n-1; i++){
		for(int j = n-1; j > i;j--){
			if(a[j-1] > a[j]){//升序排列  降序 a[j-1] < a[j] 
				swap(a[j-1],a[j]);
				isexchange = true;
			}
		}
		if(isexchange == false) return;//已经有序
		isexchange = false; 
	}
}
void swap(int &a,int &b){
	int temp = a;
	a = b;
	b = temp;
}

结果：4 13 27 38 49 49 55 65 76 97

2、快速排序※

• 时间复杂度:O(nlog2n) O(n*递归层数)
• 空间复杂度:O(log2n) O(递归层数)
• 稳定性:不稳定

#include<stdio.h>
#include<stdlib.h>
void QuickSort(int a[],int low,int high);
int Partition(int a[],int low,int high);
void swap(int &a,int &b);
int main(){
	int a[10] = {49,38,65,97,76,13,27,49,55,4};
	QuickSort(a,0,10); //快排 
	for(int i = 0; i < 10; i++){
		printf("%d ",a[i]);
	}
} 
void QuickSort(int a[],int low,int high){
	if(low < high){//递归终止条件 
		//返回值是枢轴索引 
		int pivot = Partition(a,low,high); 
		QuickSort(a,low,pivot-1);
		QuickSort(a,pivot+1,high);
	} 
}
int Partition(int a[],int low,int high){
	int pivot = a[low];//枢轴 
	while(low < high){
		while(low < high&&a[high] >= pivot) high--;
		a[low] = a[high];
		while(low < high&&a[low] <= pivot) low++;
		a[high] = a[low]; 
	}
	a[low] = pivot;//最终位置在low = high; 
	return low;
}
void swap(int &a,int &b){
	int temp = a;
	a = b;
	b = temp;
}

结果：4 13 27 38 49 49 55 65 76 97

三、选择排序

1、简单选择排序

• 时间复杂度:O(n^2)
• 空间复杂度:O(1)
• 稳定性:不稳定 {2，2，1} 排序后可能 {1，2，2}

#include<stdio.h>
#include<stdlib.h>
void SelectSort(int a[],int n);
void swap(int &a,int &b);
int main(){
	int a[10] = {49,38,65,97,76,13,27,49,55,4};
	SelectSort(a,10); //简单选择排序 
	for(int i = 0; i < 10; i++){
		printf("%d ",a[i]);
	}
} 
void SelectSort(int a[],int n){
	for(int i = 0;i < n;i++){
		int temp = i;
		int j; 
		for(j = i+1; j < n; j++){
			if(a[j] < a[temp]) temp = j; 
		}
		swap(a[temp],a[i]);
	} 
}
void swap(int &a,int &b){
	int temp = a;
	a = b;c
	b = temp;
}

结果：4 13 27 38 49 49 55 65 76 97

2、堆排序

1）建立大根堆

void BuildMaxHeap(int a[],int len){
	for(int i = len/2;i>0 ;i--){
		// n/2-1, 
		HeadAdjust(a,i,len);
	}
}
//将元素为K的根的子树进行调整 
void HeadAdjust(int a[],int k,int len){
	a[0] = a[k];
	for(int i = 2*k; i <= len; i*=2){
		if(i < len && a[i] < a[i+1]){
			i++; //找到key较大的子节点在下面进行比较 
		}
		if(a[0] > a[i]) break; //已经满足根>左右
		else{
			a[k] = a[i];//将a[i]调整到双亲上
			k = i;  //继续向下调整 
		} 
		a[k] = a[0]; 
	} 
	
} 

2）堆排序算法

• 时间复杂度:O(nlog2n)
• 空间复杂度:O(1)
• 稳定性:不稳定

#include<stdio.h>
#include<stdlib.h>
void HeapSort(int a[],int len);
void BuildMaxHeap(int a[],int len);
void HeadAdjust(int a[],int k,int len);
void swap(int &a,int &b);
int main(){
	int a[9] = {0,53,17,78,9,45,65,87,32};
	HeapSort(a,8);
	for(int i = 1; i < 9; i++){
		printf("%d ",a[i]);
	}
} 
void HeapSort(int 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); 
	}
}
void BuildMaxHeap(int a[],int len){
	for(int i = len/2;i>0 ;i--){
		// n/2-1, 
		HeadAdjust(a,i,len);
	}
}
//将元素为K的根的子树进行调整 
void HeadAdjust(int a[],int k,int len){
	a[0] = a[k];
	for(int i = 2*k; i <= len; i*=2){
		if(i < len && a[i] < a[i+1]){
			i++; //找到key较大的子节点在下面进行比较 
		}
		if(a[0] > a[i]) break; //已经满足根>左右
		else{
			a[k] = a[i];//将a[i]调整到双亲上
			k = i;  //继续向下调整 
		} 
		a[k] = a[0]; 
	} 
	
} 
void swap(int &a,int &b){
	int temp = a;
	a = b;
	b = temp;
}

四、归并排序

• 时间复杂度:O(nlog2n)
• 空间复杂度:O(n)
• 稳定性:稳定

#include<stdio.h>
#include<stdlib.h>
void MergeSort(int a[], int low,int high);
void Merge(int a[], int low,int mid, int high);
int *b=(int*)malloc(7*sizeof(int)); 
int main(){
	int a[7] = {49,38,65,97,76,13,27};
	MergeSort(a,0,6);//归并排序 
	//*b = (int*)malloc(7*sizeof(int));
	for(int i = 1; i < 7; i++){
		printf("%d ",a[i]);
	}
} 
void MergeSort(int a[], int low,int high){
	if(low < high){
		int mid = (low+high)/2;
		// low左侧序列左端 mid 左侧序列右端
		//mid+1右侧序列左端 high 右侧序列右端 
		MergeSort(a,low,mid);
		MergeSort(a,mid+1,high);
		Merge(a,low,mid,high);
	}
}
void Merge(int a[], int low,int mid, int high){
	for(int i = low;i <= high;i++){
		b[i] = a[i];
	}
	int i,j,k;//k为遍历的指针 
	for(i = low,j = mid+1,k = low; i <= mid && j <= high;k++){
		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++];
} 

五、基数排序

• 时间复杂度:O(d(n+r))
• 空间复杂度:O r
• 稳定性:稳定