数据结构01-线性表

说明：由于该数据结构是由java并且是原生实现，所以与C有一些出入，不过原理是相同的

1线性表的定义

　　一个线性表是由n个元素构成的有限序列（n>=0）。n=0时，线性表称为空表；当n>0时，线性表表示为（a1,a2,a3...an）a1称为线性表的第一个元素，an成为线性表的最后一个元素。除了第一个元素没有前驱结点和最后一个元素没有后继结点之外，其他节点都有唯一的前驱结点和后继结点。

2 实现原理

　　线性表是用数组实现的，包含一个数组和一个表示当前线性表大小的size ：

class List<T>{
     T[]  sorte;
     int length;
}

3 线性表的基本操作

　　1.init 　　　　初始化 生成一个空的线性表

　　2.clear　　　 清空，删除线性表中全部元素，逻辑上清空线性表

　　3.destory　　 销毁线性表，不再使用该线性表（注意删除与清空的区别）

　　4.empty　　   判断当前线性表是否为空

　　5.length　　   获取线性表当前的长度

　　6.insert 　　   插入一个元素

　　7.erase 　　  删除第i个元素

　　8.remove　　删除全部值为data的元素

　　9.add 　　     添加一个元素到末尾

4 代码实现

　　4.1 线性表代码实现

　　　　

 2 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Objects;

/**
 * @Author: xiaobai
 * @Date: 2019/4/30 22:03
 * @email: 
 * @address: 
 * @desc: 模拟线性表操作
 * @Version 1.0
 */
@SuppressWarnings("ALL")
public final class List<T> {
    /**
     * 用于存储值的数组 是线性表的核心(使用时根据泛型强转即可)
     */
    private Object[] store;

    /**
     * 当前线性表的长度
     */
    private int length;

    /**
     * 在第index个位置添加元素 索引从0开始
     * @param index 添加位置
     * @param data 被添加的元素
     * @return 插入结果
     */
    public boolean insert(int index,T data){
        //先判断是否在线性表之内
        if(index>this.length || 0 > index){
            return false;
        }
        //如果存储控件不够则需要进行扩容操作
        if(this.length+1>store.length){
            dilatation();
        }
        //将要插入的数据之后的每一位都向后移动
        for(int j = this.length+1;j>=index;j--){
            store[j] = store[j-1];
        }
        //插入数据
        store[index-1] = data;
        //添加数据，长度加一
        this.length++;

        return true;
    }

    /**
     * 删除线性表中第i个元素
     * @param i 被删除元素的位置
     * @return 删除的元素 删除失败返回null
     */
    public T erase(int i){
        //如果索引不合法  返回null
        if(i>this.length || 0>i){
            return null;
        }
        //先将被删除的元素取出
        T curr = (T)this.store[i];
        //从被删除元素位置开始 依次向前移动一个位置
        for(int j = i;j<length-1;j++){
            this.store[j] = this.store[j+1];
        }
        //删除数据 长度减一
        this.length--;
        return curr;
    }

    /**
     * 删除与data相等的元素
     * @param data 比较相等的元素
     * @return 删除的个数
     */
    public int remove(T data){
        //被删除元素的个数
        int count = 0;
        for(int i=0;i<=this.length;i++){
            //如果相等 说明应该删除
            if(compare(data,(T)this.store[i])){
                //删除一个元素
                T del = erase(i);
                if(null != del){
                    //如果删除成功 则删除元素个数加一
                    count ++;
                }
            }
        }
        return count;
    }

    /**
     * 向顺序表末尾添加一个数据
     * @param data 被添加的数据
     * @return 添加结果
     */
    public boolean add(T data){
        //如果长度不够 则扩容
        if(this.length+1>this.store.length){
            dilatation();
        }
        this.store[this.length++] = data;
        return true;
    }

    /**
     * 相当于init方法，这里使用构造方法进行初始化
     */
    public List(){
        this(16);
    }

    /**
     * 相当于init方法，这里使用构造方法进行初始化
     * @param defalut 初始化大小，如果不指定 默认16
     */
    public List(int defalut){
        this.store = new Object[defalut];
        this.length = 0;
    }

    /**
     * 清空线性表  逻辑清空 让长度等于0 即可
     */
    public void clear(){
        this.length = 0;
    }

    /**
     * 销毁线性表 使该线性表不可用
     */
    public void destroy(){
        //这是不安全的  会导致空指针异常
        this.store = null;
        this.length = 0;
    }

    /**
     *判断线性表是否为空
     * 为空返回true 不为空返回false
     */
    public boolean empty(){
        return this.length==0;
    }

    /**
     * 获取线性表的长度
     */
    public int length(){
        return this.length;
    }

    /**
     * 扩容操作
     */
    private void dilatation(){
        //开辟一个原数组1.5倍长度的新数组
        Object[] newStore = new Object[(int)(store.length*1.5)];
        //将原来的值拷贝过来
        System.arraycopy(store,0,newStore,0,store.length);
        //使用新的数组，原数组由于没有引用会被GC线程回收
        store = newStore;
    }

    /**
     * 比较方法，用于判断两个对象是否相等
     * 一般要求使用者重写这个方法或者重写所存储类型的equals方法
     * @param t1 被比较对象1
     * @param t2 被比较对象2
     * @return 比较结果
     */
    public boolean compare(T t1,T t2){
        //若有引用为空 认为不相等
        if(null == t1 || null == t2){
            return false;
        }
        //基本类型值相等 引用类型地址相等认为相等
        if(t1 == t2){
            return true;
        }
        //若地址不想等或者引用不相等 则调用存储对象的equals方法比较
        return t1.equals(t2);
    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder().append("hashcode = "+this.hashCode()+"  ").append("[");
        for(int i=0;i<this.length;i++){
            sb.append(this.store[i]+" ");
        }
        sb.append("]");
        return sb.toString();
    }
}

　　4.2测试代码及结果

　　　　

/**
 * @Author: xiaobai
 * @Date: 2019/4/30 22:53
 * @email:
 * @address:
 * @Version 1.0
 */
public class TestMyList {
    public static void main(String[] args) {
        System.out.println("初始化线性表");
        List<Integer> testList = new List<>();
        System.out.println("当前线性表长度 "+testList.length());
        System.out.println("线性表是否为空 "+testList.empty());
        for(int i=1;i<=20;i++){
            testList.add(i);
        }
        System.out.println("添加20个元素后线性表长度 "+testList.length());
        System.out.println("线性表内容 "+testList);

        System.out.println("在第五个位置上插入100 "+testList.insert(5,100));
        System.out.println("插入后的线性表 "+testList);

        System.out.println("删除第0个位置的数据 "+testList.erase(0));
        System.out.println("删除后的线性表 "+testList);

        //再插入两个8 加上之前的一共有三个8
        testList.add(8);testList.add(8);
        System.out.println("删除所有值为8的元素 共删除： "+testList.remove(8));
        System.out.println("删除8后的线性表 "+testList);

        testList.clear();
        System.out.println("清空线性表后线性表长度："+testList.length());
        System.out.println("清空后的线性表 "+testList);

        testList.destroy();

    }
}

　　　　运行结果：