老规矩，看前欣赏美图

今天给大家分享一下数据结构中一个简单的顺序表。
首先，谈到数据结构，都知道他的逻辑是非常严谨的，要想学好数据结构，我们必须要做到的是多画图，多敲代码。很多东西你可能看得懂，但是你一上手，你就会发现，你根本写不出来，前期你可以适当的抄代码，但最后你还得自己思考，自己画图，然后敲代码。
今天，我就口头叙述该如何实现以下代码。
这是我们要实现的模板：

// 打印顺序表
    public void display() { }
    // 获取顺序表的有效数据长度
    public int size() { }
    // 在 pos 位置新增元素
    public void add(int pos, int data) { }
    // 判定是否包含某个元素
    public boolean contains(int toFind) { return true; }
    // 查找某个元素对应的位置
    public int search(int toFind) { return -1; }
    // 获取 pos 位置的元素
    public int getPos(int pos) { return -1; }
    // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) { }
    //删除第一次出现的关键字key
    public void remove(int toRemove) { }
    // 清空顺序表
    public void clear() { }

目录

• 打印顺序表
• 获取顺序表的有效长度
• 在pos位置新增元素
• 判定是否包含某个元素
• 查找某个元素的位置
• 获取pos位置的元素
• 给pos位置元素设为value
• 删除第一次出现的关键字key
• 清空顺序表
• 实现
• 总结

打印顺序表

根据上面写好的方法，我们在Java中定义好这个数组。
自己先创建一个类

public class MyArrayList {

    public int[] elem;  //这个数组（最好不要初始化）
    public int usedSize;//有效的数据个数

    public MyArrayList() {       //构造方法
        this.elem = new int[10]; //定义数组长度
    }

再写一个测试类，并new好对象

public class Test {

    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        
    }
}

这样打印顺序表就比较简单了

// 打印顺序表
    public void display() {                       //方法
        for (int i = 0; i < this.usedSize; i++) { //遍历这个数组
            System.out.print(this.elem[i]+" ");  //打印这个数组
        }
        System.out.println();                    //换行      
    }

然后实现它

public class Test {

    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
            myArrayList.display();
    }
}

当然，我们的usedSize并没有复制，所以打印了并没有结果。

获取顺序表的有效长度

这个比较简单，直接返回就可以了。

// 获取顺序表的有效数据长度
    public int size() {
        return this.usedSize;  //返回个数
    }

在pos位置新增元素

首先，我们想到了新增元素，就得在一个位置上加一个元素，数组的下标是从0开始的，元素个数是从1开始的，我们要先搞清楚这一点。
先写一个方法

 // 在 pos 位置新增元素
    public void add(int pos, int data) { }

我们要考虑以下几点
1：新增元素的位置是不是在这个数组类，我们要先判定以下
及pos < 0 或 pos > usedSize 这些位置都是不合法的。
2：新增一个元素后如果之前这个空间是满的，这个时候我们就要扩大这个空间了，要用到Array.copyOf()这个函数进行扩容
3：遍历这个数组，在要加的位置把他后面的元素后移腾出空间来
4：放入这个元素，元素增加一个，usedSize++一下。
这样我们思路就清晰了：

 // 在 pos 位置新增元素
    public void add(int pos, int data) {
    //第一步
         if(pos < 0 || pos > usedSize) {      //判定位置合不合法
            System.out.println("pos 位置不合法！");
            return;      //返回
        }
        //第二步
        if(isFull()) {      //判断这个数组满了没有
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length); 
            //满了就扩容2倍
        }
       //第三步 
        for (int i = this.usedSize-1; i >= pos ; i--) { 
        //后面的元素往前遍历,直至遇到新增的位置
            this.elem[i+1] = this.elem[i]; //把新增位置后面元素移到后面空出位置
        }
        //第四步
        this.elem[pos] = data; //新增元素
        this.usedSize++;      //元素加一
    }

    public boolean isFull() {    //实现上面的方法
        return this.usedSize == this.elem.length;  //满了
    }

判定是否包含某个元素

首先，我们得想到要包含某个元素，有就是true，没有就false就完了，所以我们可以这样写

// 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {  //从0位置开始遍历这个数组
            if(this.elem[i] == toFind) {   //有元素是要找的元素
                return true;         //找到了
            }
        }
        return false;      //遍历完都没有，没有找到
    }

查找某个元素的位置

同上一样，找到就返回这个位置，没有就没有

 // 查找某个元素对应的位置,找不到返回-1
    public int search(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if(this.elem[i] == toFind) {
                return i;  //找到了返回下标
            }
        }
        return -1;       //没有找到
    }

获取pos位置的元素

我们思考，又是关于pos位置的元素，那就得考虑pos在哪，合不合法，还有就是，这个数组是不是空的这些因素，我们可以这样写

// 获取 pos 位置的元素
    public int getPos(int pos) {
        if(pos < 0 || pos >= this.usedSize) {
            System.out.println("pos 位置不合法");
            return -1;         //不合法返回了-1
        }
        if(isEmpty()) {
            System.out.println("顺序表为空！");
            return -1;          //空表，返回-1  
        }
        return this.elem[pos];  //有他，返回他对应的元素
    }
public boolean isEmpty() {
        return this.usedSize==0;   //空表
    }

给pos位置元素设为value

更新元素，pos位置同上要先判断，合法在更新

 // 给 pos 位置的元素设为/更新 value
    public void setPos(int pos, int value) {
        if(pos < 0 || pos >= this.usedSize) {
            System.out.println("pos位置不合法");
            return;
        }
        if(isEmpty()) {
            System.out.println("顺序表为空！");
            return;
        }
        this.elem[pos] = value;
    }
public boolean isEmpty() {
        return this.usedSize==0;   //空表
    }

删除第一次出现的关键字key

删除元素，这个跟上面讲的新增元素有点像，要先考虑，表为不为空啊，有没有你要删的数呀，删完了怎么调整新的数组，这些都是我们要考虑的
我们可以这样写

 //删除第一次出现的关键字key
    public void remove(int toRemove) {
        if(isEmpty()) {
            System.out.println("顺序表为空！");
            return;
        }
        int index = search(toRemove);  
        //根据上面实现的方法找不找得到这个数
        if(index == -1) {
            System.out.println("没有你要删除的数字！");
            return;  //没有就返回
        }
        for (int i = index; i < this.usedSize-1; i++) {  
            this.elem[i] = this.elem[i+1];
             //有这个数，从这个数开始，把后面的数粘到前一个，从而把要删的数覆盖
        }
        this.usedSize--;  //删完数组减一个元素
    }

清空顺序表

这个简单，让他元素为空就行

public void clear() {
        this.usedSize = 0;  //有效数据为0
        }

实现

当然，我这里实现是把上面所有因素都放进去了，最好是写一个测一个，这样方便改正错误

public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        System.out.println(myArrayList.contains(4));
        System.out.println(myArrayList.contains(8));
        System.out.println(myArrayList.search(1));
        System.out.println(myArrayList.search(8));
        System.out.println(myArrayList.getPos(3));
        myArrayList.setPos(2,99);
        myArrayList.display();
        myArrayList.remove(2);
        myArrayList.display();
    }

总结

好了，今天的分享就到这里了，当然，我今天是用口水话叙述了这个简单的顺序表，希望对刚接触顺序表的你有帮助。但你要知道，学数据结构最重要的就是画图理解，当然还有自己敲代码练习，不是光看看光想想就可以成功的，既然决定了要学好数据结构就不能偷懒，当然，这句话是对你们说的，也是对博主自己说的。欢迎大家指正，感谢你的支持，祝我们一起进步！！