第二章、數組

時間長度：執行算法的時間長度與執行步數成正比，所以數組的查找算法時間(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);
    }
}

數組不能滿足插入刪除查詢都很快的要求。

爲什麼不將所有的數據用數組來存儲

插入效率太低(有序數組)，查找、刪除效率太低(無序)

另外，數組大小是固定的。