数据结构之线性表之顺序存储Java实现

Posted 2021-11-10 pier～呀

文章目录

• 线性表的定义
• 线性表的基本运算
• 线性表的存储之顺序存储
• • 定义线性表
  • 添加元素
  • 查找元素
  • 删除元素
  • 打印线性表
  • 实现的完整代码
  • 测试一下

线性表的定义

• 线性表的逻辑特征：
  • ①有且仅有一个称为开始元素的a1，她没有前趋，仅有一个后继结点a2；
  • ②有且仅有一个称为终端元素的an,他没有后继，只有一个直接前驱a(n-1)；
  • ③其余元素ai(2≤i≤n-1)称为内部元素，他们都有且仅有一个直接前驱a(i-1)和直接后继a(i+1)。

线性表的图像表示

线性表的基本运算

• 线性表初始化
• 求表长
• 按索引值查找元素
• 按值查找
• 插入元素
• 删除

线性表的存储之顺序存储

线性表顺序存储的定义：线性表的顺序存储指的是将线性表的数据元素按其逻辑次序依次存入一组连续的存储单元里，用这种方式存储的线性表称为顺序表。

定义线性表

• 定义线性表的默认空间大小，定义一个数组，定义数组的长度，初始化一个size用来保存里面元素的个数。

 	/** 定义线性表默认空间大小 */
    private final Integer ListSize=100;
    /**定义数组长度*/
    private Integer Len;
    /** 定义线性表保存的数据类型
     * 使用泛型*/
    private Object[] list;
    /**存一个当前元素的个数*/
    private Integer size=0;
    /**定义默认线性表*/
    public SeqList(){
        Len = ListSize;
        this.list = new Object[Len];
        size++;
    }

• 初始化线性表
  • 把线性表里面的元素全部置空

	/**清空线性表*/
    public void clear(){
        for (int i = 0; i < size; i++) {
            list[i]=null;
        }
        size=0;
    }

添加元素

• 这里采用尾插法，即每次默认将元素放在最后面

	/**添加元素到指定位置*/
    public void insert(T element , int index){
        if(index>=Len || index<0){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
        }
        Capacity(size+1);
        //将添加元素的元素往后移一位
        for (int i = size-2; i >= index-1; i--) {
            list[i+1]=list[i];
        }
        list[index-1]=element;
        size++;
    }
    /**添加元素到末尾*/
    public void add(T element){
        insert(element,size);
    }

查找元素

• 这个模块分为按索引值查找，和按元素值查找

	/**线性表的查找
     * 按索引值查找*/
    public T getNode(int index){
        return (T)list[index-1];
    }
    /**按元素值查找返回索引值*/
    public int LocateNode(T t){
        for(int i=0;i<list.length;i++){
            if(list[i].equals(t)){
                return i+1;
            }
        }
        System.out.println("没有找到该元素！");
        return -1;
    }

删除元素

• 删除元素，又分为删除指定元素，和删除最后一个元素

    /**删除指定位置的元素*/
    public T delete(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("删除位置不在线性表的索引范围内！");
        }
        for (int i = index-1; i < size-1; i++) {
            list[i]=list[i+1];
        }
        /*if(size - index >0){
            System.arraycopy(list,index,list,index-1,size-index);
        }*/
        list[size-1]=null;
        size--;
        return (T) list;
    }
    /**删除最后一个元素*/
    public T remove(){
        return delete(size-1);
    }

打印线性表

• 打印线性表，其实就是重写一个toString方法，将线性表打印出来

/**循环打印线性表*/
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        if(isEmpty()){
            return "[]";
        }
        else {
            sb.append("[");
            for (int i = 0; i < size-1; i++) {
                int a=0;
                if(list[i]!=null){
                    sb.append(list[ i ]);
                }
                else {
                    break;
                }
                sb.append(",");
            }
            sb.append("]");
            sb.deleteCharAt(sb.indexOf(",]"));
        }
        return sb.toString();
    }

实现的完整代码

class SeqList<T>{
    /** 定义线性表默认空间大小 */
    private final Integer ListSize=100;
    /**定义数组长度*/
    private Integer Len;
    /** 定义线性表保存的数据类型
     * 使用泛型*/
    private Object[] list;
    /**存一个当前元素的个数*/
    private Integer size=0;
    /**定义默认线性表*/
    public SeqList(){
        Len = ListSize;
        this.list = new Object[Len];
        size++;
    }
    /**定义自定义长度的线性表*/
    public SeqList(int length){
        Len = length;
        list = new Object[Len];
        size++;
    }
    /**获取当前线性表的长度*/
    public int getLen(){
        return Len;
    }
    /**获取当前线性表元素的个数*/
    public int getSize(){
        return size;
    }
    /**根据元素查找在线性表中的位置，未找到返回-1*/
    public int getIndex(T element){
        for (int i = 0; i < size; i++) {
            if(list[i].equals(element)){
                return i;
            }
        }
        return -1;
    }
    /**判断是否表满或表空*/
    private boolean OutIndex(int index){
        //return size==Len;//不扩容的话，可以这样写，但是怕扩容
        if(index>size || index<0){
            return false;
        }
        else {
            return true;
        }
    }
    /**根据索引值返回元素*/
    private T getElement(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
            /* System.out.println("输入索引超过了线性的范围");
            return null; */
        }
        return (T)list[index];
    }
    /**扩容*/
    private T Capacity(int capacity){
        if(capacity<Len){
            Len = Len+(Len+1)/2;
            if(capacity<Len){
                Capacity(Len);
            }
            else {
                list = Arrays.copyOf(list,Len);
                return (T) list;
            }
        }
        return (T)list;
    }
    /**添加元素到指定位置*/
    public void insert(T element , int index){
        if(index>=Len || index<0){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
        }
        Capacity(size+1);
        //将添加元素的元素往后移一位
        for (int i = size-2; i >= index-1; i--) {
            list[i+1]=list[i];
//            System.out.println("i="+i);
        }
        list[index-1]=element;
        size++;
    }
    /**添加元素到末尾*/
    public void add(T element){
        insert(element,size);
    }
    /**判断元素表是否为空*/
    public boolean isEmpty(){
        return size==0;
    }
    /**删除指定位置的元素*/
    public T delete(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("删除位置不在线性表的索引范围内！");
        }
        for (int i = index-1; i < size-1; i++) {
            list[i]=list[i+1];
        }
        /*if(size - index >0){
            System.arraycopy(list,index,list,index-1,size-index);
        }*/
        list[size-1]=null;
        size--;
        return (T) list;
    }
    /**删除最后一个元素*/
    public T remove(){
        return delete(size-1);
    }
    /**清空线性表*/
    public void clear(){
        for (int i = 0; i < size; i++) {
            list[i]=null;
        }
        size=0;
    }
    /**线性表的查找
     * 按索引值查找*/
    public T getNode(int index){
        return (T)list[index-1];
    }
    /**按元素值查找返回索引值*/
    public int LocateNode(T t){
        for(int i=0;i<list.length;i++){
            if(list[i].equals(t)){
                return i+1;
            }
        }
        System.out.println("没有找到该元素！");
        return -1;
    }
    /**循环打印线性表*/
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        if(isEmpty()){
            return "[]";
        }
        else {
            sb.append("[");
            for (int i = 0; i < size-1; i++) {
                int a=0;
                if(list[i]!=null){
                    sb.append(list[ i ]);
                }
                else {
                    break;
                }
                sb.append(",");
            }
            sb.append("]");
            sb.deleteCharAt(sb.indexOf(",]"));
        }
        return sb.toString();
    }
}

测试一下

• 测试代码

	public static void main(String[] args) {
        SeqList<String> seqList = new SeqList<String>();
        //添加一个元素
        seqList.add("pier");
        seqList.add("真好看");
        seqList.add("90度点头");
        System.out.println("添加后的线性表为\\n\\t"+seqList.toString());
        seqList.insert("pipi",1);
        System.out.println("在位置1的地方添加元素后的线性表为\\n\\t"+seqList.toString());
        seqList.delete(1);
        System.out.println("删除第二个元素后的线性表为\\n\\t"+seqList.toString());
        System.out.println("pier时第"+seqList.LocateNode("pier")+"个元素");
        System.out.println("第1个元素是"+seqList.getNode(1)+"。");
    }

• 运行结果