数组扩容技术与栈实现

1.MyArrayList

//能动态的扩容数组
public class YcArrayList {
    // 常量长度
    final int LENGTH = 5;
    // 初始数组，长度为5
    private int[] array = new int[LENGTH];
    // 索引标识，它用于指定数组当前存到第几个元素上了
    private int index = -1;
​
    // 获取这个动态数组实际存的元素个数
    public int size() {
        return index+1;
    }
    // 获取这个动态数组的容量
    public int capacity() {
        return array.length;
    }
    
    // 删除指定位置 position的元素
    public int remove(int position) {
        if (position < 0 || position > index) {
            System.out.println(position + "越界，没有这个下标");
            throw new RuntimeException("数组下标越界");
        }
        // 删除的位置
        int result = array[position];
        // 1.将position+1后面的值依次向前覆盖
        for (int i = position + 1; i <= index; i++) {
            array[i - 1] = array[i];
        }
        // 2.index--
        index--;
        return result;
    }
​
    // 存
    public void add(int data) {
        if (index >= array.length -1) {
            System.out.println("动态数组当前已满，开始自动扩容...");
            // 产生新数组 长度是原数组的2倍
            int[] newArray = new int[array.length * 2];
            // 将原数组的数组复制到新数组中
            for (int i = 0; i < array.length; i++) {
                newArray[i] = array[i];
            }
            array = newArray;
        }
        System.out.println(index+"=====");
        array[++index] = data;
    }
    
//  // 考虑扩容
//
//          if (index >= students.length) {
//              System.out.println("动态数组当前已满，开始自动扩容...");
//              // 产生新数组 长度是原数组的2倍
//              Pupil[] newArray = new Pupil[students.length * 2];
//              // 将原数组的数组复制到新数组中
//              for (int i = 0; i < students.length; i++) {
//                  newArray[i] = students[i];
//              }
//              students = newArray;
//          }
//          students[index] = student;
//          index++;
//      }
​
    // 根据position这个索引到array数组中取对应position下标的值，但要注意position不越界
    public int get(int position) {
        if (position < 0 || position > index) {
            System.out.println(position + "越界，没有这个下标");
            throw new RuntimeException("数组下标越界");
        }
        return array[position];
    }
​
    // 需求：
    // 1.在指定位置position开始插入一个数组y
    public void insert(int position, int[] y) {
        addArray(position, y);
    }
​
    private void addArray(int position, int[] y) {
        // 如果插入位置大于数组长度，不做处理
        if (position >= array.length || position < 0) {
            return;
        }
        int i = 0;
        // 动态扩容 保证一定能存放下数组y
        int[] newArray2 = new int[array.length + y.length];
        for (i = 0; i <= position; i++) {
            newArray2[i] = array[i];
        }
        int j = 0;
        // 加入数组y中的元素
        for (j = 0; j < y.length; j++, i++) {
            newArray2[i] = y[j];
        }
        // 加入数组array中剩余的元素
        for (int k = i - j; k < array.length; k++, i++) {
            newArray2[i] = array[k];
        }
        index = index + y.length;
        array = newArray2;
    }
​
    // 2.切片
    // 从指定的position删除num个数
    public int[] slice(int position, int num) {
        if (position < 0 || position + num > index || num < 0) {
            System.out.println(position + "越界，没有这个下标");
            throw new RuntimeException("数组下标越界");
        }
        //存储输入时position的位置
        int inPosition = position;
        // 删除的位置
        int[] result = new int[num];
        for (int i = 0; i < num; i++) {
            result[i] = array[position++];
        }
        System.err.println(Arrays.toString(result));
        System.err.println(Arrays.toString(array));
        System.err.println(index+"  " + array.length);
        // 1.将position+num+1后面的值一次向前覆盖
        for (int i = inPosition + num ; i <= index + num && i < array.length; i++) {
            array[i - num ] = array[i];
        }
        System.err.println(Arrays.toString(array));
        // 2.index--
        return result;
    }
​
    public void showArray() {
        System.out.println("------"+index+"-----");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
​
}
​

2.MyStack

//后进先出  数据结构
public class MyStack {
​
    // 常量长度
    final int LENGTH = 5;
    // 初始数组，长度为5
    private int[] array = new int[LENGTH];
    // 索引标识，它用于指定数组当前存到第几个元素上了
    private int index = 0;
​
    // 获取这个动态数组实际存的元素个数
    public int size() {
        return index;
    }
​
    // 获取这个动态数组的容量
    public int capacity() {
        return array.length;
    }
​
    // 存：只能存到栈的最后， 与ArrayList中的add相同
    public void push(int data) {
​
        if (index >= array.length) {
            System.out.println("动态数组当前已满，开始自动扩容...");
            // 产生新数组 长度是原数组的2倍
            int[] newArray = new int[array.length * 2];
            // 将原数组的数组复制到新数组中
            for (int i = 0; i < array.length; i++) {
                newArray[i] = array[i];
            }
            array = newArray;
        }
        array[index]=data;
        index++;
    }
​
    // 取：从栈顶取，且从栈顶去掉，而不能按索引取
    public int pop() {
        if(index==0) {
//          System.out.println("此是空栈..");
            throw new RuntimeException("此是空栈..");
        }
        index--;
        return array[index];
    }
​
    // 偷看：获取栈顶元素的值，但不删除
    public int peek() {
        if(index==0) {
//          System.out.println("此是空栈..");
            throw new RuntimeException("此是空栈..");
        }
        return array[index-1];
    }
}
​