排序算法

排序

排序：将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列。

排序的稳定性：两个元素Ri、Rj(i!=j)，其对应的关键字Keyi=Keyj，且在排序前Ri在Rj前面，如果使用排序算法排序后，Ri仍然在Rj的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定

插入排序

直接插入排序

将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表，直到所有记录插入到有序表中。

#include<iostream>
using namespace std;
void InsertSort(int a[],int n) {
	int j;
	for(int i=2;i<=n;i++) {
		if(a[i]<a[i-1]) {
			a[0]=a[i];
			for(j=i-1;a[0]<a[j];j--) {
				a[j+1]=a[j];
			}
			a[j+1]=a[0];
		}
		cout<<"i="<<i<<": ";
		for(int k=0;k<=8;k++)
			cout<<a[k]<<" ";
		cout<<endl;
	}
} 

int main() {
	int a[]={0,49,38,65,97,76,13,27,49};
	cout<<"排序前序列: "; 
	for(int i=1;i<=8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	InsertSort(a,8);
	cout<<"排序后序列: ";
	for(int i=1;i<=8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	return 0;
}

运行结果：

直接插入排序的排序稳定性是稳定的，时间复杂度O(n²)

折半插入排序

在插入之前，需找到插入的位置，因此在查找的部分，可以使用折半查找已排好序的序列。查找部分使用折半，其他与直接插入排序类似。

#include<iostream>
using namespace std;
void BInsertSort(int a[],int n) {
	int low,high,mid;
	for(int i=2;i<=n;i++) {
		a[0]=a[i];
		low=1,high=i-1;
		while(low<=high) {
			mid=(low+high)/2;
			if(a[mid]>a[0])
				high=mid-1;
			else
				low=mid+1;
		}
		for(int j=i-1;j>=high+1;j--)
			a[j+1]=a[j];
		a[high+1]=a[0];
		cout<<"i="<<i<<": ";
		for(int k=0;k<=8;k++)
			cout<<a[k]<<" ";
		cout<<endl;
	}
} 

int main() {
	int a[]={0,49,38,65,97,76,13,27,49};
	cout<<"排序前序列: "; 
	for(int i=1;i<=8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	BInsertSort(a,8);
	cout<<"排序后序列: ";
	for(int i=1;i<=8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	return 0;
}

运行结果：

折半插入排序仅减少了关键字间的比较次数，记录移动次数不变，时间复杂度还是O(n²)，稳定的。

希尔排序

属于插入类排序，先将整个待排序的记录序列分割成为若干子序列分别进行插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。

基本过程：

#include<iostream>
using namespace std;
void ShellSort(int a[],int n,int dk) {
	int j;
	for(int i=dk+1;i<=n;i++) {
		if(a[i]<a[i-dk]) {
			a[0]=a[i];
			for(j=i-dk;j>0&&a[0]<a[j];j-=dk) {
				a[j+dk]=a[j];
			}
			a[j+dk]=a[0];
		}
	}
	cout<<"dk="<<dk<<": ";
	for(int k=1;k<=10;k++)
		cout<<a[k]<<" ";
	cout<<endl;
} 

int main() {
	int a[]={0,49,38,65,97,76,13,27,49,55,04};
	int dk[]={5,3,1};
	cout<<"排序前序列: "; 
	for(int i=1;i<=10;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	for(int i=0;i<3;i++)
		ShellSort(a,10,dk[i]);
	cout<<"排序后序列: ";
	for(int i=1;i<=10;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	return 0;
}

运行结果：

希尔排序的时间复杂度是夺所取增量序列函数的。当n在一定范围时，希尔排序的时间复杂度约为O(n^1.3)，在最坏情况下，希尔排序的时间复杂度为O(n²)，是不稳定的

交换排序

冒泡排序

将第一个记录的关键字和第二个关键字进行比较，若为逆序，则将两个记录交换，然后比较第二个关键字和第三个关键字。
依次类推，直至第n-1个记录和第n个记录的关键字进行过比较为止。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

基本过程：

#include<iostream>
using namespace std;
void BubbleSort(int a[],int n) {
	bool flag;int temp;
	for(int i=0;i<n-1;i++) {
		flag=false;
		for(int j=n-1;j>i;j--) {
			if(a[j-1]>a[j]) {
				temp=a[j-1];
				a[j-1]=a[j];
				a[j]=temp;
				flag=true;
			}
		}
		for(int k=0;k<n;k++)
			cout<<a[k]<<" ";
		cout<<endl;
		if(!flag)
			break;
	}
} 

int main() {
	int a[]={49,38,65,97,76,13,27,49};
	cout<<"排序前序列: "; 
	for(int i=0;i<8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	BubbleSort(a,8);
	cout<<"排序后序列: ";
	for(int i=0;i<8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	return 0;
}

运行结果：

时间复杂度：O(n²)，稳定性：稳定的

快速排序

快速排序是一种基于分治法的排序方法。每一趟快排选择序列中任一个元素作为枢轴(pivot)(通常选第一个元素)，将序列中比枢轴小的元素都移到枢轴前边，比枢轴大的元素都移到枢轴后边。

基本过程：

#include<iostream>
using namespace std;
int Partition(int a[], int low, int high) {
	int pivot = a[low]; //用表的第一个记录作枢轴记录 
	while(low < high) {
		while(low < high && pivot <= a[high])
			high--;
		a[low] = a[high]; //将比枢轴小的记录交换到低端 
		while(low < high && pivot >= a[low])
			low++;
		a[high] = a[low]; //将比枢轴大的记录交换到高端 
	}
	a[low] = pivot; //枢轴位置 
	return low; //返回枢轴位置 
} 

int QuickSort(int a[], int low, int high) {
	if(low < high) {
		int pivotloc = Partition(a, low, high); //划分 
		QuickSort(a, low, pivotloc-1); //对低子表递归排序 
		QuickSort(a, pivotloc+1, high); //对高子表递归排序 
	}
}

int main() {
	int a[]={49, 38, 65, 97, 76, 13, 27, 49};
	cout<<"排序前序列: "; 
	for(int i = 0; i < 8; i++)
		cout<<a[i]<<" ";
	cout<<endl;
	QuickSort(a, 0, 7);
	cout<<"排序后序列: "; 
	for(int i = 0; i < 8; i++)
		cout<<a[i]<<" ";
	cout<<endl;
	return 0;
}

运行结果：

选择排序

简单选择排序

第i趟在i~n选择关键字最小记录，与第i位置上记录交换，每一趟确定一个记录，经过n-1趟完成排序。

#include<iostream>
using namespace std;
int SelectMinKey(int a[], int index, int n) { //在i~n选择最小记录 ，返回其位置 
	int i,minKey = a[index], minIndex=index;
	for(i=index+1; i<n; i++) {
		if(a[i] < minKey) {
			minKey = a[i];
			minIndex = i;
		}
	}
	return minIndex;
}
void SelectSort(int a[],int n) {
	int j, temp;
	for(int i=0; i<n-1; i++) { //选择第i个小的记录，并交换到位 
		j = SelectMinKey(a, i, n); //在i~n选择最小记录 
		if(i != j) { //交换位置 
			temp = a[i];
			a[i] = a[j];
			a[j] = temp;
		}
		cout<<"i="<<i<<": ";
		for(int i=0;i<8;i++)
			cout<<a[i]<<" ";
		cout<<endl;
	}
} 

int main() {
	int a[]={49,38,65,97,76,13,27,49};
	cout<<"排序前序列: "; 
	for(int i=0;i<8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	SelectSort(a,8);
	cout<<"排序后序列: ";
	for(int i=0;i<8;i++)
		cout<<a[i]<<" ";
	cout<<endl;
	return 0;
}

运行结果：