总结：各种排序算法

排序算法比较：

排序算法	平均时间复杂度	最差时间复杂度	空间复杂度	稳定性
冒泡排序	O（n^2）	O（n^2）	O（1）	稳定
选择排序	O（n^2）	O（n^2）	O（1）	不稳定 （交换时）
插入排序	O（n^2）	O（n^2）	O（1）	稳定
归并排序	O（n*logn）	O（n*logn）	O（n）	稳定
快速排序	O（n*logn）	O（n^2）	O（n）	不稳定

冒泡排序：

	public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int e = arr.length - 1; e > 0; e--) {
			for (int i = 0; i < e; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(arr, i, i + 1);
				}
			}
		}
	}

	public static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] ^ arr[j];
		arr[j] = arr[i] ^ arr[j];
		arr[i] = arr[i] ^ arr[j];
	}

选择排序：

	public static void selectionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			}
			swap(arr, i, minIndex);
		}
	}

	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

插入排序：

    public static void insertSort(int[] arr){
        if(arr==null||arr.length<2){
            return;
        }
        for(int i=1;i<arr.length;i++){
            while (i>0&&arr[i]<arr[i-1]){
                swap(arr,i,i-1);
                i--;
            }
        }
    }
    public static void swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

归并排序：

package chapter2;

public class P79_mergeSort {
    public static void sort(int[] arr){
        if(arr==null||arr.length<2)
            return;
        mergeSort(arr,0,arr.length-1);
    }

    public static void mergeSort(int[] arr,int l,int r){
        if(l==r) return;	//is very important!!
        int mid=l+((r-l)>>1);	//() is very important.
        mergeSort(arr,l,mid);//sort left part
        mergeSort(arr,mid+1,r);//sort right part
        merge(arr,l,mid,r);
    }

    public static void merge(int[] arr,int l,int m,int r){
        int[] help=new int[r-l+1];
        int i=0;
        int p1=l;
        int p2=m+1;
        while (p1<=m&&p2<=r){
            help[i++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
        }
        while (p1<=m){
            help[i++]=arr[p1++];
        }
        while (p2<=r){
            help[i++]=arr[p2++];
        }
        for(i=0;i<help.length;i++){
            arr[l+i]=help[i];//start at l !!!
        }
    }

    public static void main(String[] args) {
        int[] arr=new int[]{1,3,5,7,9,2,4,6,8};
        sort(arr);
        for(int num:arr){
            System.out.print(num+" ");
        }
    }
}

快速排序：

package chapter2;

public class P79_quickSort {
    public static void swap(int[] data,int i,int j){
        int temp=data[i];
        data[i]=data[j];
        data[j]=temp;
    }

    public static void quickSort(int[] arr){
        if(arr==null||arr.length<2) return;

        sort2(arr,0,arr.length-1);
    }

    public static void sort2(int[] arr,int l,int r){
        if(l>=r) return;
       // swap(arr, l + (int) (Math.random() * (r - l + 1)), r);//加这一行，代表随机快排
        int[] p=partition2(arr,l,r);//p[0]--p[1]之间都相等
        sort2(arr,l,p[0]-1);//左边继续
        sort2(arr,p[1]+1,r);//右边继续
    }

    public static int[] partition2(int[] arr,int l,int r){
        if(l>=r){
            return new int[]{-1,-1};
        }
        int less=l-1;
        int more=r;
        int index=l;
        while (index<more){
            if(arr[index]<arr[r]){
                swap(arr,++less,index++);
            }else if(arr[index]>arr[r]){
                swap(arr,--more,index);//index不加加，需要停在原地继续判断
            }else {
                index++;
            }
        }
        swap(arr,more,r);
        return new int[]{less+1,more};
    }

    public static void main(String[] args) {
        int[] data={2,4,6,8,1,3,5,7};
        quickSort(data);
        for(int num:data){
            System.out.print(num+" ");
        }
    }
}

堆排序：

package chapter2;

public class P79_heapSort {

    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 size = arr.length;
        swap(arr, 0, --size);
        while (size > 0) {
            heapify(arr, 0, size);
            swap(arr, 0, --size);
        }
    }

    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;
        }
    }

    public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

    public static void swap(int[] arr,int i,int j){
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[i]^arr[j];
        arr[i]=arr[i]^arr[j];
    }

    public static void main(String[] args) {
        int[] arr={1,3,5,7,9,2,4,6,8};
        heapSort(arr);
        for(int num:arr){
            System.out.print(num+" ");
        }
    }
}