public static List<Integer> naiveMatching(String text, String pattern) {
    List<Integer> result = new ArrayList<>();
    // 一个循环在Text上一个一个Index的进行滑动
    for (int i = 0; i <= text.length() - pattern.length(); i++) {
        // 在当前Index，检查Pattern是否匹配Text
        for (int j = 0; j < pattern.length(); j++) {
            if (text.charAt(i + j) != pattern.charAt(j)) break;
            if (j == pattern.length() - 1) result.add(i);
        }
    }
    return result;
}

public static List<Integer> holspoolMatching(String text, String pattern) {
    List<Integer> result = new ArrayList<>();
    //构建移动Pattern距离的一个移位表，只考虑ASCII编码的128位
    //Java用了Unicode集，前128位即采用了ASCII编码
    int[] shiftTable = buildShiftTable(pattern);
    int searchIndex = 0;
    while (searchIndex <= text.length() - pattern.length()) {
        //从pattern右侧开始往左侧匹配
        int patternIndex = pattern.length() - 1;
        while (text.charAt(searchIndex + patternIndex) == pattern.charAt(patternIndex)) {
            //如果匹配到Pattern的头部，说明完全匹配，则返回Text中相对应的Index，
            if (patternIndex == 0) result.add(searchIndex);
            //不断往左匹配
            patternIndex--;
        }
        //根据起始匹配位置（即Pattern最右侧匹配的对应)的那个Text中的char来决定右移的长度
        searchIndex += shiftTable[text.charAt(searchIndex + pattern.length() - 1)];
    }
    return result;
}


/**
 * 构建移动 Pattern 距离的一个移位表，只考虑 ASCII 编码的128位
 * Java 用了 Unicode 集，前128位即采用了 ASCII 编码
 *
 * @param pattern 需要匹配的子字符串
 * @return 根据Pattern来构建的Shift Table
 */
private static int[] buildShiftTable(String pattern) {
    int[] shiftTable = new int[128];
    //非在Pattern中出现的char，则移动位置为Pattern长度
    Arrays.fill(shiftTable, pattern.length());
    //将每个出现在Pattern中的char在数组中的位置里填充上移动距离(除最后一位)
    for (int j = 0; j < pattern.length() - 1; j++) {
        //char自动通过ASCII编码转码到对应的Int值，即shiftTable中对应Index
        //shift的距离根据当前char距离最后一个元素的距离决定，如果有重复的元素，则右边
        //的元素覆盖左边的元素，以右边距离最后一个元素的距离为准
        shiftTable[pattern.charAt(j)] = (pattern.length() - 1) - j;
    }
    return shiftTable;
}

public static List<Integer> KMPMatching(String text, String pattern) {
    List<Integer> result = new ArrayList<>();
    int[] prefixTable = buildPrefixTable(pattern);
    int matchedCharacter = 0;
    for (int i = 0; i < text.length(); i++) {
        //不匹配，根据prefixTable回退到相对应的位置，
        while (matchedCharacter > 0 && pattern.charAt(matchedCharacter) != text.charAt(i)) {
            matchedCharacter = prefixTable[matchedCharacter - 1]; //核心回退语句
        }
        //匹配，匹配数量+1
        if (pattern.charAt(matchedCharacter) == text.charAt(i)) {
            matchedCharacter++;
        }
        if (matchedCharacter == pattern.length()) {
            result.add(i - matchedCharacter + 1);
            matchedCharacter = prefixTable[matchedCharacter - 1];
        }
    }
    return result;
}
    
private static int[] buildPrefixTable(String pattern) {
    int[] prefixTable = new int[pattern.length()];
    int maxPrefixLength = 0;
    //遍历Pattern，对每一个Char创建一个对应的最长前缀长度表
    for (int i = 1; i < prefixTable.length; i++) {
        while (maxPrefixLength > 0 && pattern.charAt(maxPrefixLength) != pattern.charAt(i)) {
            //当前index的char和prefix的char对应不上，则不断去找去掉当前位置得char的
            //之前的所有的text的后缀的“次一级最长前缀长度”，直到
            //①Length为0，从头再开始匹配，
            //②匹配到相对应的prefix，往下运行。具体可以看例子来理解这句话
            maxPrefixLength = prefixTable[maxPrefixLength - 1];    //核心回退语句
        }
        if (pattern.charAt(maxPrefixLength) == pattern.charAt(i)) {
            maxPrefixLength++;
        }
        prefixTable[i] = maxPrefixLength;
    }
    return prefixTable;
}    

public static void selectionSort(int[] arr) {    
    int length = arr.length;    
    int min;    
    for (int i = 0; i < length - 1; i++) {        
        min = i;        
        //找到并选择(select)最小的Index        
        for (int k = i + 1; k < length; k++) {            
            if (arr[k] < arr[min]) {                
                min = k;            
            }        
        }        
        //交换 arr[i] 和 arr[min]        
        int temp = arr[i];        
        arr[i] = arr[min];        
        arr[min] = temp;    
    }
}

public static void insertionSort(int[] arr) {
    int length = arr.length;
    for (int i = 1; i < length; i++) {
        int item = arr[i];
        int k = i - 1;
        //把比当前item小的items都后移一位
        while (k >= 0 && item < arr[k]) {
            arr[k + 1] = arr[k];
            k--;
        }
        //插入(Insert)当前item
        arr[k + 1] = item;
    }
}

/**
    * 希尔排序利用 gap sequence 为 length/2, length/4 ... 1
    */
public static void shellSort(int[] arr) {
    int length = arr.length;
    //从数组长度/2的Gap开始, 减小到Gap = 1
    for (int gap = length / 2; gap > 0; gap /= 2) {
        //相当于Insertion Sort从第2个元素开始insert,
        //Shell Sort从第gap个元素开始insert
        for (int i = gap; i < length; i++) {

            int temp = arr[i];

            //相当于Insertion Sort比较当前的item和之前排序过的items
            //小于,则把之前的元素后移gap位(Insertion Sort是1位)
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            //把当前item 插入正确的位置
            arr[j] = temp;
        }
    }
}

/**
 * 基于最大堆的堆排序
 */
public static void heapSort(int[] arr) {
    int size = arr.length;
    //建立一个最大堆
    for (int i = arr.length / 2 - 1; i >= 0; i--) {
        siftDown(arr, i, size);
    }
    //不断交换heap头和尾的数值，因为是最大堆，最终排序为从小到大
    while (size > 0) {
        int temp = arr[0];
        arr[0] = arr[size - 1];
        arr[size - 1] = temp;
        size--;
        //重新让arr符合heap的性质，让交换上来的第一位元素下沉
        siftDown(arr, 0, size);
    }
}
    
/**
 * 存在一个Parent节点的值小于任一Child节点，就让它Sift Down，直到符合堆的性质（最大堆）
 *
 * @param heap     存放堆的array
 * @param keyIndex 当前要处理的Parent节点的Index
 * @param heapSize Heap的大小
 */
private static void siftDown(int[] heap, int keyIndex, int heapSize) {
    int keyValue = heap[keyIndex];
    boolean isHeap = false;
    while (!isHeap && keyIndex < heapSize / 2) {
        //左孩子的index
        int childIndex = 2 * keyIndex + 1;
        //如果有右孩子的情况
        if (childIndex < heapSize - 1) {
            //比较两个child值的大小，把index值设为大的那个（最大堆中）
            if (heap[childIndex] < heap[childIndex + 1]) {
                childIndex++;
            }
        }
        //递归比较子节点的大小和keyValue的大小来决定是否满足heap的属性
        if (heap[childIndex] <= keyValue) {
            isHeap = true;
        } else {
            //child节点的值上移
            heap[keyIndex] = heap[childIndex];
            keyIndex = childIndex;
        }
    }
    //把原本的KeyValue放到最终的位置，形成一个heap
    heap[keyIndex] = keyValue;
}

public static void quickSort(int[] arr) {
    quickSortHelper(arr, 0, arr.length - 1);
}

private static void quickSortHelper(int[] arr, int lo, int hi) {
    if (lo < hi) {
        int partitionIndex = partition(arr, lo, hi);
        quickSortHelper(arr, lo, partitionIndex - 1);
        quickSortHelper(arr, partitionIndex + 1, hi);
    }
}

/**
 * Hoare Partition（https://www.wikiwand.com/en/Quicksort#/Hoare_partition_scheme）
 * 一种简单的Partition方法，选取一个pivot（我在代码中选取了index=lo的元素），
 * 然后用2个指针，从头尾向对方移动，直到检测到一个大于pivot，一个小于或等于pivot，
 * 彼此是相对不正确的顺序，然后交换两者。当2个指针相遇，调整pivot到正确位置，并返回最终index。
 *
 * @param arr 等待被排序的数组
 * @param lo  开始index,
 * @param hi  结束index
 * @return 选取的pivot最终正确的位置的index
 */
private static int partition(int[] arr, int lo, int hi) {
    int pivot = arr[lo], loIndex = lo, hiIndex = hi;
    while (loIndex < hiIndex) {
        while (loIndex < hi && arr[loIndex] <= pivot) loIndex++;
        while (hiIndex > lo && arr[hiIndex] > pivot) hiIndex--;
        //交换逆序元素,如果不设这个判断，最后一次loIndex>hiIndex也会进行交换
        if (loIndex <= hiIndex) {
            int temp = arr[loIndex];
            arr[loIndex] = arr[hiIndex];
            arr[hiIndex] = temp;
        }
    }
    //将pivot放到正确的位置
    int temp = arr[lo];
    arr[lo] = arr[hiIndex];
    arr[hiIndex] = temp;
    //返回pivot最终正确的位置的index
    return hiIndex;
}

/**
 * 递归版(Top-down)的 归并排序
 * 处理一个未排序数组，不断递归的分成2半，分别排序，最后合并
 */
public static void mergeSortTopDown(int[] arr) {
    if (arr.length > 1) {
        int mid = arr.length / 2;
        //将原数组分成左右两半，分别拷贝到临时数组中
        //left=[leftIndex, midIndex), right = [midIndex, rightIndex)
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
        //对左右两半临时数组进行排序
        mergeSortTopDown(left);
        mergeSortTopDown(right);
        //将左右两半临时数组归并到原数组
        merge(left, right, arr);
    }
}

private static void merge(int[] left, int[] right, int[] arr) {
    //3个数组的初始index都设置为0
    int leftIndex = 0, rightIndex = 0, mergedIndex = 0;
    //不断比较左右两个数组中元素的大小，复制到原数组中，直到一个数组元素完全复制完
    while (leftIndex < left.length && rightIndex < right.length) {
        if (left[leftIndex] < right[rightIndex]) {
            arr[mergedIndex++] = left[leftIndex++];
        } else {
            arr[mergedIndex++] = right[rightIndex++];
        }
    }
    //将剩余一个数组中的剩余元素复制到原数组的末尾
    if (leftIndex == left.length) {
        System.arraycopy(right, rightIndex, arr, mergedIndex, 
                            right.length - rightIndex);
    } else {
        System.arraycopy(left, leftIndex, arr, mergedIndex, 
                            left.length - leftIndex);
    }
}

/**
 * 迭代版(Bottom-up)的 归并排序
 * 迭代的对原数组中不断增长的2的倍数(2,4,8...)长度的子数组进行排序
 */
public static void mergeSortBottomUp(int[] arr) {
    int[] temp = new int[arr.length];
    //对从长度为2开始的数组进行排序
    for (int i = 2; i < (2 * arr.length); i *= 2) {
        //对每一次排序而言，对当前数组对半分，进行排序
        for (int j = 0; j < (arr.length + i) / i; j++) {
            //数组左中右index，等同于将数组分成了左右两半，对最后一个数组，需要判断是否超过原数组下标
            int left = i * j;
            int mid = Math.min(left + i / 2, arr.length);
            int right = Math.min(i * (j + 1), arr.length);
            //对左右数组进行排序操作，等同于Top-down里的merge操作
            int leftIndex = left, rightIndex = mid, mergedIndex = left;
            while (leftIndex < mid && rightIndex < right) {
                if (arr[leftIndex] < arr[rightIndex]) {
                    temp[mergedIndex++] = arr[leftIndex++];
                } else {
                    temp[mergedIndex++] = arr[rightIndex++];
                }
            }
            if (leftIndex == mid) {
                System.arraycopy(arr, rightIndex, temp, mergedIndex, right - rightIndex);
            } else {
                System.arraycopy(arr, leftIndex, temp, mergedIndex, mid - leftIndex);
            }
            //注释掉这句话可以看具体排序过程
            //System.out.println(Arrays.toString(temp));
            //将排序好的数组拷贝回原数组相对应位置
            System.arraycopy(temp, left, arr, left, right - left);
        }
    }
}