一、快速排序算法：從數(shù)列中挑出一個元素，稱為基準。重新排序數(shù)列，所有元素比基準值小的排在前面，所有元素比基準值大的排在后面。分區(qū)操作：使用遞歸把小于基準值元素的子數(shù)列和大于基準值元素的子數(shù)列排序
代碼實現(xiàn)：

private void quickSort(int[] a, int low, int high) {
    int start = low;
    int end = high;
    int key = a[low];
    //判斷開始角標是否小于結(jié)束角標
    while (end > start) {
        //從后往前比較
        while (end > start && a[end] >= key)
            end--;
        if (a[end] < key) {
            int temp = a[end];
            a[end] = a[start];
            a[start] = temp;
        }
        //從前往后排列
        while (end > start && a[start] <= key)
            start++;
        if (a[start] > key) {
            int temp = a[start];
            a[start] = a[end];
            a[end] = temp;
        }
    }
    //遞歸調(diào)用子序列
    if (start > low)
        quickSort(a, low, start - 1);
    if (end < high)
        quickSort(a, end + 1, high);
}

或是

public void quickSort(int[] a, int low, int high) {
    if (low < high) {
        int middle = getMiddle(a, low, high);
        quickSort(a, low, middle - 1);
        quickSort(a, middle + 1, high);
    }
}

public int getMiddle(int[] a, int low, int high) {
    int key = a[low];
    //判斷開始角標是否小于結(jié)束角標
    while (low < high) {
        //從后往前比較
        while (low < high && a[high] >= key)
            high--;
        a[low] = a[high];
        //從前往后比較
        while (low < high && a[low] <= key)
            low++;
        a[high] = a[low];
    }
    a[low] = key;
    return low;
}

二、插入排序算法：從第一個元素開始，默認該元素已經(jīng)排序，取出下一個元素，在已經(jīng)排序的元素中從后向前掃描，如果該元素（已排序）大取出元素，將該元素移到下一個位置。直到找到已排序的元素小于或者等于取出元素，將取出元素插入到該位置中。
代碼實現(xiàn)

public int[] str(int[] srt) {
    int i, j, key;
    for (i = 1; i < srt.length; i++) {
        key = srt[i];
        j = i - 1;
        while (j >= 0 && srt[j] > key) {
            srt[j + 1] = srt[j];
            srt[j] = key;
            j = j - 1;
        }
    }
    return srt;
}

三、冒泡排序算法：越小的元素會經(jīng)由交換慢慢“浮”到數(shù)列的頂端。循環(huán)取出未排序的第一個元素與后面每個元素去比較獲取未排序的最小元素。重復循環(huán)
代碼實現(xiàn)

private int[] bubbleSort(int[] srt) {
    int temp;
    for (int i = 0; i < srt.length - 1; i++) {
        for (int j = i + 1; j < a.length - 1; j++) {
            if (srt[i] > srt[j]) {
                temp = srt[i];
                srt[i] = srt[j];
                srt[j] = temp;
            }
        }
    }
    return srt;
}

private int[] bubbleSort(int[] srt) {
    int temp;
    for (int i = 0; i < srt.length - 1; i++) {
        for (int j = 0; j < a.length - 1 - i; j++) {
            if (srt[j] > srt[j + 1]) {
                temp = srt[j];
                srt[j] = srt[j + 1];
                srt[j + 1] = temp;
            }
        }
    }
    return srt;
}

四、選擇排序算法：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續(xù)尋找最小元素，然后放到排序序列末尾。
代碼實現(xiàn)

public int[] sortSelect(int[] arr) {
    int min;
    int temp;
    for (int i = 0; i < arr.length; i++) {
        min = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) 
                min = j;
        }
        if (arr[i] > arr[min]) {
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
    return arr;
}

五、合并排序算法：申請空間，使其大小為兩個已經(jīng)排序序列之和，該空間用來存放合并后的序列。設定兩個指針，最初位置分別為兩個已經(jīng)排序序列的起始位置。比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置循環(huán)比較，將另一序列剩下的所有元素直接復制到合并序列尾。
代碼實現(xiàn)

 private int[] sort(int[] num, int low, int high) {
    int mid = (low + high) / 2;
    if (low < high) {
        sort(num, low, mid);
        sort(num, mid + 1, high);
        merge(num, low, mid, high);
    }
    return num;
}

private void merge(int[] num, int low, int mid, int high) {
    int[] temp = new int[high - low + 1];
    int i = low;
    int j = mid + 1;
    int k = 0;
    while (i <= mid && j <= high) {
        if (num[i] < num[j])
            temp[k++] = num[i++];
        else
            temp[k++] = num[j++];
    }
    while (i <= mid)
        temp[k++] = num[i++];
    while (j <= high)
        temp[k++] = num[j++];
    for (int k2 = 0; k2 < temp.length; k2++) {
        num[k2 + low] = temp[k2];
    }
}

六、希爾排序算法：希爾排序是插入排序高效的改進版，插入排序?qū)缀跖藕眯虻臄?shù)據(jù)操作時效率高，可以達到線性排序。插入排序是低效的，因為插入排序每次只能將數(shù)據(jù)移動一位。
代碼實現(xiàn)

private void shellSort(int[] a) {
    int temp;
    int d = a.length / 2;
    while (true) {
        for (int i = 0; i < d; i++) {
            for (int j = i; j + d < a.length; j += d) {
                if (a[j] > a[j + d]) {
                    temp = a[j];
                    a[j] = a[j + d];
                    a[j + d] = temp;
                }
            }
        }
        if (d == 1) 
            break;
        d--;
    }
}

七、堆排序算法：后期更新......