数据结构之【线性表】篇

线性表是由n个数据元素组成的有限序列。

1.顺序表

顺序表具有按位序号随机存取（直接访问）的特性

---

ILineList接口：

在 Java 中我们可以使用一个接口来进
行定义。如此在使用类来完成抽象数据类型的具体实现时，我们只要实现相应的接口就实现
了对抽象数据类型定义的操作的实现。

public interface ILineList <Object>{        
    int getLength();    //线性表的长度
    boolean isEmpty();  //判断线性表是否为空
    public void clear();    //清空线性表
    boolean InsertNode(int index,Object value); //插入value对象
    boolean InsertNode(Object a);   //插入a，无指定插入位置
    Object DeleteNode(int index);   //删除操作
    Object Get(int index);  //返回序号为index的对象
    Object Set(int index,Object value); //设置序号为index对象为a，返回原对象
     public void display();     //显示线性表
    }

SeqList顺序表：

public class SeqList implements ILineList{
    int length; //顺序表的当前长度
    int MaxSize;    //顺序表的最大长度
    Object[] data;  //数据元素

    public SeqList(){   //构造方法，指定空表的默认容量
        /*
         * 创建指定容量为默认长度为10的空表
         */
        this(10);
    }

    public SeqList(int size){       //构造方法，创建指定容量的空表
        MaxSize = size;             //设置顺序表的最大长度
        length = 0;                 //设置顺序表的当前长度
        data = new Object[size];    //创建指定容量为size的空表
    }
    public int getLength() {
        return length;
    }

    @Override
    public boolean isEmpty() {
        return length==0;
    }

    @Override
    public void clear() {
        /*
         *  1.如果顺序表的长度不为0，则设置顺序表的每个数据元素为null
         *  2.设置顺序表的长度为0
         */
        for(int i=0;i<length;i++){
            data[i]=null;
        }
        length = 0;
    }

    @Override
    public boolean InsertNode(int index,Object a) {
        /*
         * 注意区别index的开始位置为0或1
         *  1.判断顺序表是否已满
         *  2.判断index位置是否合理，如index<0等
         *  3.数据元素从index位置开始后移（将第length-1个至index个存储位置） 
         *  4.设置index位置的元素为a
         *  5.顺序表的长度加1
         */
        if(isFull())
            return false;
        if(index<0||index>length)
            return false;
        for(int k =length;k>index;k--)
            data[k] = data[k-1];
        data[index] = a;
        length++;
        return true;
    }

    @Override
    public boolean InsertNode(Object a) {
        if(isFull())
            return false;
        data[length] =a;
        length++;
        return true;
    }

    @Override
    public Object DeleteNode(int index) {
        /*
         * 注意区别index的开始位置为0或1
         * 1.判断线性表是否为空
         * 2.定义对象保存index位置的对象
         * 3.将第index+1到length（共length-index）个数据元素依次前移
         * 4.线性表的最后一个元素设置为空对象
         * 5.顺序表的长度减一
         */
        if(isEmpty()){
            return null;
        }
        if(index<0||index>length)
            return null;
        Object tempNode = (Object)data[index];
        for(int i=index;i<length-1;i++)
            data[i]=data[i+1];
        data[length]=null;
        length--;
        return tempNode;
    }

    @Override
    public Object Get(int index) {

        return data[index];
    }

    @Override
    public Object Set(int index, Object value) {
        /*
         * 1.判断index为有效位置，value不为空
         * 2.定义对象old保存index位置的对象
         * 3.设置index未知的对象为value
         * 4.返回老对象old
         */
        if(index<0||index>length)
            return null;
        Object old = data[index];
        data[index] = value;
        return old;
    }

    public boolean isFull(){
        /*
         * 如果顺序表的长度为最大长度，则返回true，否则返回false
         */
        return length == MaxSize;
        }

    public void display(){
        for(int i=0;i<length;i++)
            System.out.print(data[i]);
    }
}

测试类：

public class TextSeqList {

    public static  void main(String[] args) {
        // TODO 自动生成的方法存根
        SeqList aa = new SeqList(10);
        aa.InsertNode(0,"a");
        aa.InsertNode("pp");
        aa.InsertNode(2,"le");
        aa.display();
        System.out.println(aa.getLength());
        aa.DeleteNode(2);
        aa.display();
        aa.clear();
        aa.display();
    }
}

优点：

• 存储密度高，可以随机存取结点

缺点：

• 长度固定；插入和删除操作需要移动节点，效率低