資料結構之陣列

Array一些操作函式：

//自定義一個E型的泛型陣列
public class Array<E> {

private E data[];
private int size;

/**
 * 建構函式
 * @param capacity 傳入陣列容量
 */
public Array(int capacity){
    data=(E[])new Object[capacity];//先new一個Object的陣列，在強制轉換成E型的陣列
    size=0;
}

/**
 * 無引數的建構函式，預設陣列容量為capacity 10
 */
public Array(){
    this(10);
}

/**
 * 獲取陣列中的元素個數
 * @return
 */
public int getSize(){
    return size;
}

/**
 * 獲取陣列容量
 * @return
 */
public int getCapacity(){
    return data.length;
}

/**
 * 向所有元素後新增一個元素e
 * @param e 新增的元素
 */
public void addLast(E e){
    add(size,e );
}

/**
 * 在所有元素最前面新增一個元素e
 * @param e
 */
public void addFirst(E e){
    add(0,e );
}

/**
 * 在index位置新增一個新元素e
 * @param index 位置
 * @param e 新元素
 */
public void add(int index,E e) {

    //新增位置不在陣列內，丟擲異常
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
    }

    //擴容
    if(size == data.length)
         resize(2 * data.length);

    //依次從最後的位置開始往後移，直到index
    for (int i = size - 1; i >= index; i--) {
        data[i + 1] = data[i];
    }
    //新增到index位置
    data[index] = e;
    size++;
}

/**
 * 重寫toStrong函式
 * @return
 */
@Override
public String toString(){
    StringBuilder res=new StringBuilder();
    res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
    res.append('[');
    for(int i=0;i<size;i++){
        res.append(data[i]);
        if(i!=size-1){
            res.append(", ");
        }
    }
    res.append("]");
    return res.toString();
}

/**
 * 獲取index索引位置的元素
 * @param index
 * @return
 */
E get(int index){
    //位置不在陣列內，丟擲異常
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
    }
    return data[index];
}

/**
 * 修改索引位置的元素值
 * @param index
 * @param e
 */
void set(int index,E e){
    //位置不在陣列內，丟擲異常
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
    }
    data[index]=e;
}

/**
 * 查詢陣列中是否有元素e
 * @param e
 * @return
 */
public boolean contains(E e){
    for(int i=0;i<size;i++){
        //兩個類之間的值的比較用equals
        if(data[i].equals(e)){
            return true;
        }
    }
    return false;
}

/**
 * 查詢陣列中元素所在的索引，如果不存在，返回-1
 * @param e
 * @return
 */
public int find(E e){
    for(int i=0;i<size;i++){
        if(data[i].equals(e)){
            return i;
        }
    }
    return -1;
}

/**
 * 從陣列中刪除index位置的元素
 * @param index
 * @return
 */
public E remove(int index) {
    //陣列已空，丟擲異常
    if (size == 0) {
        throw new IllegalArgumentException("AddLast is failed");
    }
    //位置不在陣列內，丟擲異常
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
    }
    //儲存要刪除的元素
    E ret = data[index];
    //從index+1開始，依次往前移
    for (int i = index + 1; i < size; i++) {
        data[index] = data[i];
    }
    size--;

    //當size為容量的1/4時才進行縮容，防止複雜度的震盪
    if(size==data.length/4 && data.length/2!=0){
        resize(data.length/2);
    }
    return ret;
}

/**
 * 刪除第一個元素
 * @return
 */
public E removeFirst(){
    return remove(0);
}

/**
 * 刪除最後一個元素
 * @return
 */
public E removeLast(){
    return remove(size-1);
}

/**
 * 從陣列中刪除元素e
 * @param e
 */
public void removeElement(E e){
    int index=find(e);
    if(index!=-1){
        remove(index);
    }
}

/**
 * 動態陣列的定義修改
 * @param newCapacity 新容量
 */
private void resize(int newCapacity){
    E[] newData=(E[])new Object[newCapacity];//建立一個新陣列
    for(int i=0;i<size;i++){
        newData[i]=data[i];
    }
    data=newData;//將新陣列賦值給原來的陣列
}
 

}

測試函式

public class Main {

public static void main(String[] args) {

    Array<Integer> arr = new Array<>();//建立一個整型陣列
    for (int i = 0; i < 10; i++){
        arr.addLast(i);
    }
    System.out.println(arr);

    arr.add(0, 100);
    System.out.println(arr);

    arr.addFirst(-1);
    System.out.println(arr);
    // [-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    arr.remove(2);
    System.out.println(arr);

    arr.removeElement(4);
    System.out.println(arr);

    arr.removeFirst();
    System.out.println(arr);
}
}
 

測試結果

Array: size = 10 , capacity = 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size = 11 , capacity = 20
[100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size = 12 , capacity = 20
[-1, 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size = 11 , capacity = 20
[-1, 100, 9, 1, 2, 3, 4, 5, 6, 7, 8]
Array: size = 10 , capacity = 20
[-1, 100, 9, 1, 2, 3, 8, 5, 6, 7]
Array: size = 9 , capacity = 20
[7, 100, 9, 1, 2, 3, 8, 5, 6]