数据结构 -- 基本查找算法

数据结构 -- 基本的查找算法学习

　　　　

　　　　　查找算法学习目录

　　　　1、顺序查找

　　　　　　顺序查找就是从头到尾依次遍历的去查找，就像数组的遍历、链表的遍历一样，最坏情况下，需要对所有的元素都执行一遍查找。对于数组来说，若是知道需要查找到元素的具体位置，就直接依靠索引去直接获取，所以数组的操作更偏向于获取，不适合插入与删除；对于链表来说，没有具体的索引，数据也不是存放在一个连续的存储空间中，所以只能从头到后进行遍历，所以链表不适合查找获取，但是更适合插入与删除结点。

　　　　　　数组的顺序查找：

 

 　　　　　　现在数组中存在8个元素，按照顺序查找，查找7这个元素。

　　　　　　算法代码：

public class Demone6 {
    public static void main(String[] args) {
        int[] arrary = new int[8];
        for (int i = 0; i < arrary.length; i++) {
            arrary[i] = i + 1;
        }
        /**
         * 数组的顺序查找
         */
        for (int i = 0; i < arrary.length; i++) {
            if (arrary[i] == 7) {
                System.out.println(arrary[i]);
            }
        }
    }
}

　　　　　　

　　　　　　链表的顺序查找：

　　　　

 

 　　　　　　算法代码：

　　　　　　

class TestList {

    private NodeTemp first = new NodeTemp(0);// 虚拟头结点

    /**
     * 判断是否为空
     */
    public boolean isEmpty() {
        return first.next == null;
    }
    /**
     * 添加结点
     */
    public void addNode(NodeTemp newNode) {

        NodeTemp nodeTemp = first;
        if (isEmpty()) {
            first.next = newNode;
        } else {
            while (nodeTemp.next != null) {
                nodeTemp = nodeTemp.next;
            }
            nodeTemp.next = newNode;
        }
    }
    /**
     * 查找算法
     */
    public void search(int no) {
        if (isEmpty()) {
            System.out.println("无");
        } else {
            NodeTemp nodeTemp = first.next;
            while (nodeTemp != null) {
                if (nodeTemp.no == no) {
                    System.out.println("查找的结点是： " + nodeTemp.no);
                    break;
                }
                nodeTemp = nodeTemp.next;
            }
        }
    }
    /**
     * 打印节点
     */
    public void print() {
        if (isEmpty()) {
            System.out.println("无");
        } else {
            NodeTemp nodeTemp = first.next;
            while (nodeTemp != null) {
                System.out.print(nodeTemp.no + "\t");
                nodeTemp = nodeTemp.next;
            }
            System.out.println();
        }
    }
}

public class Demone6 {
    public static void main(String[] args) {
        TestList linklist1 = new TestList();
        System.out.println(linklist1.isEmpty());
        for (int i = 0; i < 8; i++) {
            linklist1.addNode(new NodeTemp(i + 1));
        }
        linklist1.print();
        linklist1.search(7);
    }
}

　　　　　　算法结果：

 

　　　　

　　　　顺序查找的算法分析：

　　　　时间复杂度：在最差情况下，遍历完所有元素，进行了N次的比较，所以时间复杂度应该为O(n)

　　　　在平均情况下，假设数据出现的概率相等，则需要进行(n + 1) / 2 次。

　　　　当数据量大的情况下，就不适合使用顺序查找的方法。

 

　　　　　 2、二分查找

　　　　二分查找算法，就是在已经排好序的基础之上，将数据分成两部分，按照键值与中间的数进行比较，若小于中间值，就在前半部分，反之，就在后半部分，如此依次的循环下去，直到找到该元素即可。

　　　　

public class Demone7 {
    public static void main(String[] args) {
        int[] arrary = new int[]{1,2,3,4,5,6,7,8,9,10};
        System.out.println(BF(arrary, 6));
    }

    private static int BF(int[] arrary,int number) {
        int low = 0;
        int hight = arrary.length - 1;
        while (low <= hight && number != -1) {
            int mid = (low + hight) / 2;
            if (mid == number) {
                return mid;
            } else if (mid > number) {
                hight = mid - 1;
            } else if (mid < number) {
                low = mid +1;
            }
        }
        return -1;
    }
}

　　　　　二分查找算法分析：

　　　　　　时间复杂度：因为每一次的查找都会比上一次少一半的范围，最多需要比较（log₂n）向上取整 + 1 时间复杂度为O(log₂n)

　　　　　　二分查找算法必须事先经过排序，并且数据都要加载到内存中才能进行查找。

　　　　　　二分法查找适合于不需要增删的静态数据。

 

　　　　　3、插值查找法

 

 

 

 

 

　　　　     4、斐波那契查找法