归并排序，插入排序，快速排序，冒泡排序，选择排序的思想

简单的梳理一下我对几种简单算法的思想的认识，代码我都是copy的，网上有很多前辈的代码是不错的。我这里就不去再次实现了，虽然之前基本都写过。

一.归并排序：
先递归：
一个数组，可以看做是由两个子数组构成的，而这两个数组，也可以当成是由两个子数组构成的。。。。不断直到当这个数组中只有一个元素的时候(起始位置的下标和终止位置的下标相等)。
再合并：
先申请一块数组存放这两个数组的值，排序完成然后存回原数组对应的位置。
当两个数组中有其中一个已经全部放入temp数组的时候，就将另一个数组的直接放入最后就好。
时间复杂度：O(n log n)

归并排序是基于分治法的
分治法的一般的求解步骤为：
a 分解：将原问题分解为一系列子问题
b 解决：递归地求解各子问题
c 合并：将子问题的结果合并为原问题的解
注：代码是copy的

package com.collonn.algorithm.sort;  

/** 
 * <pre> 
 * 经典归并排序 
 * </pre> 
 */  
public class MergeSort {  

    public void mergeSort(int[] s, int start, int end) {  
        if (start >= end) {  
            return;  
        }  

        int m = (start + end) / 2;  
        int start1 = start;  
        int end1 = m;  
        int start2 = m + 1;  
        int end2 = end;  
        this.mergeSort(s, start1, end1);  
        this.mergeSort(s, start2, end2);  

        this.merge(s, start1, end1, start2, end2);  
    }  

    // 合并两个有序数组为一个有序数组  
    private void merge(int[] s, int start1, int end1, int start2, int end2) {  
        System.out.printf("\n开始合并,合并范围,[%d,%d],[%d,%d]", start1, end1, start2, end2);  
        int start = start1;  
        // 临时数组  
        int[] t = new int[end2 - start1 + 1];  
        // 临时数组下标  
        int i = 0;  

        // 比较开始  
        while (start1 <= end1 && start2 <= end2) {  
            if (s[start1] < s[start2]) {  
                t[i] = s[start1];  
                start1++;  
                i++;  
                continue;  
            }  
            if (s[start1] > s[start2]) {  
                t[i] = s[start2];  
                start2++;  
                i++;  
                continue;  
            }  
        }  

        // 拷贝剩余元素  
        while (start1 <= end1) {  
            t[i] = s[start1];  
            start1++;  
            i++;  
        }  

        // 拷贝剩余元素  
        while (start2 <= end2) {  
            t[i] = s[start2];  
            start2++;  
            i++;  
        }  

        // 将已排好序的元素放回对应位置  
        for (i = 0; i < t.length; i++) {  
            s[start + i] = t[i];  
        }  

        // 打印数组  
        PrintArray(s);  
    }  

    // 打印数组  
    private static void PrintArray(int[] s) {  
        System.out.print("\n下标:");  
        for (int p = 0; p < s.length; p++) {  
            System.out.printf("%2d,", p);  
        }  
        System.out.print("\n值值:");  
        for (Integer m : s) {  
            System.out.printf("%2d,", m);  
        }  
        System.out.print("\n-----------------------------");  
    }  

    public static void main(String[] args) {  
        // int[] s = new int[] { 99, 88, 5, 99, 7, 9, 3, 8, 10, 90, 56, 83, 39, 22 };  
        int[] s = new int[] { 9, 2, 3, 7, 6, 5, 8, };  

        // 打印数组  
        PrintArray(s);  

        MergeSort mergeSort = new MergeSort();  
        mergeSort.mergeSort(s, 0, s.length - 1);  

        // 打印数组  
        PrintArray(s);  
    }  

}  

二.插入排序：
插入排序是这样的：一个数组a，从第一个元素开始，认为其是一个子数组b（其实可以不存在），那么子数组b是有序的。开始遍历整个数组b，将从第二个数开始的元素，插入到数组b中的相应的位置。
时间复杂度 O(n2)

 package com.njue;  

public class insertSort {  
public insertSort(){  
    inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};  
    int temp=0;  
    for(int i=1;i<a.length;i++){  
       int j=i-1;  
       temp=a[i];  
       for(;j>=0&&temp<a[j];j--){  
       a[j+1]=a[j];                       //将大于temp的值整体后移一个单位  
       }  
       a[j+1]=temp;  
    }  
    for(int i=0;i<a.length;i++)  
       System.out.println(a[i]);  
}  
}

三.快速排序
快排算是用的很多的一种排序了，其的思想是，有一个准线temp（一般默认第一个），从左右两边同时开始，左边找到比temp大于等于的第一个元素，右边找到比temp小于等于的第一个元素，两两交换。直到两个下标元素相碰为止，然后开始递归。将两个子数组递归下去就ok。

public class quickSort {  
  int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};  
public  quickSort(){  
    quick(a);  
    for(int i=0;i<a.length;i++)  
        System.out.println(a[i]);  
}  
public int getMiddle(int[] list, int low, int high) {     
            int tmp = list[low];    //数组的第一个作为中轴     
            while (low < high) {     
                while (low < high && list[high] >= tmp) {     

      high--;     
                }     
                list[low] = list[high];   //比中轴小的记录移到低端     
                while (low < high && list[low] <= tmp) {     
                    low++;     
                }     
                list[high] = list[low];   //比中轴大的记录移到高端     
            }     
           list[low] = tmp;              //中轴记录到尾     
            return low;                   //返回中轴的位置     
        }    
public void _quickSort(int[] list, int low, int high) {     
            if (low < high) {     
               int middle = getMiddle(list, low, high);  //将list数组进行一分为二     
                _quickSort(list, low, middle - 1);        //对低字表进行递归排序     
               _quickSort(list, middle + 1, high);       //对高字表进行递归排序     
            }     
        }   
public void quick(int[] a2) {     
            if (a2.length > 0) {    //查看数组是否为空     
                _quickSort(a2, 0, a2.length - 1);     
        }     
       }   
}

四.冒泡排序：
很经典的排序了。从第一个元素i开始，之后的元素两两比较，大的浮在后边，那么一次交换之后，最大的数就在最右了。第二次，仍然从第一个数开始，到倒数第二个数停止，两两比较，大的浮在最右边，那么次大数就在倒数第二个位置了。。。。
时间复杂度：O（n2）

public class bubbleSort {  
public  bubbleSort(){  
     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};  
    int temp=0;  
    for(int i=0;i<a.length-1;i++){  
        for(int j=0;j<a.length-1-i;j++){  
        if(a[j]>a[j+1]){  
            temp=a[j];  
            a[j]=a[j+1];  
            a[j+1]=temp;  
        }  
        }  
    }  
    for(int i=0;i<a.length;i++)  
    System.out.println(a[i]);     
}  
}

五.选择排序：
在一个数组中，找出最小的元素，然后和第一个元素交换。然后再选出次小的元素，和第二个元素交换。。。。。。
时间复杂度：O(n2)

public class selectSort {  
    public selectSort(){  
        int a[]={1,54,6,3,78,34,12,45};  
        int position=0;  
        for(int i=0;i<a.length;i++){  

            int j=i+1;  
            position=i;  
            int temp=a[i];  
            for(;j<a.length;j++){  
            if(a[j]<temp){  
                temp=a[j];  
                position=j;  
            }  
            }  
            a[position]=a[i];  
            a[i]=temp;  
        }  
        for(int i=0;i<a.length;i++)  
            System.out.println(a[i]);  
    }  
}