jdk自带的经典算法

排序

    private static void binarySort(Object[] a, int lo, int hi, int start) {
        assert lo <= start && start <= hi;
        if (start == lo)
            start++;
        for (; start < hi; start++) {
            // 选择start节点的值为锚点
            Comparable pivot = (Comparable) a[start];
            // 设置次轮循环排序的左节点为lo, 右节点是start,即次轮将数组索引：lo->start排序好
            int left = lo;
            int right = start;
            assert left <= right;

            // 锚点pivot的位置，因为之前lo->start-1是排序好，所以通过2分查询找到pivot的位置
            // pivot >= all in [lo, left), pivot < all in [right, start).
            while (left < right) {
                int mid = (left + right) >>> 1;
                if (pivot.compareTo(a[mid]) < 0)
                    right = mid;
                else
                    left = mid + 1;
            }
            assert left == right;
            // 计算数组需要移动的个数，把pivot放到left的位置，后续位置往后挪动一位：left->start-1===>left+1->start
            int n = start - left;
            // 优化挪动算法
            switch (n) {
                case 2:
                    a[left + 2] = a[left + 1];
                case 1:
                    a[left + 1] = a[left];
                    break;
                default:
                    System.arraycopy(a, left, a, left + 1, n);
            }
            // 将pivot放到left的位置
            a[left] = pivot;
        }
    }

　　自己练习的版本

public static void timSort(Integer[] a) {
    int len = a.length;
    int low = 0;
    if (a.length <= 1) {
        return;
    }
    int count = 0;
    for (int start = 1; start < len; start++) {
        int left = low;
        int right = start;
        int pivot = a[start];
        while (left < right) {
            count++;
            int mid = right + left >>> 1;
            if (pivot < a[mid]) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        int n = start - left;
        System.arraycopy(a, left, a, left + 1, n);
        a[left] = pivot;
    }
    System.out.println("count:" + count);
}

字符串查找

   static int indexOf(char[] source, int sourceOffset, int sourceCount,            char[] target, int targetOffset, int targetCount,            int fromIndex) {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetCount == 0) {
            return fromIndex;
        }
　　　　　// 需要查找的第一个字符
        char first = target[targetOffset];
        int max = sourceOffset + (sourceCount - targetCount);

        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* Look for first character. */
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }

            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
                int j = i + 1;
                int end = j + targetCount - 1;
                for (int k = targetOffset + 1; j < end && source[j]
                        == target[k]; j++, k++);

                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }

 自己的练习版本

    private static int findStringIndex(String source, String target) {
        if (StringUtils.isBlank(source) || StringUtils.isBlank(target)) {
            return -1;
        }
        char[] sourceChars = source.toCharArray();
        char[] targetChars = target.toCharArray();
        int max = sourceChars.length - target.length();
        for (int i = 0; i <= max; i++) {
            if (sourceChars[i] != targetChars[0]) {
                while (i++ < max && sourceChars[i] != targetChars[0]) ;
            }
            // 从第二个字符串查找
            if (i <= max) {
                int j = i + 1;
                int end = j + targetChars.length - 1;
                for (int k = 1; j < end && sourceChars[j] == targetChars[k]; j++, k++);
                if (j == end) {
                    /* Found whole string. */
                    return i;
                }
            }
        }
        return -1;
    }