数据结构（二）之线性表（顺序表示）

线性结构的特点：

1. 存在唯一的一个被称作“第一个”的数据元素
2. 存在唯一 的一个被称作“最后一个”的数据元素
3. 除了第一个外，集合中每个数据元素均只有一个前驱；
4. 除最后一个元素外，集合中每个数据元素均只有一个后继；

线性表的类型定义：
线性表是常用且最简单的一种数据结构.简言之，一个线性表示n个数据元素的有限序列.至于每个数据元素的具体含义，在不同情况下各不相同，他可以是一个数或一个符号，也可以是一页书，甚至是其他更复杂的信息.例如26个英文字母的字母表。
（A，B，C，…Z）
是一个线性表.
在稍复杂的线性表中，一个数据元素可以由若干个数据项组成，在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件.
例如：一个学校的学生信息，他由姓名，学号，性别，年龄，班级等5个数据项组成

姓名	学号	性别	年龄	班级
王林	201600001	男	12	软一
陈红	201600002	女	11	软一
爱钱进	201600003	男	13	计一

下面的一条信息成为记录（数据元素）而列名为5个数据项

姓名（数据项）	学号（数据项）	性别（数据项）	年龄（数据项）	班级（数据项）
王林	201600001	男	12	软一

当表里面没有数据我们称为空表

简单实现线性表顺序表示（采用数组）

package main.com.cs.abstractDataType;

import java.util.Arrays;

public class AbstractDataType {

    //定义抽象数组
    private int[] arr;

    public int[] getArr() {
        if(arr == null){
            throw new NullPointerException("数组为空");
        }
        return arr;
    }

    public void setArr(int[] arr) {
        if(arr == null){
            throw new NullPointerException("数组为空");
        }
        this.arr = arr;
    }

    public AbstractDataType(){

    }

    public AbstractDataType(int[] arr){
        init(arr);
    }

    //初始化
    private void init(int[] arr){
        if(arr == null){
            throw new NullPointerException("数组为空");
        }
        this.arr = arr;
    }

    //销毁
    public void destoryDataType(){
        this.arr = null;
    }

    //插入元素  插入到末尾
    public int put(int a){
        if(this.arr.length != 0){
            int[] arr  = new int[this.arr.length +1 ];
            for (int i = 0; i < arr.length; i++) {
                if (i != this.arr.length){
                    arr[i] = this.arr[i];
                }else {
                    arr[i] = a;
                }
            }
            this.arr = null;
            this.arr = arr;
        }else {
            arr[0] = a;
        }
        return a;
    }


    //在指定位置 插入元素
    public int put(int index,int a){

        //如果  索引小于 0 或者 索引 大于 数组长度  那么就直接插入到最后面
        if(index < 0 || index > this.arr.length){
           put(a);
       }else {
            //定义一个 新的数组  长度为原来数组长度多1
            int[] arr  = new int[this.arr.length + 1];

            for (int i = 0; i < arr.length; i++) {
                if(i < index){
                    arr[i] = this.arr[i];
                }

                if(i == index){
                    arr[i] = a;
                }

                if(i > index){
                    arr[i] = this.arr[i-1];
                }
            }

            this.arr = arr;
        }
        return  a;
    }


    //删除 指定 元素
    public int delete(int a){
        //判断元素是否存在
        int contain = contain(this.arr, a);

        if (contain == 0){
            throw new RuntimeException("元素不存在");
        }

        int[] arr = new int[this.arr.length - contain];

        int index = 0;
        for (int i = 0; i < this.arr.length; i++) {
            if (this.arr[i] != a){
                arr[index] = this.arr[i];
                index ++ ;
            }
        }

        this.arr = arr;
        return  a;
    }


    //判断是否包含 此元素
    public int  contain(int[] arr,int a){
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (a == arr[i]){
                count ++;
            }
        }
        return  count;
    }


    @Override
    public String toString() {
        return "AbstractDataType{" +
                "arr=" + Arrays.toString(arr) +
                '}';
    }

    public static void main(String[] args) {
        int[] a = {1,2,3};
        AbstractDataType  abstractDataType = new AbstractDataType(a);
        abstractDataType.put(4);
        abstractDataType.put(5);
        abstractDataType.put(0,0);
        abstractDataType.delete(0);
        System.out.println(abstractDataType.toString());
    }
}