04、Java 数据结构：有序数组和二分查找_对有序组进行二分查询java

1 有序数组

数据按照一定规则排序的数组称为有序数组，一般为数字从小到大排序

2 二分查找

2.1 思想

假设数据是按升序排序的，对于给定值 x，从序列的中间位置开始比较，如果当前位置值等于 x，则查找成功；若 x 小于当前位置值，则在数列的前半段中查找；若 x 大于当前位置值则在数列的后半段中继续查找，直到找到为止

2.2 查找次数

有序数组二分查找的次数，数据量越大，越显得高效
数据量——比较次数 log₂N = log₁₀N*3.322
10————4
100————7
1000————10
10000————14
100000————17
1000000————20
10000000————24
100000000————27
1000000000————30

3 有序数组优缺点分析

优点： 采用二分查找效率高，比无序数组效率高
缺点： 插入的时候，要移动元素，比无序数组效率低
有序和无序数组共同缺点： 删除的时候要都要移动元素，效率低

4 代码实现

public class OrderArray {
    public static void main(String[] args) {
        //创建无序数组
        IOrderArray array = new IOrderArray(10);
        //插入数据
        array.insert(4);
        array.insert(7);
        array.insert(9);
        array.insert(2);
        //显示数据
        array.display();//2 4 7 9
        //二分查找
        System.out.println(array.get(4));//1
        //删除数据
        array.delete(4);
        array.display();
    }
}

class IOrderArray {
    private Long[] array;//有序数组
    private int nElement;//数组中存在的数据个数

    //构造方法，初始化 arraySize 长度的有序数组，并初始化数据个数为 0
    public IOrderArray(int arraySize) {
        array = new Long[arraySize];
        nElement = 0;
    }

    //插入数据
    public void insert(long data) {

        //判断数组长度
        if (nElement == array.length) {
            return;
        }

        //从头遍历找到要插入的位置
        int i;
        for (i = 0; i < nElement; i++) {
            if (array[i] > data) break;
        }
        //找到要插入的位置，将后面的所有元素后移一个位置，插入元素,元素个数加一
        if (i < nElement) {
            for (int j = nElement; j > i; j--) {
                array[j] = array[j - 1];
            }
            array[i] = data;
            nElement++;
        } else { //没有找到要插入的位置，直接插入,元素个数加一
            array[i] = data;
            nElement++;
        }
    }

    //寻找数据：二分查找
    public int get(long data) {
        int lowerBound = 0;//下边界
        int upperBound = nElement - 1;//上边界
        int curint = 0;//当前位置
        while (true) {
            curint = (lowerBound + upperBound) / 2;
            if (data == array[curint]) {//找到数据，直接返回
                return curint;
            } else if (data < array[curint]) {//如果数据小于中间数据，将上边界缩小
                upperBound = curint - 1;
            } else {//如果数据大于中间数据，将下边界扩大
                lowerBound = curint + 1;
            }
            if (curint == upperBound) {//找不到数据
                return -1;
            }
        }
    }

    //删除数据：先查找数据，再删除数据，再将后面的所有数据前移一个位置，最后数据个数减一
    public void delete(long data) {//只会删除找到的第一个目标数组
        int n = get(data);//得到数据索引位置
        if (n == -1) {
            return;
        }
        for (int i = n; i < nElement; i++) {
            array[i] = array[i + 1];
        }
        nElement--;
    }

    //遍历数组：读取数组的每个数据项
    public void display() {
        for (int i = 0; i < nElement; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

5 总结

5.1 无序数组

插入新数据的时候很高效：O(1)，查找和删除数据较慢：O(n)

5.1 有序数组

查找数据的时候很高效：O(logn)，但插入数据和删除数据上费劲：O(n)