各种排序算法

排序算法时间复杂度比较

import java.util.Arrays;


public class Main {
	public static void main(String[] args) {
		 int a[] = new int[35];
		for (int i = 0; i < 35; i++) {
			a[i] = (int) (Math.random() * 900560);
		} 
//		int a[]={4,5,3,102,4,85,7,9,8,5,4,10,22,54,24,3512,154646,124};
		System.out.print("初始数列：");print(a);
		/**
		 * 希尔排序
		 */
		ShellSort(Arrays.copyOf(a, a.length)); 
		/**
		 * 插入排序
		 */
		InserSort(Arrays.copyOf(a, a.length),0,a.length-1); 
		/**
		 * 折半插入排序
		 */
		BinaryInserSort(Arrays.copyOf(a, a.length)); 
		/**
		 * 冒泡排序
		 */
		sort(Arrays.copyOf(a, a.length)); 
		/**
		 * 选择排序
		 */
		SelectSort(Arrays.copyOf(a, a.length));
		/**
		 * 快速排序
		 */
		long start = System.currentTimeMillis();
		int quick[]=Arrays.copyOf(a, a.length);
		QuickSort(quick,0,a.length-1);
		long end = System.currentTimeMillis();
		System.out.print("快速排序：("+(end-start)+"ms)");
		print(quick);
		/**
		 * 三路划分快速排序
		 */
		long start1 = System.currentTimeMillis();
		QuickSort(a,0,a.length-1);
		long end1 = System.currentTimeMillis();
		System.out.print("三路划分快速排序：("+(end1-start1)+"ms)");
		print(a);
		 /**
		  *  Arrays.sort快速排序
		  */
		long start2 = System.currentTimeMillis();
		Arrays.sort(quick,0,a.length-1);
		long end2 = System.currentTimeMillis();
		System.out.print("Arrays.sort()排序：("+(end2-start2)+"ms)");
		
		
	}

	/**
	*@param 希尔排序   ，不稳定排序，时间复杂度n^1.25	 */
	private static void ShellSort(int[] arr) {
		int  temp,gap=arr.length,k; 
		long start = System.currentTimeMillis();
		do {
			gap=gap/3+1;//增量(组数)
			for (int i = gap; i < arr.length; i++) {
				if(arr[i]<arr[i-gap]){
					temp=arr[i];k=i-gap;
					do {
						arr[k+gap]=arr[k];
						k=k-gap;
					} while (k>=0&&temp<arr[k]);
					arr[k+gap]=temp;
				}
			}
			
			
		} while (gap>1);
		long end = System.currentTimeMillis();
		System.out.print("希尔排序：("+(end-start)+"ms)");
		print(arr);
	}

	/**
	*@param 折半插入排序   稳定排序，排序码比较次数与初始序列无关
	*都经过log2(i)+1次比较，时间复杂度O(n*log2n)   
	 */
	private static void BinaryInserSort(int[] arr) {
		 
		int  temp,left,right,mid,k; 
		long start = System.currentTimeMillis();
		for (int i = 1; i <arr.length; i++) {
			 temp=arr[i];left=0;right=i-1;
			 while (left<=right) {
				mid=(left+right)/2;
				if (temp<arr[mid]) {
					right=mid-1;
				}
				else {
					left=mid+1;
				}
			}
			 for (k = i-1; k >=left; k--) arr[k+1]=arr[k];
			 arr[left]=temp;
		}
		long end = System.currentTimeMillis();
		System.out.print("折半插入：("+(end-start)+"ms)");
		print(arr);
		
		
	}

	/**
	*@param 插入排序   稳定排序，时间复杂度O(n^2)
	 */
	private static void InserSort(int[] arr,int left,int r) {
		int  temp; 
		long start = System.currentTimeMillis();
		for (int i = left+1; i <=r; i++) {
			if (arr[i]<arr[i-1]) {
			int j=i-1;
			temp=arr[i];
			while (j>=left&&arr[j]>temp) {
				arr[j+1]=arr[j];
				j--;
			}
			arr[j+1]=temp;
			}
		}
		long end = System.currentTimeMillis();
		System.out.print("插入排序：("+(end-start)+"ms)");
		print(arr);
	}

	/**
	*@param 快速排序(对每个元素进行定位),不稳定排序，时间复杂度O(nlog2(n))
	 */
	private static void QuickSort(int[] a,int left,int  right) {
//		if (right-left<=25) {
//			InserSort(a,left,right);
//		}
		if(left<right){
			 int pivotpos=partition(a,left,right);//pos基准元素位置（即定位）
			 QuickSort(a, 0, pivotpos-1);//左侧子序列
			 QuickSort(a, pivotpos+1, right);//右侧子序列
		}
		
	}

	/**
	*@param 快速排序   获取pos基准元素位置
	 */
	private static int partition(int[] a, int left, int right) {
		 int pos=left;
		 int center=a[left];
		for (int i = left+1; i <=right; i++) {
			if(a[i]<center){
				pos++;
				if (pos!=i) {
				 int  temp=a[pos];
				a[pos]=a[i];
				a[i]=temp;
				}
			}
		}
		a[left]=a[pos];
		a[pos]=center;
		return pos;
	}

	/**
	 * 三路划分的快速排序算法。不稳定排序
	 */
	
	public static void QuickSort2(int[] a, int Left, int Right) {
		int left, right, temp, middle;
		middle = a[(Left + Right) / 2];
		left = Left;
		right = Right;
		do {
			// 从左边寻找大于中间值的下标
			while (left < Right && a[left] < middle) {
				left++;
			}
			// 从右边寻找小于中间值的下标
			while (right > Left && a[right] > middle) {
				right--;
			}
			// 找到一对，对换他们
			// 注意：如果少了等于号，会长生死循环
			if (left <=right) {
				temp = a[left];
				a[left] = a[right];
				a[right] = temp;
				left++;
				right--;
			}

		} while (right >= left); // 直到左右对换

		if (Left < right) {
			QuickSort(a, Left, right);
		}

		if (Right > left) {
			QuickSort(a, left, Right);
		}
	}
	/**
	*@param 选择排序 时间复杂度O(n^2) ,为不稳定排序    
	 */
	private static void SelectSort(int[] a) {
		long start = System.currentTimeMillis();
		for (int i = 0; i < a.length-1; i++) {
			int t=i;
			for (int j = i+1; j < a.length; j++) {
				if(a[j]<a[t]){t=j;}//找出小的元素对应的下标
			}
			int temp=a[i];
			a[i]=a[t];
			a[t]=temp;
		}
		long end = System.currentTimeMillis();
		System.out.print("选择排序：("+(end-start)+"ms)");
		print(a);
		
	}

	/**
	*@param 冒泡排序 时间复杂度O(n^2) ,为稳定排序 
	 */
	private static void sort(int[] arr) {
		long start = System.currentTimeMillis();
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if(arr[j]<arr[i]){
					arr[i]=arr[i]+arr[j];
					arr[j]=arr[i]-arr[j];
					arr[i]=arr[i]-arr[j];
				}
			}
		}
		long end = System.currentTimeMillis();
		System.out.print("冒泡排序：("+(end-start)+"ms)");
		print(arr);
		
	}

	/**
	*打印
	 */
	private static void print(int[] arr) {
		 for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		 System.out.println();
	}
}