常见的排序算法

一：冒泡排序：是将一个杂乱无序的数组对象，通过相应的算法进行比较得出一个有顺序的数组序列,实现的具体细节是相邻的数据两两比较逐渐将最大的数给展现出来，加入有n个数据那么就需要遍历n-1次（外层循环控制着遍历的次数，外层循环没执行一次就说明出来了一个最大的数）

内层循环控制着数组中的两个数据进行比较

模拟一下简单的：
40-12

总共需要三次遍历数组我们是清楚的：

第一次遍历：第一次比较：0，4，-1，2

      第二次比较：0，-1，4，2

                      第三次比较：0，-1，2，4              这里已经把最大的数据给提取出来了，那么最大的数据就不用下次遍历的时候再遍历它了

第二次遍历：第一次比较：-1，0，2，4

                      第二次比较：-1，0，2，4            倒数第二个大数也相应的出来了

第三次遍历：第一次比较：-1,0,2,4                     倒数第三个大数也出来了，排序完成

在代码中表示就是：

public class BubbleSort {     public static void sortList(int[] list){          int len = list.length;         //对数组进行遍历          for(int i = 1;i<len;i++){            //对数组中的数据进行两两比较             for(int k = 0;k < len - i;k++ ){                           //如果前面的元素比后面的元素大进行交换                           if(list[k] > list[k + 1]){                             int temp = list[k];                             list[k] = list[k + 1];                             list[k + 1] = temp;                         }                     }          }   }      public static void main(String[] args){                int[] list = {4,0,-1,2}                sort(list);                for(int i = 0;i<list.length;i++){                     System.out.print(list[i]);                }         }}

二：插入排序：重复的将新的元素插入到一个排好序的子线性表中，直到整个线性表排好序了

使用插入排序对{2，0，9，3，-1}进行排序

插入排序前已经有排好序的列表{2}

第一次插入0：{2，0}  然后比较0和2，进行一次比较得{0，2}

第二次插入9：{0,2,9} 然后比较9和2得{0，2，9}比左边得大退出

第三次插入3：{0，2，9，3}，然后3和9比较，{0，2，3，9}，然后3和2比较比左边得大退出

第四次插入-1：{0，2，3，9，-1}开始比较

然后-1和9比较得{0，2，3，-1，9}，

然后-1和3比较得{0，2，-1，3，9}，

然后-1和2比较得{0，-1，2，3，9}

然后-1和0比较得{-1，0，2，3，9} 直到当前元素1比他左边得大或者比到了最前面得一个元素

实现如下：

//插入排序    public static void insertSort(int[] list){        int len = list.length;        //确定插入的次数，每插入一次排序一次        for(int i = 1;i < len;i++){            int currentItem = list[i];            //让其从后向前比这样更高效一点            int k = i;            for(;k > 0 && currentItem < list[k - 1];k--){                    //交换元素                    int temp = list[k];                    list[k] = list[k - 1];                    list[k - 1] = temp;            }            list[k] = currentItem;        }    }

三：归并排序：将数组分为两半，对每一部分递归地应用归并排序。在两部分都排好序后，对他们进行归并

 //归并排序：1:分解数组    public static void mergerSort(int[] list){        //如果数组的长度大于1的话继续进行分割数组        if(list.length > 1) {            //创建第一部分的数组分割，加入是奇数的话            int[] firstPage = new int[list.length / 2];            //复制数组内容到新数组            System.arraycopy(list, 0, firstPage, 0, list.length / 2);            //继续分割数组            mergerSort(firstPage);            //处理余下的另外一部分数组            int[] lastPage = new int[list.length - list.length/2];            //复制数组到新数组中去            System.arraycopy(list,list.length/2,lastPage,0,list.length - list.length/2);            //继续分割该数组            mergerSort(lastPage);            //开始合并            meger(firstPage,lastPage,list);        }    }    //归并排序：2：归并数组    public static void  meger(int[] list1,int[] list2,int[] temp){        int c1 = 0;    //index of list1        int c2 = 0;    //index of list2        int c3 = 0;    //index of temp        //第一个列表的        while(c1 < list1.length && c2 < list2.length){            if(list1[c1] < list2[c2]){                temp[c3++] = list1[c1++];            }else{                temp[c3++] = list2[c2++];            }        }        //确保第一个列表的元素比较完了        while(c1 < list1.length){            temp[c3++] = list1[c1++];        }        //确保第二个列表的元素也比较完了        while(c2 < list2.length){            temp[c3++] = list2[c2++];        }    }

四：快速排序：此排序的算法的思想主要是找到一个主元的东西，然后安排哨兵从前向后和从后向前与主元进行比较；从前向后比较遇到比主元大的数就停止了记录下现在的i，接着就是从后向前进行比较遇到比主元小的数停止并且记录下哨兵的当前下标j，然后两者进行交换，继续进行从前向后和从后向前比较，直到i >= j，并将主元安排到j的位置，分别对j以前的数组和j以后的数组进行递归快速排序，

QuickSort.java

public class QuickSort {    public static void main(String[] args){        int[] a = {-1,9,0,8,1,10,80,20,30,7,66,6};        quickSort(a,0,a.length-1);        System.out.println(a);        for(int i = 0;i<a.length;i++){            System.out.print(a[i] + " ");        }    }    public static void quickSort(int[] array,int first,int last){        //分两部分进行排序，先排序比主元小的所有元素，在排序比主元大的所有元素        if(last > first){            int pivotLocation = positionPivot(array,first,last);            quickSort(array,first,pivotLocation-1);            quickSort(array,pivotLocation+1,last);        }    }    public static int positionPivot(int[] arr,int start,int last){         int pivot = arr[start];         int i = start + 1;         int j = last;         while(i < j){             while(i<j && arr[i] <= pivot){                 //遇到一个比pivot大的数就停止毕竟从左向右找的是比主元小的数                 i++;             }             //当两个哨兵碰到一起的时候j也要减一             while(i<=j && arr[j] > pivot){                 j--;             }             if(i < j){                 //互换元素                 int temp =arr[j];                 arr[j] = arr[i];                 arr[i] = temp;             }         }//         //这种情况是主元是数列中最小的数了//         while(j > start && arr[j] >= pivot){//             j--;//         }         //大多数情况下应该是主元都是大于arr[j]的情况（如果主元被移动）（主元被移动的条件是一个数比他大就行了）         if(pivot > arr[j]){             arr[start] = arr[j];             arr[j] = pivot;             return j;         }else{             //主元没有移动说明它是最小的元素             return start;         }    }}