基本排序算法（记录一下）

直接插入排序：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。

public class Sort {
    public int[] sort(int[] arrays) {
        int length = arrays.length;
        if (length <= 1) {
            return arrays;
        }
        int tmp;
        for (int i = 1; i < length; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (arrays[j + 1] < arrays[j]) {
                    tmp = arrays[j + 1];
                    arrays[j + 1] = arrays[j];
                    arrays[j] = tmp;
                } else {
                    break;
                }
            }
        }
        return arrays;
    }
}

快速排序算法：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。

public class Sort {

    public int[] sort(int[] arrays) {
        int length = arrays.length;

        if (length <= 1) {
            return arrays;
        }

        sortByFirst(arrays, 0, length);

        return arrays;
    }

    private void sortByFirst(int[] arrays, int startIndex, int endIndex) {
        if (startIndex >= endIndex) {
            return;
        }
        int tmp;
        int keyIndex = startIndex;
        for (int i = startIndex; i < endIndex; i++) {
            if (arrays[i] < arrays[keyIndex]) {
                tmp = arrays[i];
                for (int j = i; j > keyIndex; j--) {
                    arrays[j] = arrays[j - 1];
                }
                arrays[keyIndex] = tmp;
                keyIndex++;
            }
        }
        sortByFirst(arrays, startIndex, keyIndex);
        sortByFirst(arrays, keyIndex + 1, endIndex);
    }
}

选择排序：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

public class Sort {

    public int[] sort(int[] arrays) {
        int length = arrays.length;

        if (length <= 1) {
            return arrays;
        }

        // 递归比较N - 1个元素，找出最小值，和第1个元素进行交换
        for (int i = 0; i < length; i++) {
            int index = i;
            for (int j = i + 1; j < length; j++) {
                if (arrays[j] < arrays[index]) {
                    index = j;
                }
            }
            if (arrays[i] > arrays[index]) {
                int tmp = arrays[i];
                arrays[i] = arrays[index];
                arrays[index] = tmp;
            }
        }


        return arrays;
    }

}

希尔排序：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

public class Sort {

    public int[] sort(int[] arrays) {
        int length = arrays.length;

        if (length <= 1) {
            return arrays;
        }

        int tmp;
        int shellValue = length / 2;
        while (shellValue > 0) {
            for (int i = 0; i < shellValue; i++) {
                for (int j = i; j < length; j += shellValue) {
                    for (int m = j - shellValue; m >= 0; m -= shellValue) {
                        if (arrays[m] > arrays[m + shellValue]) {
                            tmp = arrays[m];
                            arrays[m] = arrays[m + shellValue];
                            arrays[m + shellValue] = tmp;
                        } else {
                            break;
                        }
                    }
                }
            }
            shellValue = shellValue / 2;
        }
        return arrays;
    }
}

冒泡排序：重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

public class Sort {

    public int[] sort(int[] arrays) {
        int length = arrays.length;

        if (length <= 1) {
            return arrays;
        }

        // 优化
        int tmp;
        boolean noOrder = true;
        for (int i = 0; i < length && noOrder; i++) {
            noOrder = false;
            for (int j = length - 1; j > i; j--) {
                if (arrays[j] < arrays[j - 1]) {
                    tmp = arrays[j];
                    arrays[j] = arrays[j - 1];
                    arrays[j - 1] = tmp;
                    noOrder = true;
                }
            }
        }


        // 从后往前排
        // int tmp;
        // for (int i = 0; i < length; i++) {
        //     for (int j = length - 1; j > i; j--) {
        //         if (arrays[j] < arrays[j - 1]) {
        //             tmp = arrays[j];
        //             arrays[j] = arrays[j - 1];
        //             arrays[j - 1] = tmp;
        //         }
        //     }
        // }

        // 从前往后排
        // int tmp;
        // for (int i = 0; i < length; i++) {
        //     for (int j = i; j < length; j++) {
        //         if (arrays[i] > arrays[j]) {
        //             tmp = arrays[i];
        //             arrays[i] = arrays[j];
        //             arrays[j] = tmp;
        //         }
        //     }
        // }

        // 将最大的数移动到最后面
        // for (int i = length - 1; i > 0; i--) {
        //     for (int j = 0; j < i; j++) {
        //         if (arrays[i] < arrays[j]) {
        //             int tmp = arrays[i];
        //             arrays[i] = arrays[j];
        //             arrays[j] = tmp;
        //         }
        //     }
        // }

        return arrays;
    }

}

归并排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

public class  Sort {
    public int[] sort(int[] arrays) {
        int length = arrays.length;

        if (length <= 1) {
            return arrays;
        }
        sortArrays(arrays, 0, arrays.length);

        return arrays;
    }

    private void sortArrays(int[] arrays, int fisrt, int end) {
        int middle = (fisrt + end) / 2;
        if (fisrt < end - 1) {
            sortArrays(arrays, fisrt, middle);
            sortArrays(arrays, middle, end);
            merge(arrays, fisrt, middle, end);
        }
    }

    private void merge(int[] arrays, int fisrt, int middle, int end) {
        int firstIndex = fisrt;
        int secondIndex = middle;
        int[] tmpArrays = new int[end - fisrt];
        int tmpIndex = 0;

        while (firstIndex < middle && secondIndex < end) {
            if (arrays[firstIndex] < arrays[secondIndex]) {
                tmpArrays[tmpIndex++] = arrays[firstIndex++];
            } else {
                tmpArrays[tmpIndex++] = arrays[secondIndex++];
            }
        }

        while (firstIndex < middle) {
            tmpArrays[tmpIndex++] = arrays[firstIndex++];
        }

        while (secondIndex < end) {
            tmpArrays[tmpIndex++] = arrays[secondIndex++];
        }

        for (int i = 0; i < tmpArrays.length; i++) {
            arrays[fisrt + i] = tmpArrays[i];
        }
    }
}

附上一张排序算法图：