排序算法

冒泡排序

将第一个数字与下一个数字比较，如果第一个数字大，交换两数

tip:先将大的数字往后面放
key:相邻的数字比较

代码块

for(int i=a.length-1;i>0;i--)   
    for(int j=0;j<i;j++)    
        if(a[j]>a[j+1])        
        {            
            k=a[j+1];           
            a[j+1]=a[j];            
            a[j]=k;        
            
        }

选择排序

与冒泡排序相反，将较小的数字向前排
找出未排序数组中的最小数的下标，交换

代码块

for(int i=0;i<a.length-1;i++)
{
    minIndex=i;//无序区的最小数据数组下标
    for(int j=i+1;j<a.length;j++)
    {
        //在无序区中找到最小数据并保存其数组下标
        if(a[j]<a[minIndex])
        {
            minIndex=j;
        }
    }
    if(minIndex!=i)
    {
        //如果不是无序区的最小值位置不是默认的第一个数据，则交换之。
        temp=a[i];
        a[i]=a[minIndex];
        a[minIndex]=temp;
    }
}

插入排序

⒈ 从第一个元素开始，该元素可以认为已经被排序
⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描
⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置
⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
⒌ 将新元素插入到下一位置中
⒍ 重复步骤2~5

可以使用二分查找法

代码块

for (int i = 1; i {
    for (int j = i; j > 0; j--) {
        if (arr[j] 1]){   
            int temp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = temp;
        }        
        else{
            break;
        }
    }
}

归并排序

代码块

public class MergeSort {
    // private static long sum = 0;
    /**
     * <pre>
     * 二路归并
     * 原理：将两个有序表合并和一个有序表
     * </pre>
     * 
     * @param a
     * @param s
     * 第一个有序表的起始下标
     * @param m
     * 第二个有序表的起始下标
     * @param t
     * 第二个有序表的结束小标
     * 
     */
    private static void merge(int[] a, int s, int m, int t) {
        int[] tmp = new int[t - s + 1];
        int i = s, j = m, k = 0;
        while (i < m && j <= t) {
            if (a[i] <= a[j]) {
                tmp[k] = a[i];
                k++;
                i++;
            } else {
                tmp[k] = a[j];
                j++;
                k++;
            }
        }
        while (i < m) {
            tmp[k] = a[i];
            i++;
            k++;
        }
        while (j <= t) {
            tmp[k] = a[j];
            j++;
            k++;
        }
        System.arraycopy(tmp, 0, a, s, tmp.length);
    }
    /**
     * 
     * @param a
     * @param s
     * @param len
     * 每次归并的有序集合的长度
     */
    public static void mergeSort(int[] a, int s, int len) {
        int size = a.length;
        int mid = size / (len << 1);
        int c = size & ((len << 1) - 1);
        // -------归并到只剩一个有序集合的时候结束算法-------//
        if (mid == 0)
            return;
        // ------进行一趟归并排序-------//
        for (int i = 0; i < mid; ++i) {
            s = i * 2 * len;
            merge(a, s, s + len, (len << 1) + s - 1);
        }
        // -------将剩下的数和倒数一个有序集合归并-------//
        if (c != 0)
            merge(a, size - c - 2 * len, size - c, size - 1);
        // -------递归执行下一趟归并排序------//
        mergeSort(a, 0, 2 * len);
    }
    public static void main(String[] args) {
        int[] a = new int[] { 4, 3, 6, 1, 2, 5 };
        mergeSort(a, 0, 1);
        for (int i = 0; i < a.length; ++i) {
            System.out.print(a[i] + " ");
        }
    }
}