常见的排序算法—冒泡排序、插入排序、希尔排序、快速排序

1.冒泡排序
冒泡排序的原理就是比较相邻的两个元素，如果第一个比第二个大，就交换他们两个的位置，这样就能把较大的那个数向后移，最终将最大的数排到最后面，做循环操作，每一次循环都由一个最大项排到正确的位置。
代码实现：

public static void bubbleSort(int[] array) {
	    for (int i = 0; i < array.length - 1; i++) {
	    	// 无序区间是 [0, arrya.length - i)
			boolean sorted = true;
			//较大的数往后冒
	        for (int j = 0; j < array.length - i - 1; j++) {
	            if (array[j] > array[j + 1]) {
	                swap(array, j, j + 1);
	                sorted = false;
				}
			}

	        if (sorted) {
	        	break;
			}
		}
	}

2.插入排序
插入排序的工作原理是通过构建有序数列，对于未排序的数据，在已经排序好的有序序列从后向前扫描，找到相应的位置并插入。
代码实现：

public static void insertSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            int cur=array[i+1];
            int j=i;
            while(j>=0&&array[j]>cur){   //从已经排好序的有序序列从后往前遍历
                array[j+1]=array[j];
                j--;
            }
            array[j+1]=cur;  //将未排好的元素插入到已经排序完毕的序列当中
        }
    }

3.希尔排序
希尔排序的工作原理与插入排序的工作原理类似，可以说是插入排序的一种高速而稳定的改进版本，它将原来要排序的序列分成一些子序列，在对每个子序列进行插入排序。
*注意：划分子序列并不是将原始列表划分为含有连续元素的子序列，而是将每个给定的间隔的元素组成的子序列。

代码实现：

//将原始序列划分为若干个间隔为gap的子序列
   private static void insertSortWithGap(int[] array, int gap) {
		for (int i = 0; i < array.length - gap; i++) {
			int key = array[i + gap];
			int j;
			for (j = i; j >= 0 && key < array[j]; j -= gap) {
				array[j + gap] = array[j];
			}
			array[j + gap] = key;
		}
	}

	public static void shellSort(int[] array) {
	    int gap = array.length;
	    while (true) {
	        gap = gap / 3 + 1;
	        insertSortWithGap(array, gap);
	        if (gap == 1) {
	            return;
			}
		}
	}

4.快速排序
快速排序的原理是通过一趟排序将将要排序的数据分割成独立的两部分，其中一部分的所有值都要比另一部分的数据小，就是在原始数据中选定一个基准值（pivot),比基准值小的组放左边，比基准值大的组放右边。再对分出来的两个组做同样的操作，需要用到递归的思想。
代码实现：

//将两个元素交换位置
            public static  void swap(int[] array,int m,int n){
                int flag=array[m];
                array[m]=array[n];
                array[n]=flag;
            }
            //将原始序列分组，小于基准值的元素放左边，大于基准值的元素放右边
            public static int partition(int[] array,int left,int right){
                int poivt=array[left];
                int low=left;
                int high=right;
                while (low<high){
                    while (low<high&&array[low]<=poivt){
                        low++;
                    }
                    while (low<high&&array[high]>=poivt){
                        high--;
                    }
                    swap(array,low,high);
                }
                swap(array,left,low);
                return low;
            }
            public static void quick1(int[] array,int left,int right){
                if(left>=right){
                    return;
                }
                int low=partition(array,left,right);
                //将左右两边的组重复做partition的操作
                quickSort(array,left,low);
                quickSort(array,low+1,right);
            }