第二章、数组

时间长度：执行算法的时间长度与执行步数成正比，所以数组的查找算法时间(N/2步)要比插入算法(一步)长很多。删除(不允许重复)查找算法时间(N/2)加上移动剩下N/2个数据项，总共是N步。

允许重复的查找算法：即使找到了上一个，还得继续查找下一个，直到最后一个数据项。但是删除的话，需要检查N个数据项和移动大于等于N/2个数据项。这个操作的平均时间依赖于重复数据项在整个数组中的分布情况。算法的实现：

1. 每删除一个，就将其后的所有数据往前移一位，然后再从头开始查找？
2. 感觉不用从头开始，而应该从查找到的那位开始，这样效率会高一点。
3. 更好的做法是删除完了所有的关键字之后再进行整合？好像不太好实现。

	No Duplicates	Duplicates OK
Search	N/2 comparisons	N comparisons
Insertion	No comparisons, one moves	No comparisons, one moves
Deletion	N/2 comparisons, N/2 moves	N comparisons, more than N/2 moves

有序与无序数组的对比

1、插入操作慢，因为需要排序

2、查找快，因为有了排序

3、删除稍快，因为查找快

数组实现

/**
 * @author darren
 * @time 2020/5/24
 * @todo 有序数组
 **/
public class OrdArray<T extends Comparable<? super T>> {
    private int size;
    private T[] tArray;

    /**
     * 指向当前索引的下一个位置
     */
    private int index;
    /**
     * 是否允许重复
     */
    private boolean isDup;

    /**
     * 默认不允许重复
     *
     * @param array
     */
    public OrdArray(T[] array) {
        this.tArray = array;
        size = tArray.length;
        this.isDup = false;
    }

    public OrdArray(T[] array, boolean isDup) {
        this.tArray = array;
        size = tArray.length;
        this.isDup = isDup;
    }

    /**
     * 1、找到要插入的位置
     * 2、从该位置到末尾都需要往后挪动一位
     * 3、在该位置赋value值
     *
     * @param value
     * @return
     */
    public int add(T value) {
        /**
         * 不允许重复，并且在数组中有对应的值，直接返回-1
         */
        if (!isDup && getKey(value) != -1) {
            return -1;
        }

        int pos = getPosition(value, 0, index);
        /**
         * 不是在数组最后一位插入的，都需要挪动
         */
        if (pos != index) {
            System.arraycopy(tArray, pos, tArray, pos + 1, index - pos);
        }
        //先挪动一位，再赋值
        tArray[pos] = value;
        index++;

        return pos;
    }

    /**
     * 有序数组中的二分法查找，不再是线性查找
     *
     * @return 索引位置，-1代表没有找到
     */
    public int getKey(T value) {
        /**
         * 数组为空，直接返回；
         * 比最小值小，比最大值大，直接返回，不用二分法查找
         */
        if (index < 1 || (tArray[0].compareTo(value) > 0 || tArray[index - 1].compareTo(value) < 0)) {
            return -1;
        }
        return getKey(value, 0, index);
    }

    /**
     * 根据索引位置删除
     *
     * @param pos
     * @return 当前位置下的值
     */
    public T delete(int pos) {
        if (pos < 0 || pos >= index) {
            return null;
        }
        T value = tArray[pos];
        System.arraycopy(tArray, pos + 1, tArray, pos, index - pos - 1);
        tArray[index - 1] = null;
        index--;
        return value;
    }

    public int delete(T value) {
        int pos = getKey(value);
        if (pos != -1) {
            System.arraycopy(tArray, pos + 1, tArray, pos, index - pos - 1);
            tArray[index - 1] = null;
            index--;
        }
        return pos;
    }

    /**
     * 二分法查找算法
     *
     * @param value
     * @param sPos
     * @param ePos
     * @return
     */
    private int getKey(T value, int sPos, int ePos) {
        return binarySearch(value, sPos, ePos, true);
    }

    /**
     * 二分法查找，不管存不存在，都返回一个插入的索引值
     *
     * @param value
     * @param sPos
     * @param ePos
     * @return
     */
    private int getPosition(T value, int sPos, int ePos) {

        //等于小于最小值，返回0，数组所有的数据后移一位
        if (index < 1 || tArray[0].compareTo(value) >= 0) {
            return 0;
        }
        //大于等于最大值，返回当前索引的下一位
        if (tArray[index - 1].compareTo(value) <= 0) {
            return index;
        }

        return binarySearch(value, sPos, ePos, false);
    }

    /**
     * 二分算法核心实现
     *
     * @param value
     * @param sPos
     * @param ePos
     * @param isFind 是否需要真正找到value对应的索引
     * @return
     * @Todo 递归中return与非return的区别
     * 假设某个递归方法有返回值：
     * 递归中之所以使用return是用来返回最终执行的那个方法的返回值
     * 如果不使用return，那么返回值是首次进入该方法时的返回值
     */
    private int binarySearch(T value, int sPos, int ePos, boolean isFind) {
        /**
         * @todo 这个查找终止条件很关键
         */
        if (sPos > ePos) {
            return isFind ? -1 : (ePos + 1);
        }

        int pos = (sPos + ePos) / 2;
        /**
         * 发现值比数组的中间值小
         * @Todo 关键在于pos-1和pos+1
         */
        int compRlt = tArray[pos].compareTo(value);
        if (compRlt > 0) {
            //去掉return会导致返回的值是首次进入该方法时的返回值
            return binarySearch(value, sPos, pos - 1, isFind);
        } else if (compRlt < 0) {
            return binarySearch(value, pos + 1, ePos, isFind);
        }
        return pos;
    }

    /**
     * 正向排序
     * 1、首先决定内层循环的算法
     * 2、决定外层循环的次数：从最后开始比最前开始要好
     * 不要内层外层一起考虑
     */
    public void bubbleSort() {
        for (int i = index - 1; i > 0; i--) {    //只是用来控制次数，所以可前可后
            for (int j = 0; j < i; j++) {
                if (tArray[j] > tArray[j + 1]) {
                    swap(j, j + 1);
                }
            }
        }
    }

    /**
     * 选择排序算法精髓:
     * 和冒泡算法一样比较，但只是比较，找到最小值，直到比较完一次后后才进行交换
     * 然后进行下一次比较，并且比较的个数少了一个
     */
    public void selectSort() {
        for (int i = 0; i < index; i++) {
            int min = tArray[i];
            //pos的初始值很重要
            int pos = i;
            for (int j = i + 1; j < index; j++) {
                if (min > tArray[j]) {
                    min = tArray[j];
                    pos = j;
                }
            }
//此处的交换是放在内层循环的外面，因此减少了交换的次数
            swap(i, pos);
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (T t : tArray) {
            sb.append(t);
            sb.append(",");
        }
        sb.delete(sb.length() - 1, sb.length());
        sb.append("]");
        return sb.toString();
    }

    public static void main(String[] args) {
        Integer[] ints = new Integer[10];
        OrdArray<Integer> ordArray = new OrdArray<Integer>(ints, true);
        ordArray.add(5);
        ordArray.add(1);
        ordArray.add(7);
        ordArray.add(0);
        ordArray.add(9);
        ordArray.add(6);
        ordArray.add(6);
        int i1 = ordArray.getKey(1);
        int i2 = ordArray.getKey(9);
        int i3 = ordArray.getKey(3);
        int i4 = ordArray.delete(new Integer(7));
        int i5 = ordArray.delete(new Integer(0));
        int i6 = ordArray.delete(new Integer(9));
        Integer int1 = ordArray.delete(0);
        Integer int2 = ordArray.delete(3);
    }
}

数组不能满足插入删除查询都很快的要求。

为什么不将所有的数据用数组来存储

插入效率太低(有序数组)，查找、删除效率太低(无序)

另外，数组大小是固定的。