排序算法锻炼编程思维：冒泡，选择，插入，快速，归并

冒泡，选择，插入，快速，归并这五个排序是所有编程语言初学者所遇到过的，可能在实际的编程应用中不会遇到，

但对于锻炼编程思维，还是有很好的作用。

冒泡排序
冒泡排序的就是让大的数向后冒，让小的数向前冒。通过前后两个数据比较，不断将大的元素移动到尾部。

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr= {-10, 2, 3, 246, -100, 0, 5};
        for(int i=0;i<arr.length-1;i++) {
            for(int j=0;j<arr.length-i-1;j++) {
                if(arr[j]>arr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int a:arr) {
            System.out.print(a+" ");
        }
    }

选择排序
选择排序就是把无序区的最小元素与首元素互换位置，然后将有序区的区间扩大一位，直到所有无序区都变成有序区。

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr= {-10, 2, 3, 246, -100, 0, 5};
        for(int i=0;i<arr.length-1;i++) {
            int k=i;
                  //位置还不确定的数据
            for(int j=i+1;j<arr.length;j++) {
                if(arr[j]<arr[k]) {
                    k=j;
                    //遍历找到比k小的索引，然后把j赋给k；
                }
            }
            if(i!=k) {
                int temp=arr[i];
                arr[i]=arr[k];
                arr[k]=temp;
            }
        }
        for(int a:arr) {
            System.out.print(a+" ");
        }
    }

插入排序
插入排序是把数组分为有序区和无序区两块，然后将无序区的指定索引的数插入到有序区的指定位置，假设第0个元素是已经排序好的，无序区第一次循环从1开始遍历，设置一个temp，找到要插入的位置，把temp插入到有序区指定位置。

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr= {-10, 2, 3, 246, -100, 0, 5};
        int j=0;
        for(int i=1;i<arr.length;i++) {
            int temp=arr[i];
            //temp存放将要插入的数据
            if(arr[i]<arr[i-1]) {
                for( j=i-1;j>=0&&arr[j]>temp;j--) {
                    arr[j+1]=arr[j];
                    //temp的位置空出来，把第j个的值赋给第j+1个；
                }
                arr[j+1]=temp;
            }
        }
        for(int a:arr) {
            System.out.print(a+" ");
        }
    }

快速排序
快速排序主要思想方法有两个：一趟排序和分治；一趟排序完成数组的第一次排序，设置一个键值data,找到对应正确的位置，data的值插进去；分治就是用分而治之的思想，将键值左右两侧分为两个部分，再调用递归，将左边的部分再分为两个部分，将右边的部分再分为两个部分，依此类推，直到将数组排列完。

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = { -10, 2, 3, 246, -100, 0, 5 };
        QuickSort(arr, 0, arr.length - 1);
        for (int a : arr) {
            System.out.print(a + " ");
        }
    }

    public static int PartSort(int arr[], int low, int high) {
        int data = arr[low];
        /*
         * 一次遍历的方法：插空法 定义一个data将arr[low]存起来，并把这个位置挖空
         */
        while (low < high) {
            while (low < high && arr[high] >= data) {
                high--;
            }
            arr[low] = arr[high];
            /**
             * 从high，也就是后面往前遍历 找到比键值小的数据 插入到前面留下的空中 high位再次留下空来
             */

            while (low < high && arr[low] <= data) {
                low++;
            }
            arr[high] = arr[low];

        }
        arr[low] = data;
        /*
         * 循环退出后 low和high重合 将将键值赋给第low，并将low返回
         */
        return low;
    }

    public static void QuickSort(int arr[], int low, int high) {
        if(low<high) {
            //防止发生栈溢出异常
            int index = PartSort(arr, low, high);
            QuickSort(arr, low, index - 1);
            QuickSort(arr, index + 1, high);    
        }

    }

归并排序
归并排序要点有两个：对于两个有序数组的合并；递归思想。合并两个有序数组要定义一个新数组temp来存放合并后的数组，并通过判断条件让新的数组在合并后成为有序数组。归并的时候让数组调用自己，一步步将数组的长度变小，当子数组被分治到只有一个元素的时候，子数组也就是有序数组，这时候可以调用合并有序数组的方法，整个数组也就完成了排序。

    public static void main(String[] args) {
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        mergeSort(a, 0, a.length - 1);
        System.out.println("排好序的数组：");
        for (int e : a)
            System.out.print(e + " ");

    }

    //两路归并算法，两个排好序的子序列合并为一个子序列
    public static  void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];//辅助数组
        int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }

        while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while(p2<=right) tmp[k++]=a[p2++];//如果第二个序列未检测完，直接将后面所有元素加到合并的序列中

        //复制回原数组
        for (int i = left; i <=right; i++)
            a[i]=tmp[i];
    }


    public static void mergeSort(int [] a,int start,int end){
        if(start<end){//当子序列中只有一个元素时结束递归
            int mid=(start+end)/2;//划分子序列
            mergeSort(a, start, mid);//对左侧子序列进行递归排序
            mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
            merge(a, start, mid, end);//合并
            System.out.println("start = " + start + ", mid = " + mid+ ", end = " + end);

        }
    }