查找

线性表的查找

顺序查找

逐个比较查询，如果找到，返回数据或索引，如果到最后也没有找到，返回null
可以是在顺序表中，也可以是在链表中
在各个结点查找概率相同情况下，默认查询长度为一般长度，所以时间复杂度是T（n）=O（n）

package DataStructure.search;

/**
 * @Description TODO 功能：在分数中查询指定分数的索引
 * T(n) = O(n)
 * S(n) = O(1)
 * @Author Matthew
 * @Date 2019/6/1 10:13
 * @Version 1.0
 */

public class TestSearch1 {
    public static void main(String[] args) {
        //给定分数数组
        int[] scoreArr = {89, 45, 78, 45, 100, 98, 86, 100, 65};
        //给定要查找的分数
        int score = 65;
        //完成查找

        int index = search(scoreArr,score);
        //输出结果
        if (index == -1) {
            System.out.println("该分数不存在");
        } else {
            System.out.println(score + "的索引是" + index);
        }
    }

    public static int search(int[] arr, int key){
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == key) {
                index = i;
                break;
            }
        }
        return index;
    }
}

折半查找

折半查找而成为二分查找，这种查找方法需要待查的查找表满足两个条件：受限，查找表必须使用顺序存储结构；其次，查找表必须按关键字大小有序排列

使用非递归实现折半查找

package DataStructure.search;

/**
 * @Description TODO 前提：顺序结构、按照关键字有序
 * @Author Matthew
 * @Date 2019/6/2 10:17
 * @Version 1.0
 */

public class TestSearch2 {
    public static void main(String[] args) {
        //给定数组
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //给定要查找的值
        int key = 6;
        //进行折半二分查找
//      int index = binarySearch(array, key);
        int index = binarySearch2(array, key);

        //输出结果
        if (index == -1) {
            System.out.println("不存在");
        } else {
            System.out.println(key + "的索引是" + index);
        }
    }
    /*
     * @Description: TODO 不使用递归
     *                T(n) = O(log2 n)
     *                S(n) = O(1)
     */
    public static int binarySearch(int[] array, int key) {
        //指定low和high
        int low = 0;
        int high = array.length - 1;

        //折半查找
        while (low <= high) {
            //求得mid
            int mid = (low + high) / 2;
            //判断是否等于
            if (key == array[mid]) {
                return mid;
            } else if (key < array[mid]) {
                high = mid - 1;
            } else {//key > array[mid]
                low = mid + 1;
            }

        }
        return -1;
    }

    /*
     * @Description: TODO 使用递归
     *                T(n) = O(log2 n)
     *                S(n) = O(n)
     */
    public static int binarySearch2(int[] array, int key) {
        int low = 0;
        int high = array.length - 1;
        return binarySearch2(array, key, low, high);
    }

    public static int binarySearch2(int[] array, int key, int low, int high) {
        //递归结束条件
        if (low > high) {
            return -1;
        }
        int mid = (low + high) / 2;
        if (key == array[mid]) {
            return mid;
        } else if (key < array[mid]) {
            high = mid - 1;
            return binarySearch2(array, key, low, high);
        } else {
            low = mid + 1;
            return binarySearch2(array, key, low, high);
        }
    }
}

查找树

二叉查找/搜索/排序树 BST（binary search/sort tree）

或者是一棵空树；或者是具有下列性质的二叉树；

1. 若他的左子树不空，则左子树上所有系欸但的值均小于它的根节点的值；
2. 若他的右子树上所有节点的值均大于它根节点的值；
3. 他的左右子树分别为二叉排序树
   
   注意：对二叉查找树进行中序遍历，得到有序集合。

平衡二叉树（Self-balancing binary search tree）自平衡二叉查找树 又被称为AVL树（有别于AVL算法）

它是一棵空树，或它的左右两个子树的高度差（平衡因子）的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树，同时，平衡二叉树必定式二叉搜索树，反之则不一定。
平衡因子（平衡度）：结点的平衡因子是结点的左子树的高度减去右子树的高度。（或反之定义）
平衡二叉树：每个结点的平衡因子都为1、-1、0的二叉排序树。或者说每个结点的左右子树的高度最多差1的二叉排序树
平衡二叉树的目的是为了减少二叉查找树层次，提高查找速度
平衡二叉树的常用实现方法有AVL、红黑树、替罪羊树、Treap、伸展树等。

红黑树

R-B Tree，全称是Red-Black Tree又称为“红黑树”，它是一种平衡二叉树。红黑树的每个系欸但上都有存储位表示结点的颜色，可以是红（Red）或黑（black）
红黑树的特性：

1. 每个结点或者是黑色，或者是红色
2. 根节点是黑色。
3. 每个叶子结点（NIL）是黑色。【注意：这类叶子节点，是指为空（NIL或NULL）的叶子节点！】
4. 如果一个节点是红色，则它的子节点必须是黑色的。
5. 从一个节点到该节点的子孙节点的左右路径上包含相同数目的黑节点。
   注意：
6. 特性3中的叶子节点，是只为空（NIL或NULL）的节点。
7. 特性（5），确保没有一条路径会比其他路径长出两倍。因而，红黑树是相对接近平衡的二叉树。
   
   红黑树的应用比较广泛，主要是用它来存储有序的数据，它的时间复杂度是O（log2 N），效率非常之高。
   它虽然复杂，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的；他可以在O（log2 n）时间内做查找，插入和删除，这里的n是树中元素的数目。
   例如：Java集合中的TreeSet和TreeMap，C++ STL中的set、map，以及Linux虚拟内存的管理，都是通过红黑树去实现的。

B树（balanced tree）

你觉得平衡树和二叉平衡树有什么差别呢？
与二叉平衡树相比，是多叉的可以降低树的深度，提高查找效率

B树应文件系统的要求而发展起来的，大量数据存放在外村中，通常存放在硬盘中。
由于是海量数据，不可能一次调入内存。因此，要多次访问外存。但硬盘的驱动受机械运动的制约，速度慢。所以，主要矛盾变为减少访问外存次数。在1972年有R。Bayer和E。Macreight提出用B_树作为索引组织文件。提高访问速度、减少时间

B+ 树

在B树基础上，为叶子结点增加链表指针，所有关键字都在叶子节点中出现，非叶子系欸但作为叶子节点的索引；B+树总是到叶子节点才命中。

B*树

是B+树的变体，在B+树的非根和非叶子节点再增加指向兄弟的指针