从零开始学数据结构与算法-线性结构-数组

数组

最熟知和最简单的线性结构那就是数组了。

线性查找数组中的元素

//线性查找数组中的元素
public class TestSearch {
    public static void main(String[] args) {
        int[] array = new int[]{1, 2, 3, 4, 5, 6};
        int target = 5;
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            if (target == array[i]) {
                index = i;
                break;
            }
        }
        System.out.println("index :" + index);
    }
}

上面的代码非常简单，一看就能明白。但时间复杂度为 O(n)。

假设一个数组中还是10个元素，需要比较第一个元素是否等于数组中任何其它元素，算法需要运行9次。如果数组中有100个元素呢，算法需要运行99次，也就是n-1次，算法运行的次数随着n的不同而发生改变。人们把这种算法写成O(n)，1可以忽略不计，读成"n阶"。

二分法查找数组中的元素

//二分法查找数组中的元素
public class TestBinarySearch {
    public static void main(String[] args) {
        int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        int target = 9;
        int begin = 0;
        int end = array.length - 1;
        int mid = (begin + end) / 2;
        int index = -1;
        while (begin <= end) {
            if (array[mid] == target) {
                index = mid;
                break;
            } else if (array[mid] > target) {
                end = mid - 1;
            } else {
                begin = mid + 1;
            }
            mid = (begin + end) / 2;
        }
        System.out.println("index:" + index);
    }
}

如果数组中的元素是已经排序好的，那我们可以使用“二分法”来查找元素。
这样运行代码，查找效率显著提升，时间复杂度为 O(log n)。

假设一个数组长度为n,每次查找后数据长度减半，第一次查找后数据长度为n/2,第二次查找后数据长度为n/(2^2)，第k次查找后数据长度为n/(2^k)，最坏情况下数数据长度为1时找到该数，即n/(2^k)=1, 解得k=log2(N)，忽略掉底数则为 log(n)