七种常用排序算法的java实现

一、交换方法(被调用来交换值)

	/**
	 * 交换方法
	 * @param a
	 * @param j
	 * @param i
	 */
	private static void swap(int[] a, int j, int i) {
		// TODO Auto-generated method stub
		int temp = a[j];
		a[j] = a[i];
		a[i] = temp;
	}

二、交换算法
1.选择排序

/**
	 * 选择排序  每次都选择最小的
	 * 时间复杂度O(N^2)
	 * 空间复杂度O(1)
	 */
	public static void selectionSort(int[] a) {
		if(a==null||a.length<2)
			return;
		for(int i = 0;i < a.length-1;i++) {
			int min = i;
			for(int j = i+1;j < a.length;j++) {
				min = a[j]<a[min]?j:min;   //选择最小的
			}
			swap(a,i,min);	//交换值
		}
		
	}

2.冒泡算法

/**
	 * 冒泡排序   每次选择最大的，放到最后
	 * 时间复杂度O(N^2)
	 * 空间复杂度O(1)
	 */
	public static int[] bubleSort(int[] a) {
		if(a==null||a.length<2) {
			return a;
		}else {
			for(int i = a.length-1;i > 0; i--) {
				for(int j = 0;j<i;j++) {
					if(a[j]>a[j+1]) {
						swap(a,j,j+1);//交换值
					}
				}
			}
			return a;
		}
	}

3.插入排序

/**
	 * 插入排序  每次都往已经排好的队列插入数据
	 * 时间复杂度O(N^2)
	 * 空间复杂度O(1)
	 */
	public static int[] insertionSort(int[] a) {
		if(a==null||a.length<2)
			return a;
		for(int i = 1;i < a.length;i++) {
			for(int j = i-1;j >= 0 && a[j] > a [j+1];j--) {
				swap(a, j, j+1);
			}
		}
		return a;
	}

4.希尔排序

/**
*最坏时间复杂度：O(n2)
*稳定想：不稳定
*/
public static void shellSort(int[] a){
		int len = a.length;
		int gap = len/2;
		while(gap>0){
			for(int j = gap;j<len;j++){
				int i = j;
				while(i>=gap&&a[i-gap]>a[i]){
					int tmp = a[i];
					a[i] = a[i-gap];
					a[i-gap] = tmp;
					i = i-gap;
				}
			}
			gap = gap/2;
		}
		
		
	}

5.归并排序

	/**
	 * 归并排序  运用递归   
	 * 时间复杂度:O(nlogn)
	 * 空间复杂度O(n)
	 * @param a
	 * @param begin
	 * @param end
	 */
	public static void mergeSort(int[] a,int begin,int end) {
        if (begin < end) {
		int mid = begin+((end-begin)>>1);
        	mergeSort(a,begin,mid);
        	mergeSort(a,mid+1,end);
        	merge(a,begin,mid,end);
        }
	}
	/**
	 * 归并运算合起来
	 * @param a
	 * @param begin
	 * @param mid
	 * @param end
	 */
	private static void merge(int[] a, int begin, int mid, int end) {
		// TODO Auto-generated method stub
		int[] help = new int[end-begin+1];
		int i = 0;
		int p1 = begin;
		int p2 = mid+1;
		while(p1<=mid && p2<=end) {
			help[i++] = a[p1]<a[p2]?a[p1++]:a[p2++];
		}
		while(p1<=mid) {
			help[i++] = a[p1++];
		}
		while(p2<=end) {
			help[i++] = a[p2++];
		}
		for(i = 0;i<help.length;i++)
			a[begin+i] = help[i];
		
	}

6.快速排序

/**
	 *找一个基准，left和right，将基准赋值给left和right重合的位置
	 *左边都比它小，右边都大于它
	 *继续递归排序
	 * 时间复杂度 nlogn
	 * 空间复杂度 nlogn
	 */
public static void quickSort2(int a[], int low, int hight) {
		int i, j, index;
        if (low > hight) {
            return;
        }
        i = low;
        j = hight;
        index = a[i]; // 用子表的第一个记录做基准
        while(i<j) {
        	while(i<j && a[j]>=index) {
        		j--;
        	}
        	if(i<j) {
        		int temp = a[i];
        		a[i] = a[j];
        		a[j] = temp;
        	}
        	while(i<j && a[i]<index) {
        		i++;
        	}
        	if(i<j) {
        		int temp = a[i];
        		a[i] = a[j];
        		a[j] = temp;
        	}
        }
        
        quickSort2(a, low, i-1);
        quickSort2(a, i+1, hight);
   
        
	}

7.堆排序

/**
 * 堆排序
 * 1）将数组变成大根堆
 * 2）把最后一个和堆顶位置交换 堆长度减1
 * 3）从0到最后做 heapify
 * 解决贪心问题，优先性排序
 *时间复杂度O(N*logN)  额外空间 O(1)
 * @author hasee
 *
 */
public static void heapSort(int[] arr) {
		if(arr == null || arr.length < 2) {
			return;
		}
		for(int i = 0;i < arr.length;i++) {
			heapInsert(arr, i);//先调成大根堆
		}
		//开始排序，每次都将最大值调到最后
		int heapSize = arr.length;
		swap(arr,0,--heapSize);
		while(heapSize > 0) {
			heapify(arr, 0, heapSize);
			swap(arr, 0, --heapSize);
		}
		
	}
	/**子节点上升
	 * 将每个子节点与父类进行比较，并交换
	 * @param arr
	 * @param index
	 */
	public static void heapInsert(int[]arr,int index) {
		while(arr[index]>arr[(index-1)/2]) {
			swap(arr,index,(index-1)/2);
			index=(index-1)/2;
		}
	}
	
	/**
	 * 父节点下沉过程
	 * @param arr
	 * @param index
	 * @param heapSize
	 */
	public static void heapify(int[] arr,int index,int heapSize) {
		int left = index*2+1;
		while(left<heapSize) {
			int largest = (left+1<heapSize && arr[left+1]>arr[left]) ?(left+1):left;
			largest = arr[largest] > arr[index] ? largest : index;
			if(largest == index)
				break;
			swap(arr,index,largest);
			index = largest;
			left = index*2+1;
		}
	}