[XJTUSE]数据结构学习——第一章 线性表 1.2 顺序表的实现（JAVA)

1.2 顺序表的实现（JAVA)

首先依据线性表的一组操作来定义该对象的抽象数据类型（ADT)，我利用泛型和接口来进行定义，代码如下：

public interface ListADT<E> {
    public void clear();//清空表

    public void insert(E it);//插入元素

    public void append(E it);//从表尾插入元素

    public Object remove();//删除当前位置的值并返回该位置的元素

    public void setFirst(); //将当前位置设置到初始位置

    public void prev();//位置前移

    public void next();//位置后移

    public void setPosition(int position); //设置当前位置

    public void setValue(E it);//设置当前位置的元素值

    public Object currValue(); //获取当前位置的元素值

    public int length();  //获取表实际大小

    public boolean isInList();//判断当前位置是否合规

    public boolean isFull();//判断表是否已经满了

    public boolean isEmpty(); //判断表是否为空

    public void print();  //打印表
}

自定义顺序表，实现代码如下：

//自定义一个顺序表
public class SequentialList<E> implements ListADT<E> {
    private static final int DEFAULT_SIZE = 10;//默认大小

    private int maxSize;//表的最大大小
    private int numInList;//表中的实际元素数
    private int curr;//当前元素的位置
    private E[] listArray; //包含所有元素的数组

    private void setUp(int sz) {//初始化方法
        maxSize = sz;
        numInList = curr = 0;
        listArray = (E[]) new Object[sz];
    }


    public SequentialList() {//默认构造
        setUp(DEFAULT_SIZE);
    }

    public SequentialList(int maxSize) {//限制大小的构造
        setUp(maxSize);
    }

    public void clear() {
        numInList = curr = 0;//元素清空
    }

    /*在当前位置插入一个元素，从curr开始的元素全部向后移动一位
       curr上的元素变为插入的元素
     */
    public void insert(E it) {
        if (isFull()) {
            System.out.println("list is full");
            return;//表满
        } else if (curr<0||curr>numInList) {
            System.out.println("bad value for curr");
            return;//当前位置不合规
        } else {
            for (int i = numInList; i > curr; i--) {
                listArray[i] = listArray[i - 1];
            }
            listArray[curr] = it;
            numInList++;
        }
    }

    //在表尾插入一个元素
    public void append(E it) {
        if (isFull()) {
            System.out.println("list is full");
            return;//表满
        } else {
            listArray[numInList] = it;
            numInList++;
        }
    }

    //删除当前位置的值并返回该位置的元素
    public E remove() {
        if (isEmpty()) {
            System.out.println("list is empty");
            return null;
        } else if (!isInList()) {
            System.out.println("no current element");
            return null;
        } else {
            E it = listArray[curr];
            for (int i = curr; i < numInList - 1; i++) {
                listArray[i] = listArray[i + 1];//元素前移
            }
            numInList--;
            return  it;
        }
    }

    //将当前位置设置到初始位置
    public void setFirst() {
        curr = 0;
    }

    //位置前移
    public void prev() {
        curr--;
    }

    //位置后移
    public void next() {
        curr++;
    }

    //设置当前位置
    public void setPosition(int position) {
        curr = position;
    }

    //设置当前位置的元素值
    public void setValue(E it) {
        if (!isInList()) {
            System.out.println("no current element");
        } else {
            listArray[curr] = it;
        }
    }

    //获取当前位置的元素值
    public E currValue() {
        if (!isInList()) {
            System.out.println("no current element");
            return null;
        } else {
            return listArray[curr];
        }
    }

    //获取顺序表实际大小
    public int length() {
        return numInList;
    }

    //判断当前位置是否合规
    public boolean isInList() {
        return (curr >= 0 && curr < numInList);
    }

    //判断顺序表是否已经满了
    public boolean isFull() {
        return numInList >= maxSize;
    }

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

    //打印顺序表
    public void print() {
        if (isEmpty()) {
            System.out.println("empty");
        } else {
            System.out.print("(");
            for (setFirst(); isInList(); next()) {
                System.out.print(currValue() + " ");
            }
            System.out.println(")");
        }
    }
}

测试代码如下：

public class SequentialListTest {
    public static void main(String[] args) {
        //测试顺序表
        SequentialList<Integer> list = new SequentialList<>();//默认构造最多10个元素
        list.print();//打印空表
        list.insert(1);
        list.insert(4);
        list.insert(2);
        list.insert(5);
        list.insert(3);
        list.insert(0);
        list.insert(2);//插入元素
        System.out.println("after insert: ");
        list.print();
        list.setPosition(2);
        list.remove();
        System.out.println("delete the third element:");
        list.print();
        list.setFirst();
        System.out.println("set first");
        list.setValue(7);
        System.out.println("change the current element from "+list.currValue()+" to 7:");
        list.print();
    }
}

运行结果如下：

empty
after insert: 
(2 0 3 5 2 4 1 )
delete the third element:
(2 0 5 2 4 1 )
set first
change the current element from 7 to 7:
(7 0 5 2 4 1 )