几大排序的原理以及代码实现

1.选择排序

      原理：从左到右遍历数组，选择最小的放在第一个，再从第二个从左到右遍历，选择最小的放在第二个，再从第三个遍历，最小的放在第三个，以此类推到结束。

    时间复杂度O(N^2) 空间复杂度O(1)，不稳定

void SelectionSort(int a[],int n){
	if(n==0||n<2)
		return;
	for(int i=0;i<n-1;i++){
		int minIndex=i;
		for(int j=i+1;j<n;j++){
			minIndex=a[j]<a[minIndex]?j:minIndex;
		}
		int temp=a[i];
		a[i]=a[minIndex];
		a[minIndex]=temp;
	}
}

2.插入排序

    原理：类似于扑克牌理牌的过程，从左到右遍历，每个数插入到前面适应的位置上

    时间复杂度O(N^2)、空间复杂度O(1)、稳定

void InsertSort(int a[],int n){
	if(n==0||n<2)
		return ;
	for(int i=1;i<n;i++){
		for(int j=i-1;j>=0&&a[j]>a[j+1];j--){
			int temp=a[j];
			a[j]=a[j+1];
			a[j+1]=temp;
		}
	}
} 

3.冒泡排序

    每次遍历最大的放最后。

    时间复杂度O(N^2)、空间复杂度O(1)、稳定

void BubbleSort(int a[],int n){
	for(int j=n-1;j>0;j--){
		for(int i=0;i<j;i++){
			if(a[i]>a[i+1])
				swap(a,i,i+1);
		} 
	}
}

4.归并排序（分治思想）

    原理：把数组拆分成子数组，排序后再与相邻的合并，再排序，直到整个数组合并、排序完成

    时间复杂度O(NlogN)、空间复杂度O(N)、稳定

void Mergearray(int a[],int left,int mid,int right){
	int p1=left;
	int p2=mid+1;
	int r[right-left+1];
	int i=0;
	while(p1<=mid&&p2<=right){
			r[i++]=a[p1]<a[p2]?a[p1++]:a[p2++];
	}
	
	while(p1<=mid)
		r[i++]=a[p1++];
	while(p2<=right)
		r[i++]=a[p2++];
		
	for(i=0;i<right-left+1;i++){
		a[left+i]=r[i];
	}	
}

void MergeSort(int a[],int left,int right){
	if(left==right)
		return;
	int mid=left+(right-left)/2;
	MergeSort(a,left,mid);
	MergeSort(a,mid+1,right);
	Mergearray(a,left,mid,right); 
}

5.快速排序（分治思想）

    原理：从数组里选一个随机数a（下面实现中选择最后一个数），把它放到合适的位置，使得数组左边的数小于a，右边的数大于a，再根据左右两边数组分为子数组，子数组重复该操作直到整个数组有序。

    时间复杂度O(NlogN)、最坏情况O(N^2)、空间复杂度O(logN)、不稳定

int* Partition(int a[],int left,int right){
	int less=left-1;
	int more=right;
	while(left<more){
		if(a[left]<a[right]){
			swap(a,++less,left++);
		}
		else if(a[left]>a[right]){
			swap(a,--more,left);
		}
		else
			left++;
	}
	swap(a,right,more);
	int *p=new int[2];
	p[0]=less+1;
	p[1]=more;
	return p;
}

void QuickSort(int a[],int left,int right){
	if(left<right){
	int *p=Partition(a,left,right);
	QuickSort(a,left,p[0]-1);
	QuickSort(a,p[1]+1,right);
	}
}

6.堆排序（非递归实现）

    原理：一列数想要从小到大排列，则使用大根堆的概念，每一次将大根堆的根节点（最大的数）放到最后，大根堆总节点数再-1，使得最大的数已经排好，然后调整数组，使现在的堆仍为大根堆，再对N-1个大根堆进行同样操作。

    时间复杂度O(NlogN)，空间复杂度O(1)，不稳定

void HeapInsert(int a[],int index){									//把数组建立成大根堆 
	while(a[index]>a[(index-1)/2]){
		swap(a,index,(index-1)/2);
		index=(index-1)/2;
	}
}

void Heapify(int a[],int index,int size){							//把现数组调整成大根堆 
	int left=index*2+1;
	while(left<size){
		int largest=left+1<size&&a[left+1]>a[left]?left+1:left;
		largest=a[largest]>a[index]?largest:index;
		if(largest==index)
			break;
		swap(a,largest,index);
		index=largest;												//while循环加上下标变换，代替了递归操作 
		left=index*2+1;
	}
}

void HeapSort(int a[],int n){
	for(int i=0;i<n;i++)
		HeapInsert(a,i);
	swap(a,0,--n);
	while(n>0){														 
		Heapify(a,0,n);
		swap(a,0,--n);
	}
}

7.计数排序（线性时间排序）

    原理：数组中最大数为k，则创建一个新数组c[0...k+1]，用c数组中下标表示有多少个该数字，比如c[2]=3表示原数组有3个2，最终按序输出c[0]到c[k]即为最终数组有序结果。

void CountingSort(int a[],int n,int k){   	//k表示a[]中最大的数字 
	int c[k+1];
	int i=0;
	for(i=0;i<k+1;i++)
		c[i]=0;
	for(i=0;i<n;i++){
		int x=a[i];
		c[x]++;
	}
	for(i=0;i<=k;i++){				//c中存了几，就打印几次i 
		for(int j=1;j<=c[i];j++){
			cout<<i<<" ";
		}
	}
}