数据结构与算法-自定义顺序表API

API设计

类名	MyArrayList
构造方法名	public MyArrayList () public MyArrayList (int capacity)
成员方法	public void insert(T t) ；往顺序表添加一个元素 public void insert(int i,T t)；在指定索引处添加一个元素 public void clear()；清空整个顺序表； public int length()；获取顺序表数据个数（长度） public T remove(int index)；删除指定索引处元素，并将其返回 public int indexOf(T t)；获取该元素第一次出现的索引 public boolean isEmpty()；判断顺序表是否为空 public T get(int index)；获取顺序表中指定索引处的值 public void resize(int capacity)；执行扩容操作
成员变量	private int size；记录当前顺序表的元素个数 public T[] eles；存储元素的数组 private final int DEFAULT_SIZE = 10；创建线性表时，如果不指定长度，则默认长度是10

API设计思路

1.空参构造方法设计

---

代码如下

    /**
     * 初始化数据
     */
    public MyArrayList() {
        size = 0;
        eles = (T[]) new Object[DEFAULT_SIZE];
    }

---

  在创建线性表时，如果不指定顺序表长度，就会执行无参的构造方法，无参构造方法体内；会创建一个Object类型的数组强转为泛型T给eles成员变量赋值，数组长度默认是10；并为成员变量size赋值为0

---

2.有参构造方法设计

---

代码如下

    /**
     * 初始化数据
     */
    public MyArrayList(int capacity) {
        size = 0;
        eles = (T[]) new Object[capacity];
    }

---

  在创建线性表时，指定顺序表长度，就会执行一个参的构造方法，构造方法体内；会创建一个Object类型的数组强转为泛型T给eles成员变量赋值，数组长度是创建时指定的长度；并为成员变量size赋值为0

---

3.insert（T t）往顺序表添加元素

---

代码如下

public void insert(T t) {
        if (size == eles.length) {
            resize(2 * eles.length);
        }
        eles[size++] = t;
    }

---

  在执行添加操作的时候，先判断插入数据后元素的个数是否等于数组的长度，如果等于的话则说明数组长度已经不够了，需要要先对数组进行扩容操作，再继续完成添加操作。添加操作只需要为eles数组的size索引处赋值即可,如何数组元素个数size自增1（将指针往后移动一位）

1. 比如创建一个线性表，不指定长度（默认为10），引用数据类型初始值为null
   
2. 这个时候记录元素个数的属性size值 为0（指向的是eles 数组0索引处）

3. eles[size++] = t; 这段代码表示为size索引处赋值t，然后size 自增1（也就是指针需要往后移动一位）；先赋值，后自增

4. 后续的插入操作以此类推，先赋值，后移动指针

4.insert(int index,T t)；在指定索引处添加元素

---

代码如下

    public void insert(int index, T t) {
        //判断索引是否合法
        if (index > size || index < 0) {
            throw new RuntimeException("索引输出不合法");
        }
        //判断是否需要扩容
        if (size == eles.length) {
            resize(2 * eles.length);
        }
        //从后往前遍历，将index索引处空出来
        //size -1 获得最后一个元素的索引值
        for (int i = size - 1; i >= index; i--) {
            //将当前的值往后移动一位
            eles[i + 1] = eles[i];
        }
        //为指定索引处赋值
        eles[index] = t;
        //顺序表长度+1
        size++;
    }

---

   在执行添加操作的时候，先判断插入数据后元素的个数是否等于数组的长度，如果等于的话则说明数组长度已经不够了，需要要先对数组进行扩容操作，再继续完成添加操作。添加时首先判断用户传进来的索引是否合法，如果不合法则抛出异常信息。

• 假设我创建了一个长度为10的顺序表，我需要在该顺序表 4索引处添加元素g

• 思路：从最后一个元素开始遍历，包括index索引处的元素都需要往后移动一位，让index索引处的的元素空出来，再为index位置的索引赋值t。
  

5.clear() 清空顺序表

---

代码如下

    public void clear() {
        for (int i = 0; i < size; i++) {
            eles[i] = null;
        }
        this.size = 0;
    }

---

  将顺序表的eles 数组内容置为空，将线性表长度size 置为0 即可

6.length() 获取顺序表个数

---

代码如下

    public int length() {
        return size;
    }

---

  将记录线性表长度的 size 返回即可

7. remove(int index)；删除指定索引处元素，并将其返回

---

代码如下

    public T remove(int index) {
        //判断索引是否合法
        if (index > size || index < 0) {
            throw new RuntimeException("索引输出不合法");
        }
        //找到需要删除的索引处的元素
        T temp = get(index);
        //将需要删除元素的后面所有元素依次往前移动一位
        for (int i = index; i < size; i++) {
            //让 i 后面的元素往前移动
            eles[i] = eles[i + 1];
        }
        //删除后判断数据是不是原数组长度的四分之一，如果是的话进行缩容
        if (size < eles.length / 4) {
            resize(2 * eles.length);
        }
        //删除之后线性表长度减1
        size--;
        //返回删除的数据
        return temp;
    }

---

   先判断传入进来的索引是否合法，如果不合法则抛出异常。因为需要将删除的元素返回，要定义一个临时变量存储要删除的元素。使用for循环从 需要删除元素的 后面每个元素 往前移动一位

• 假设我创建了一个长度为10的顺序表，我需要删除顺序表 3索引处的元素d

• 思路：从索引index开始遍历，让后面的元素往前移动一位即可

  

8.indexOf(T t)；获取该元素第一次出现的索引

---

代码如下

    public int indexOf(T t) {
        for (int i = 0; i < size; i++) {
            if (eles[i].equals(t)) {
                return i;
            }
        }
        return -1;
    }

---

  这个操作比较简单，变量eles输出， 判断是否等于目标元素即可，如果找到返回索引i，如果找不到则返回-1

9.get(int index)；获取顺序表中指定索引处的值

---

代码如下

    public boolean isEmpty() {
        return size == 0;
    }

---

  这个操作也比较简单，只需要 判断顺序表元素个数是否为0即可

10.get(int index)；获取顺序表中指定索引处的值

---

代码如下

    public T get(int index) {
        return eles[index];
    }

---

  这个操作也比较简单，只需要 获取指定索引处元素即可

11.resize(int capacity)；执行扩容操作

---

代码如下

public void resize(int newSize) {
        //定义一个临时数组，指向原数组
        T[] temp = eles;
        //创建新数组
        eles = (T[]) new Object[newSize];
        //把原数组的数据拷贝到新数组即可
        for (int i = 0; i < size; i++) {
            eles[i] = temp[i];
        }
    }

  用户新增数据的时候或者删除数据的时候会执行这个方法，当用户新增数据，原数组已经容量不够了，根据用户传新来的参数创建信息数组，将原数组中的数据复制到新数组中。当用户删除数据的时候，根据顺序表参数个数和数组长度判断是否需要进行缩容操作

---

测试

闲言  csdn闲言  闲言博客  鸡哥  今晚打老虎  老牛  JAVA劝退师  记录成长，记录学习！  JAVA劝退师  
======================
顺序表的长度是9
删除索引4 处的数据是：鸡哥
顺序表的长度是8
JAVA劝退师元素第一次出现的索引是：5
======================

    public static void main(String[] args) {
        MyArrayList <String> list = new MyArrayList <String>();
        list.insert("闲言");
        list.insert("csdn闲言");
        list.insert("闲言博客");
        list.insert("鸡哥");
        list.insert("老牛");
        list.insert("JAVA劝退师");
        list.insert("记录成长，记录学习！");
        list.insert(4, "今晚打老虎");
        list.insert("JAVA劝退师");
        for (int i = 0; i < list.length(); i++) {
            System.out.print(list.get(i) + "  ");
        }
        System.out.println();
        System.out.println("======================");
        System.out.println("顺序表的长度是" + list.length());
        //删除指定索引处元素
        String remove = list.remove(3);
        System.out.println("删除索引4 处的数据是：" + remove);
        System.out.println("顺序表的长度是" + list.length());
        System.out.println("JAVA劝退师元素第一次出现的索引是：" + list.indexOf("JAVA劝退师"));
        System.out.println("======================");
    }

package cn.bloghut.linear;

/**
 * @author by 闲言
 * @classname MyList
 * @description 自定义顺序表API CRD操作
 * @date 2021/7/15 11:16
 */
public class MyArrayList <T> {
    //记录元素个数
    private int size;
    //默认长度
    private final int DEFAULT_SIZE = 10;
    //存储数据
    public T[] eles;

    /**
     * 初始化数据
     */
    public MyArrayList () {
        size = 0;
        eles = (T[]) new Object[DEFAULT_SIZE];
    }

    /**
     * 初始化数据
     */
    public MyArrayList (int capacity) {
        size = 0;
        eles = (T[]) new Object[capacity];
    }

    /**
     * 往顺序表添加元素
     *
     * @param t
     */
    public void insert(T t) {
        if (size == eles.length) {
            resize(2 * eles.length);
        }
        eles[size++] = t;
    }

    /**
     * 在指定位置处添加索引
     *
     * @param index
     * @param t
     */
    public void insert(int index, T t) {
        //判断索引是否合法
        if (index > size || index < 0) {
            throw new RuntimeException("索引输出不合法");
        }
        //判断是否需要扩容
        if (size == eles.length) {
            resize(2 * eles.length);
        }
        //从后往前遍历，将index索引处空出来
        //size -1 获得最后一个元素的索引值
        for (int i = size - 1; i >= index; i--) {
            //将当前的值往后移动一位
            eles[i + 1] = eles[i];
        }
        //为指定索引处赋值
        eles[index] = t;
        //顺序表长度+1
        size++;
    }

    /**
     * 获取顺序表长度
     *
     * @return
     */
    public int length() {
        return size;
    }

    /**
     * 获取指定索引处元素
     *
     * @param index
     * @return
     */
    public T get(int index) {
        return eles[index];
    }

    /**
     * 清空顺序表
     */
    public void clear() {
        for (int i = 0; i < size; i++) {
            eles[i] = null;
        }
        this.size = 0;
    }

    /**
     * 删除指定索引处元素
     *
     * @param index
     * @return
     */
    public T remove(int index) {
        //判断索引是否合法
        if (index > size || index < 0) {
            throw new RuntimeException("索引输出不合法");
        }
        //找到需要删除的索引处的元素
        T temp = get(index);
        //将需要删除元素的后面所有元素依次往前移动一位
        for (int i = index; i < size; i++) {
            //让 i 后面的元素往前移动
            eles[i] = eles[i + 1];
        }
        //删除后判断数据是不是原数组长度的四分之一，如果是的话进行缩容
        if (size < eles.length / 4) {
            resize(2 * eles.length);
        }
        //删除之后线性表长度减1
        size--;
        //返回删除的数据
        return temp;
    }

    /**
     * 获取该元素第一次出现的索引
     *
     * @param t
     * @return
     */
    public int indexOf(T t) {
        for (int i = 0; i < size; i++) {
            if (eles[i].equals(t)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 判断顺序表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 扩容数组
     *
     * @param newSize
     */
    public void resize(int newSize) {
        //定义一个临时数组，指向原数组
        T[] temp = eles;
        //创建新数组
        eles = (T[]) new Object[newSize];
        //把原数组的数据拷贝到新数组即可
        for (int i = 0; i < size; i++) {
            eles[i] = temp[i];
        }
    }
}