一、快速排序算法：从数列中挑出一个元素，称为基准。重新排序数列，所有元素比基准值小的排在前面，所有元素比基准值大的排在后面。分区操作：使用递归把小于基准值元素的子数列和大于基准值元素的子数列排序
代码实现：

private void quickSort(int[] a, int low, int high) {
    int start = low;
    int end = high;
    int key = a[low];
    //判断开始角标是否小于结束角标
    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;
        }
    }
    //递归调用子序列
    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];
    //判断开始角标是否小于结束角标
    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;
}

二、插入排序算法：从第一个元素开始，默认该元素已经排序，取出下一个元素，在已经排序的元素中从后向前扫描，如果该元素（已排序）大取出元素，将该元素移到下一个位置。直到找到已排序的元素小于或者等于取出元素，将取出元素插入到该位置中。
代码实现

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;
}

三、冒泡排序算法：越小的元素会经由交换慢慢“浮”到数列的顶端。循环取出未排序的第一个元素与后面每个元素去比较获取未排序的最小元素。重复循环
代码实现

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;
}

四、选择排序算法：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
代码实现

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;
}

五、合并排序算法：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。设定两个指针，最初位置分别为两个已经排序序列的起始位置。比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置循环比较，将另一序列剩下的所有元素直接复制到合并序列尾。
代码实现

 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];
    }
}

六、希尔排序算法：希尔排序是插入排序高效的改进版，插入排序对几乎排好序的数据操作时效率高，可以达到线性排序。插入排序是低效的，因为插入排序每次只能将数据移动一位。
代码实现

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--;
    }
}

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