程序基本功：排序算法经典算法

常见算法排序总结：

快速排序（轴排序）：

import org.junit.Assert;
import org.junit.Test;

import java.util.Arrays;

public class Sort {
    int[] initNums = {2, 45, 23, 11, 45, 3, 88, 19, 55, 109, 1998, 1, 26, 46, 67, 99};

    @Test
    public void getFinalNum() {
        testAlgorithm(initNums, this::quickSort);
    }

    public void quickSort(int[] initNums, int left, int right) {
        if (left >= right) return;
        int pivot = partition(initNums, left, right);

        if (pivot - 1 >= left)
            quickSort(initNums, left, pivot - 1);
        if (pivot + 1 <= right)
            quickSort(initNums, pivot + 1, right);
    }

    // 分区
    public int partition(int[] nums, int leftIndex, int rightIndex) {
        // 轴的位置,取最左侧的数据
        int pivotIndex = leftIndex;
        // 记录轴的大小
        int tempt = nums[pivotIndex];
        // 向两边查找
        while (leftIndex < rightIndex) {
            while (leftIndex < rightIndex && nums[rightIndex] >= tempt) {
                rightIndex--;
            }

            nums[leftIndex] = nums[rightIndex];

            while (leftIndex < rightIndex && nums[leftIndex] <= tempt) {
                leftIndex++;
            }

            nums[rightIndex] = nums[leftIndex];
        }
        // 放在轴的位置，最终leftIndex=rightIndex为轴
        assert leftIndex == rightIndex;
        nums[leftIndex] = tempt;
        return leftIndex;
    }

    public void testAlgorithm(int[] origin, SortFunction sortFunction) {
        int[] copy = Arrays.copyOf(origin, origin.length);
        int[] copy2 = Arrays.copyOf(origin, origin.length);
        Arrays.sort(copy);
        sortFunction.sort(copy2, 0, origin.length - 1);
        Assert.assertArrayEquals("排序错误", copy2, copy);
    }

    private void swap(int[] nums, int index1, int index2) {
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }

    @FunctionalInterface
    public interface SortFunction {
        void sort(int[] initNums, int left, int right);
    }
}

堆排序：
虽然堆排序的时间复杂度理论上优于快速排序，堆是不断构造一种特殊完全二叉树，用根节点和尾部不断交换顺序进行排序。但是快速排序依然用的最多。因为以下原因。

1.堆排序访问数据的方式没有快速排序友好。cpu可能访问数组不连续的数据。
2.对于同样的数据，在排序过程中，堆排序算法的数据交换次数要多于快速排序。数据堆构造中原有的有序数据会被打乱。