排序算法比较---C++版和java版

排序算法：

排序方法	平均时间	最坏情况	辅助空间
简单排序	O(n^2)	O(n^2)	O(1)
快速排序	O(n*log2n)	O(n^2)	O(log2n)
堆排序	O(n*log2n)	O(n*log2n)	O(1)
归并排序	O(n*log2n)	O(n*log2n)	O(n)
基数排序	O(d(n+Radix))	O(d(n+Radix))	O(Radix)

分析各种排序方法的时间和空间性能，可以得到以下结论：

1） 在平均情况下，快速排序、堆排序以及归并排序有较好的时间性能，其中以快速排序最佳，它所需要时间最少，但在最坏情况下，快速排序不如堆排序和归并排序。而堆排序与归并排序之间的比较结果是，当元素较多时，归并排序的时间性能好于堆排序，但它需要辅助空间较多，而堆排序只需要一个辅助空间。

2） 直接插入排序、冒泡排序和简单选择排序等简单排序方法的时间复杂度都为O(n^2)。在这些方法中，以直接插入排序最简单，且当待排序的元素很少，或者待排序的元素序列基本有序时，直接插入排序是很好的排序方法，因此，常将直接插入排序与其他排序方法结合在一起使用。

3）希尔排序的时间性能较难分析，但大量实验结果和实例证明他是一种很好的内部排序方法。

4） 基数排序的时间复杂度为O(d(n+Radix))也可以表示为O(d*n)。当d很小时趋向于O(n),因此，基数排序适用于元素量大，但关键字的位数较少的元素序列。

5） 由于基数排序不进行关键字比较，因此他是最稳定的排序方法。简单排序方法也是稳定的，然而，快速排序、希尔排序、堆排序等时间性能较好的排序方法都是不稳定的。因此，若按照次关键字进行排序，则需要慎重选择排序方法，但若按照主关键字进行排序，则排序方法是否稳定无关紧要。

6） 可以证明，借助于“比较”进行排序的方法在最坏情况下能够达到的最好时间复杂度是O(n*log2n).

由以上讨论可知，以上介绍的排序方法，没有哪一种是绝对最有的，每一种排序方法都有它的适用范围，在实际应用中应根据实际情况合理选择排序方法。

以下代码实现中缺少希尔排序、基数排序，待补充。。。。。。

C++

#include<iostream>
using namespace std;

template<class Type> struct ElementType
{
	Type Key;//数据元素的关键字
     //数据元素的其他数据项
};
template<class Type> struct SqList
{
	ElementType<Type> *elem;//数组elem存放数据元素，其中elem[0]闲置
	int length;//顺序表中的元素个数
//	int listsize;//顺序表的长度
};
/* 直接插入排序*/
template<class Type> void InsertSort(SqList<Type> &List)
{//O(n^2)
	ElementType<int> temp;
	for(int i=1;i<List.length;i++)
		if(List.elem[i].Key<List.elem[i-1].Key)
		{
			temp=List.elem[i];
			int j;
			for(j=i-1;temp.Key<List.elem[j].Key;j--)
				List.elem[j+1]=List.elem[j];
			List.elem[j+1]=temp;
		}
}
//*折半插入排序*/
template<class Type> void BinInsertSort(SqList<Type> &List)
{//O(n^2)
	ElementType<int> temp;
	for(int i=1;i<List.length;i++)
	{
			temp=List.elem[i];
			int low=0,high=i-1;
			while(low<=high)
			{
				int mid=(low+high)/2;
				if(temp.Key<List.elem[mid].Key) high=mid-1;
				else low=mid+1;
			}
			for(int j=i;j>low;j--) List.elem[j]=List.elem[j-1];//元素后移
			List.elem[low]=temp;//插入元素
	}
}
//交换排序之冒泡排序
#define SWAP(a,b) {int temp=a;a=b;b=temp;}
template<class Type> void BubbleSort(SqList<Type> &List)
{
	int i,j;
	for(i=0;i<List.length;i++)
		for(j=List.length-1;j>i;j--)
		{
			if(List.elem[j].Key<List.elem[j-1].Key)
				SWAP(List.elem[j].Key,List.elem[j-1].Key);
		}
}
//交换排序之快速排序
template<class Type> int Partition(SqList<Type> &List,int low,int high)
{
	ElementType<Type> elem=List.elem[low];//将字表的第一个元素作为基准元素
	Type pivotkey=elem.Key;
	int i=low,j=high;
	while(i<j)
	{
		while(i<j && List.elem[j].Key>=pivotkey) j--;
		if(i<j) {List.elem[i]=List.elem[j];i++;} 
		while(i<j && List.elem[i].Key<=pivotkey) i++;
		if(i<j) {List.elem[j]=List.elem[i];j--;}
	}
	List.elem[j]=elem;
	return j;
}
template<class Type> void QuickSort(SqList<Type> &List,int low,int high)
{
	if(low<high)
	{
		int pivot=Partition(List,low,high);
		QuickSort(List,low,pivot-1);
		QuickSort(List,pivot+1,high);
	}
}
//归并排序O(n)
template<class Type> void MergeSort(SqList<Type> &List ,int left,int right)
{
	if(left<right)
	{
		int mid=(left+right)/2;
		MergeSort(List,left,mid);
		MergeSort(List,mid+1,right);
		Merge(List,left,mid,right);
	}
}
template<class Type> void Merge(SqList<Type> &List,int left,int mid,int right)
{
	ElementType<Type> *temp=new ElementType<Type>[right-left+1];
	int i=left,j=mid+1,k=0;
	while(i<=mid && j<=right)
	{
		if(List.elem[i].Key<=List.elem[j].Key) temp[k++]=List.elem[i++];
		else temp[k++]=List.elem[j++];
	}
	while(i<=mid) temp[k++]=List.elem[i++];
	while(j<=right) temp[k++]=List.elem[j++];
	for(i=0,k=left;k<=right;) List.elem[k++]=temp[i++];
}
//简单选择排序
template<class Type> void SelectSort(SqList<Type> &List)
{
	for(int i=0;i<List.length;i++)
	{
		int small_loc=i;//记录当前最小元素的位置
		for(int j=i+1;j<List.length;j++)
		{
			if(List.elem[j].Key<List.elem[small_loc].Key)
				small_loc=j;
		}
		if(small_loc!=i)//若最小元素不在第i个位置，则将他与第i个位置对调
			{
				ElementType<Type> element=List.elem[i];
				List.elem[i]=List.elem[small_loc];
				List.elem[small_loc]=element;
			}
	}
}
//堆排序
template<class Type> void HeapAdjust(SqList<Type> &List, int i, int j)
{//除了第一个元素外，顺序表List[i...j]中元素都满足堆的定义，本函数将List中的所有元素调整为一个最大堆
	int child=2*i;
	ElementType<Type> temp=List.elem[i];//临时存放根节点
	while(child<=j) //沿大儿子向下调整
	{
		if(child<j && List.elem[child+1].Key>List.elem[child].Key) child++;
		if(temp.Key>=List.elem[child].Key) break;
		List.elem[(child/2)]=List.elem[child];
		child=2*child;
	}
	List.elem[child/2]=temp;
}
template<class Type> void HeapSort(SqList<Type> &List)
{
	int i;
	for(i=List.length/2;i>=0;i--)
		HeapAdjust(List,i,List.length-1);//初始建堆
	for(i=List.length-1;i>=0;i--)
	{
		ElementType<Type> temp=List.elem[0];//将当前堆顶元素与堆尾元素互换
		List.elem[0]=List.elem[i];
		List.elem[i]=temp;
		HeapAdjust(List,0,i-1);//将剩下的元素重新调整成堆
	}
}
int main()
{
	SqList<int> list;
	ElementType<int> p[]={{1},{2},{33},{3},{4},{5},{6},{10},{9},{7},{8},{20},{44}};
//	int a[]={2,1,3,5,4,9,6,7,8,10};
	list.length=sizeof(p)/sizeof(p[0]);
	list.elem=p;
//	InsertSort(list);
//	BinInsertSort(list);
//	BubbleSort(list);
//	QuickSort(list,1,list.length-1);
//	MergeSort(list,0,list.length-1);
//	SelectSort(list);
	HeapSort(list);
	cout<<"排序后：";
	for(int j=0;j<list.length;j++)
	{	
		cout<<list.elem[j].Key<<"   ";
	}
	cout<<endl;
}

java版

package HelpAlgri;

import java.util.Arrays;
import java.util.Random;

	public class SortAll {
		/*
		 * 折半插入排序O(n^2)
		 */
	    private static int[] Sort(int[] arr) {
	        int i, j;
	        //保存中间插入的值
	        int insertNote = 0;
	        //将待排序的数列保存起来
	        int[] array = arr;
	        System.out.println("开始排序：");
	        for (i = 1; i < array.length; i++) {
	            int low = 0;
	            int high = i - 1;
	            insertNote = array[i];
	            //不断的折半
	            while (low <= high) {
	                //找出中间值
	                int mid = (low + high) / 2;
	                //如果大于中间值
	                if (array[i] > array[mid]) {
	                    //在大于中间值的那部分查找
	                    low = mid+1;
	                } else
	                    //在小于中间值的那部分查找
	                    high = mid-1;
	            }
	          //将整体数组向后移
	            for ( j=i; j > low; j--) {
	                array[j] = array[j - 1];
	            }
	         //插入到指定的位置
	            array[low] = insertNote;
	            System.out.println(Arrays.toString(array));
	        }
	        System.out.println("排序之后：");
	        System.out.println(Arrays.toString(array));
	        return array;
	    }
	    /*
	     * 直接插入排序O(n^2)
	     */
	    public static int[] InsertSort(int[] arr){
	    	int[] array=arr;
	    	int i,j,temp;
	    	for(i=1;i<array.length;i++){	    		
	    		if(array[i]<array[i-1]){
	    			temp=array[i];
	    			for(j=i-1;j>=0 && temp<array[j];j--){
	    				array[j+1]=array[j];
	    			}
	    			array[j+1]=temp;
	    		}
	    	}
	        System.out.println("排序之后：");
	        System.out.println(Arrays.toString(array));
	    	return array;
	    }
	    /*
	     * 交换排序之冒泡排序O(n^2)
	     */
	    public static int[] BubbleSort(int[] arr){
	    	int[] array=arr;
	    	int i,j,temp;
	    	for(i=0;i<array.length;i++){
	    		for(j=array.length-1;j>i;j--){
	    			if(array[j]<array[j-1]){
	    				temp=array[j];
	    				array[j]=array[j-1];
	    				array[j-1]=temp;
	    			}
	    		}
	    	}
	    	System.out.println("排序之后：");
		    System.out.println(Arrays.toString(array));
	    	return array;
	    }
	    /*
	     * 交换排序之快速排序O(log2n)
	     */
	    public static int Partition(int[] arr,int low,int high)
	    {
	    	int[] array=arr;
	    	int elem=array[low];
	    	int i=low,j=high;
	    	while(i<j){
	    		while(i<j && array[j]>=elem) j--;
	    		if(i<j) {array[i]=array[j];i++;}
	    		while(i<j && array[i]<=elem) i++;
	    		if(i<j) {array[j]=array[i];j--;}
	    	}
	    	array[j]=elem;
	    	return j;
	    }
	    public static int[] QuickSort(int[] arr,int low,int high){
	    	int[] array=arr;
	    	if(low<high){
	    		int Pivot=Partition(array,low,high);
	    		QuickSort(array,low,Pivot-1);
	    		QuickSort(array,Pivot+1,high);
	    	}
	    	return array;
	    }
	    /*
	     * 归并排序
	     */
	    public static int[] MergeSort(int[] arr,int left,int right){
	    	int[] array=arr;
	    	if(left<right){
	    		int mid=(left+right)/2;
	    		MergeSort(array,left,mid);
	    		MergeSort(array,mid+1,right);
	    		Merge(array,left,mid,right);
	    	}
	    	return array;
	    }
	    public static int[] Merge(int[] arr,int left,int mid,int right){
	    	int[] array=arr;
	    	int[] temp=new int[right-left+1];
	    	int i=left,j=mid+1,k=0;
	    	while(i<=mid && j<=right){
	    		if(array[i]<array[j]) temp[k++]=array[i++];
	    		else temp[k++]=array[j++];
	    	}
	    	while(i<=mid) temp[k++]=array[i++];
	    	while(j<=right) temp[k++]=array[j++];
	    	for(i=0,k=left;k<=right;) array[k++]=temp[i++];
	    	return array;
	    }
	    /*
	     * 简单选择排序
	     */
	    public static int[] SelectSort(int[] arr){
	    	int[] array=arr;
	    	for(int i=0;i<array.length;i++){
	    		int small_loc=i;
	    		for(int j=i+1;j<array.length;j++){
	    			if(array[j]<array[small_loc])
	    				small_loc=j;
	    		}
	    		if(small_loc!=i){
	    			int temp=array[i];
	    			array[i]=array[small_loc];
	    			array[small_loc]=temp;
	    		}
	    	}
	    	System.out.println("排序之后：");
		    System.out.println(Arrays.toString(array));
	    	return array;
	    }
	    /*
	     * 堆排序
	     */
	    public static void HeapSort(int[] arr){
	    	int i;
	    	for(i=arr.length/2;i>=0;i--){//初始建堆
	    		HeapAdjust(arr,i,arr.length-1);
	    	}
	    	for(i=arr.length-1;i>=0;i--){//将当前堆顶元素与堆尾元素互换
	    		int temp=arr[0];
	    		arr[0]=arr[i];
	    		arr[i]=temp;
	    		HeapAdjust(arr,0,i-1);//将剩下的元素重新调整成堆
	    	}
	    }
	    public static void HeapAdjust(int[] arr,int i,int j){
	    	int child=2*i;
	    	int temp=arr[i];//临时存放根节点
	    	while(child<+j){ //沿大儿子向下调整
	    		if(child<j && arr[child+1]>arr[child]) child++;
	    		if(temp>=arr[child]) break;
	    		arr[child/2]=arr[child];
	    		child=2*child;
	    	}
	    	arr[child/2]=temp;
	    }
	    public static void main(String[] args) {
	        Random random = new Random();
	        int[] array = new int[10];
	        for (int i = 0; i < 10; i++) {
	            array[i] = Math.abs(random.nextInt() % 100);
	        }
	        System.out.println("排序之前：");
	        System.out.println(Arrays.toString(array));            
//	        SortAll.Sort(array);//折半插入排序
//	        SortAll.InsertSort(array); //直接插入排序
//	        SortAll.BubbleSort(array); //冒泡排序
//	        SortAll.BubbleSort(array);//选择排序
	        SortAll.HeapSort(array);//堆排序
	        System.out.println(Arrays.toString(array));
//	        System.out.println(Arrays.toString(SortAll.QuickSort(array,0,array.length-1)));//快速排序
//	        System.out.println(Arrays.toString(SortAll.MergeSort(array,0,array.length-1)));//归并排序
	    }
	}