数据结构与算法--线性表的实现（代码）

实现线性表接口

//线性表的接口定义 继承了迭代接口Iterable
public interface MyList<E> extends Iterable<E>{
    public void add(E element);
    public void add(int index, E element);
    public void remove(E element);
    public E remove (int index);
    public E get(int index);
    public E set(int index, E element);
    public int size();
    public int indexOf(E element);
    public boolean contains(E element);
    public boolean isEmpty();
    public void clear();
    public void sort(Comparator<E> c);
    public List<E> sublist (int fromIndex, int toIndex);


}

方法重写

public class ArraysList01<E> implements MyList<E> {
    //成员变量
    private static int DEFAULT_CAPACITY = 10;//线性表的默认容量

    private E[] data;//线性表存储元素的容器 data.length 容器的最大容量

    private int size;//线性表中元素的有效个数 也表示默认在尾部添加的角标
    //size == data.length 表满   size == 0 表空

    //默认创建一个容量为DEFAULT_CAPACITY的线性表
    public ArraysList01(){
        this(DEFAULT_CAPACITY);
        //data = (E[]) new Objects[DEFAULT_CAPACITY];
        //size = 0;
    }

    //创建一个由用户指定容capacity的线性表
    public ArraysList01(int capacity){
        if(capacity < 0){
            throw new IllegalArgumentException("capacity must >= 0");
        }
        data = (E[]) new Object[capacity];
        size = 0;
    }

    //将一个一维数组转换成一个线性表
    public ArraysList01(E[] arr){
        if(arr == null){
            throw new IllegalArgumentException("arr can not be null");
        }
        data = (E[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        size = arr.length;
        /*
        data不能直接引入外部传入的数组arr
        否则外部对arr的修改会引起ArraysList01内部的一些问题
         */
    }

    //在线性表的表尾添加一个元素element
    @Override
    public void add(E element) {

        add(size,element);
    }

    //在线性表中指定的index下进行元素增加
    @Override
    public void add(int index, E element) {

        if(index < 0 || index > size){
            throw new IllegalArgumentException("add index out of bounds");
        }
        if(size == data.length){//判断线性表是否满了，满了扩容
            resize(data.length * 2);
        }
        for (int i = size - 1; i >= index ; i--) {
            data[i+1] = data[i];
        }
        data[index] = element;
        size++;
    }

    //实现了数组扩容的操作 也是先了数组缩容
    private void resize(int newLen) {
        //创建一个新数组
        E[] newData = (E[]) new Object[newLen];
        //将原数组data中的元素赋值到新数组newData中
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    //删除线性表中指定一个元素element
    @Override
    public void remove(E element) {
        //获取该元素的位置
        int index = indexOf(element);
        //判断元素的存在性 如果存在则根据角标删除该元素
        if(index != -1){
            remove(element);
        }

    }

    //删除线性表中指定角标处index的元素并返回
    @Override
    public E remove(int index) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("remove index out of bounds");
        }
        E rem = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size --;
        //判断是否要缩容 不要缩容的太多 至少保证一个最小值DEFAULT_CAPACITY
        //如果有效元素的个数是容量的1/4 且当前数组的长度是大于10的 则缩容
        if(size == data.length / 4 && data.length > DEFAULT_CAPACITY){
            resize(data.length / 2);
        }
        return rem;
    }

    //获取线性表中指定角标处index的元素
    @Override
    public E get(int index) {
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("get index out of bounds");
        }
        return data[index];
    }

    //在线性表中修改指定角标处index的元素值为新的值element 并返回原先的值
    @Override
    public E set(int index, E element) {
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("set index out of bounds");
        }
        E rem = data[index];
        data[index] = element;
        return rem;
    }

    //获取线性表中有效元素个数
    @Override
    public int size() {
        return size;
    }

    //获取线性表中数组的容量
    public int getCapacity(){
        return data.length;
    }

    //线性表中查找指定元素element的角标 并返回
    //从左到右第一次出现的位置
    //如果元素不存在 则返回-1
    @Override
    public int indexOf(E element) {

        for (int i = 0; i < size; i++) {
            if(element.equals(data[i])){
                return i;
            }
        }
        return -1;
    }

    //在线性表中判断是都包含指定元素element
    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    //判断线性表是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //清空线性表
    @Override
    public void clear() {
        //直接定义一个新数组
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    //根据比较器的规则 来对线性表进行排序
    @Override
    public void sort(Comparator<E> c) {
        if(c == null){
            throw new IllegalArgumentException("comparable can not be null");
        }
        int j = 0;
        E e = null;
        for (int i = 1; i < size; i++) {
            e = data[i];
            for( j = i; j > 0 && c.compare(data[j - 1], e) > 0; j--){
                data[j] = data[j - 1];
            }
            data[j] = e;
        }

    }

    //获取从fromIndex到ToIndex区间的子线性表
    @Override
    public List<E> sublist(int fromIndex, int toIndex) {
        if(fromIndex < 0 ){
            throw new IndexOutOfBoundsException("fromIndex must > 0");
        }
        if(toIndex > size){
            throw new IndexOutOfBoundsException("toIndex must < size");
        }
        if(fromIndex > toIndex){
            throw new IndexOutOfBoundsException("fromIndex must < toIndex");
        }
        ArrayList<E> subList = new ArrayList<>();
        for (int i = fromIndex; i <= toIndex; i++) {
            subList.add(data[i]);
        }
        return subList;
    }
    @Override
    public boolean equals(Object obj){
        //判断是否比自己
        if(this == obj){
            return true;
        }
        //判断obj是否为空
        if(obj == null){
            return false;
        }
        //判断obj是否和ArraysList是同一个类型
        if(getClass() != obj.getClass()){
            return false;
        }
        //判断比较内容
        ArraysList01 other = (ArraysList01) obj;
        //判断比较长度
        if(size != other.size){
            return false;
        }
        //判断数组内容
        return Arrays.equals(data, other.data);
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder(String.format("ArraysList01:%d/%d[",size,data.length));
        if(isEmpty()){
            sb.append("]");
        }else{
            for (int i = 0; i < size; i++) {
                sb.append(data[i]);
                if(i != size - 1){
                    sb.append(",");
                }else{
                    sb.append("]");
                }
            }
        }
        return sb.toString();
    }

    //获取ArraysList的迭代器
    @Override
    public Iterator<E> iterator() {
        return new ArraysList01Iterator();
    }

    class ArraysList01Iterator implements Iterator<E> {
        private int cur = 0;
        //判断之后是否有元素
        @Override
        public boolean hasNext() {
            return cur< size;
        }

        //先把元素返回然后在后移
        @Override
        public E next() {
            return data[cur++];
        }
    }
}

测试

public class TestArrayList01 {
    public static void main(String[] args) {
        ArraysList01<String> list = new ArraysList01<>();
        System.out.println(list);
        for(int i = 1; i < 13; i++){
            list.add("num"+i);
        }
        System.out.println(list);
        for (String num: list) {
            System.out.println(num);
        }

        System.out.println(list.sublist(3,7));
    }
}