[java]顺序表的头插，尾插，头删，尾删，中间插入，删除元素

import java.util.Arrays;
public class SeqList {
 // 属性
  private int[] array; // 用来保存数据
  private int size;  // 保存 array 已经有的数据个数
  // 构造方法
  public SeqList() {
   // 初始化部分
   // 1. 初始化 array，给定一个默认大小
   // 2. 初始化 size，没有数据，所以 size = 0
   array = new int[11]; // 11 可以调节
   size = 0;
  }  
  // 支持的方法
  // 头插 O(n)
  public void pushFront(int element) {
   ensureCapacity();   
   // i 是数据下标，遍历范围是 [size - 1, 0]
   for (int i = size - 1; i >= 0; i--) {
    array[i+1] = array[i];
   }   
   // [0] 空出来了
   array[0] = element;
   size++;
  }  
  // 尾插 O(1)
  public void pushBack(int element) {
   ensureCapacity();   
   array[size++] = element;
  } 
  // 中间插入，根据下标做插入 O(n)
  public void insert(int index, int element) {
   // index 的合法性 [0, size]
   if (index < 0 || index > size) {
    System.out.println("index 非法");
    return;
   }   
   ensureCapacity();  
   // i 代表的是空间的下标
   for (int i = size; i > index; i--) {
    array[i] = array[i - 1];
   }   
   array[index] = element;
   size++;
  }  
  // 头删
  public void popFront() {
   if (size == 0) {
    System.out.println("空顺序表，无法删除");
    return;
   }
   for (int i = 0; i < size - 1; i++) {
    array[i] = array[i + 1];
   }
   array[--size] = 0;
  } 
  public void popBack() {
   if (size == 0) {
    System.out.println("空顺序表，无法删除");
    return;
   }
   array[--size] = 0;
  }  
  public void erase(int index) {
   if (size == 0) {
    System.out.println("空顺序表，无法删除");
    return;
   }
  }  
  // 查找
  public int indexOf(int element) {
   for (int i = 0; i < size; i++) {
    if (array[i] == element) {
     return i;
    }
   }   
   return -1;
  }  
  // 根据下标，获取元素
  public int get(int index) {
   if (index < 0 || index >= size) {
    System.out.println("下标错误");
    return -1;
   }
   return array[index];
  } //[java]顺序表的头插，尾插，头删，尾删，中间插入，删除元素
  // 给定下标，修改下标所在元素的值
  public void set(int index, int element) {
   array[index] = element;
  } 
  public int size() {
   return size;
  }  
  public boolean isEmpty() {
   return size == 0;
  }  
  public int capacity() {
   return array.length;
  }  
  // 便于打印，显示顺序表中已有元素
  public String toString() {
   return Arrays.toString(
    Arrays.copyOf(array, size)
   );
 }  
 // O(n)
  public void remove(int element) {
   int index = indexOf(element);
   if (index != -1) {
    erase(index);
   }
  }  
  public void removeAll(int element) {
   // 时间：O(n^2) 空间：O(1)
   /*
   int index;
   while ((index = indexOf(element)) != -1) {
    erase(index);
   }
   */   
   /* 时间：O(n) 空间：O(n)
   int[] newArray = new int[size];
   int j = 0;
   for (int i = 0; i < size; i++) {
    if (array[i] != element) {
     newArray[j++] = array[i];
    }
   }  
   // 最后剩下的数一共有 j 个
   // 1. 把数据搬回去 2. 更新 size
   for (int i = 0; i < j; i++) {
    array[i] = newArray[i];
   }
   size = j;
   */ 
   /* 时间：O(n) 空间：O(1)
   */
   int j = 0;
   for (int i = 0; i < size; i++) {
    if (array[i] != element) {
     array[j++] = array[i];
    }
   }
   size = j;
  } 
  // 内部使用的方法
  // 无论是否需要扩容，调用完这个方法，保证容量一定够用
  private void ensureCapacity() {
   if (size < array.length) {
    // 不需要扩容
    return;
   }  
   int newCapacity = array.length + array.length / 2;
   int[] newArray = new int[newCapacity];
   for (int i = 0; i < array.length; i++) {
    newArray[i] = array[i];
   }
   this.array = newArray;  
   } 
    public static void test1(String[] args) {
   SeqList seqList = new SeqList();  
   // []
   System.out.println(seqList.toString());
   // 尾插 1 2 3
   seqList.pushBack(1);
   seqList.pushBack(2);
   seqList.pushBack(3);
   // [ 1, 2, 3 ]
   System.out.println(seqList.toString());  
   // 头插 10 20 30
   seqList.pushFront(10);
   seqList.pushFront(20);
   seqList.pushFront(30);
   // [ 30, 20, 10, 1, 2, 3 ]
   System.out.println(seqList.toString());  
   seqList.insert(2, 100);
   seqList.insert(4, 200);
   // [ 30, 20, 100, 10, 200, 1, 2, 3 ]
   System.out.println(seqList.toString());
   System.out.printf("当前容量: %d%n", seqList.capacity());  
   seqList.pushBack(1000);
   seqList.pushBack(2000);
   seqList.pushBack(3000);
   seqList.pushBack(4000);
   seqList.pushBack(5000);
   seqList.pushBack(6000);
   System.out.printf("当前容量: %d%n", seqList.capacity());
   seqList.popFront();
   seqList.popFront();
   seqList.popFront();
   seqList.popFront();
   // [ 200, 1, 2, 3 ]
   System.out.println(seqList.toString());  
   seqList.popBack();
   seqList.popBack();
   seqList.popBack();
   // [ 200 ]
   System.out.println(seqList.toString());
  } 
  public static void test2(String[] args) {
   SeqList s = new SeqList();
   s.pushBack(1);
   s.pushBack(2);
   s.pushBack(3);
   s.pushBack(4);
   s.pushBack(1);
   s.pushBack(2);
   s.pushBack(3);
   s.pushBack(4);
   // [ 1, 2, 3, 4, 1, 2, 3, 4 ]
   System.out.println(s.toString());
   s.remove(2);
   // [ 1, 3, 4, 1, 2, 3, 4 ]
   System.out.println(s.toString());
   s.removeAll(4);
   // [ 1, 3, 1, 2, 3 ]
   System.out.println(s.toString());
  }  
  public static void main(String[] args) {
   test1(args);
   test2(args);
  }
}