算法学习笔记——查找问题

学习笔记，仅做记录。

---

1.顺序查找

使用方法：蛮力法
平均时间复杂度为O(n)

package com.viper.search;

public class SeqSearch {

    public static int getIndex(int searchKey, int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (searchKey == array[i])
                return i;
        }
        return -1;
    }

    /**
     * （改进）设置哨兵，减少循环判断
     */
    public static int getIndexImprove(int searchKey, int[] array) {
        int index = array.length;// 高端开始遍历
        if (array[0] == searchKey) {
            return 0;
        }
        array[0] = searchKey;// 设置哨兵，防止越界
        while (array[index] != searchKey) {
            index--;
        }
        return index == 0 ? -1 : index;
    }
}

2.折半查找 / 二分查找

使用方法：减治法
使用条件：元素有序
平均时间复杂度为$O(\log_2n)$

package com.viper.search;

public class Bisearch {

    public static int getIndex(int searchKey, int[] array) {
        int index = -1;
        int low = 0, high = array.length - 1;
        int mid;
        while (low <= high) {
            mid = (low + high) / 2;
            if (searchKey < array[mid]) {
                high = mid - 1;
            } else if( searchKey > array[mid]) {
                low = mid + 1;
            } else {
                index = mid;
                break;
            }
        }
        return index;
    }
}

3.二叉查找

使用方法：减治法
使用条件：构建二叉查找树
时间复杂度为$O(\log_2n)$到$O(n)$之间（n个节点的二叉树的深度至少为$(\log_2n)+1$,至多为 n <script type="math/tex" id="MathJax-Element-5">n</script>）

package com.viper.search;

public class BinSearchTree {

    public static TreeNode search(int[] array, int searchKey) {
        TreeNode tree = init(array);
        return binSearch(tree, searchKey);
    }
    /**
     * 递归遍历二叉树
     */
    public static TreeNode binSearch(TreeNode mRoot, int searchKey) {
        if (mRoot == null) {
            return mRoot;
        } else if (mRoot.value == searchKey) {
            return mRoot;
        } else if (mRoot.value < searchKey) {
            return binSearch(mRoot.rChild, searchKey);
        } else {
            return binSearch(mRoot.lChild, searchKey);
        }
    }

    /**
     * 初始化二叉树，将待排序数组插入到二叉树中
     */
    private static TreeNode init(int[] array) {
        TreeNode mRoot = null;
        for (int i = 0; i < array.length; i++) {
            mRoot = insertBST(mRoot, array[i]);
        }
        return mRoot;
    }

    /**
     * 递归初始化二叉树
     */
    private static TreeNode insertBST(TreeNode rootNode, int value) {
        if (rootNode == null) {
            rootNode = new TreeNode(value);
            return rootNode;
        }
        if (value < rootNode.value) {
            rootNode.lChild = insertBST(rootNode.lChild, value);
        } else {
            rootNode.rChild = insertBST(rootNode.rChild, value);
        }
        return rootNode;
    }

    private static class TreeNode {
        private int value;
        private TreeNode lChild;
        private TreeNode rChild;

        public TreeNode(int value) {
            super();
            this.value = value;
            this.lChild = null;
            this.rChild = null;
        }
    }
}

4.平衡二叉树

5.红黑树