顺序表基本功能函数的实现

Posted 2021-09-05 小海浪.

• 🎓✏️线性表的概念
• 🎓✏️顺序表
• 🔍📐动态顺序表的实现
• • 🔍📐图解顺序表

🎓✏️线性表的概念

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常
见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的（比如链表），线性表在物理上存储时，通常以数组和链式结构的形式存储

🎓✏️顺序表

顺序表的概念：
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

🔍📐动态顺序表的实现

首先我们思考一个问题，顺序表底层的数据结构是一个数组，那么可以用这个数组取代顺序表，为什么要有这个顺序表呢？？为什么要存在顺序表呢？

我们可以简单的这样想，顺序表是一种数据结构，一种用来描述和组织数据的方式，数据在内存中的存储多种多样，为了实现处理数据，实现不同的功能，就有了不同的数据结构，比如说，在计算数组里的元素个数的时候，如果我们遍历数组，定义一个计数器，遇到非0计数器就+1，遇到0就结束程序，如果遇到数据是0和非0的数字交叉，或者我们存储的数据本身就是0，这种算法就是有问题的，数组就很鸡肋，因此我们通过顺序表实现该功能，放一个数记录一次。

🔍📐图解顺序表

接下来我们通过面向对象的思想来实现顺序表，1.找对象向，这个顺序表只有一个对象就是这个顺序表，2.创建对象，顺序表这个对象的成员属性包括一个数组，一个记录数组元素个数的标记usedsize，一个标识数组容量的成员，之后使用对象。

创建成员属性，调用构造方法初始化对象

public class MyArrayList {
    public int[] elem;//elem=null
    public int usedSize;//元素个数
    public static  int capacity = 10;//数组容量要比元素个数多，否则就要扩容

    public MyArrayList() {
        this.elem = new int[capacity];
        //this.usedSize = 0;
    }

我们初始化对象后，对象，成员属性的关系及内存布局大致如下：

❗💦在顺序表的某一个位置新增一个元素，大致分两种情况，如下图分析

 public boolean isFull() {//判断数组元素是否为满的，满了返回ture,否则返回false
        /*if(this.usedSize == capacity) {
            return true;
        }
        return false;*/
        return this.usedSize == capacity;
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        if(pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法！");
            return;
        }
        //1、满的情况   2、pos的合法情况
        if(isFull()) {
            //扩容
            this.elem =Arrays.copyOf(this.elem,2*capacity);//最少以两倍容量扩充
            capacity *= 2;//新的容量
        }
        for(int i = this.usedSize-1; i >= pos;i--) {
            this.elem[i+1] = this.elem[i];//元素个数没有达到数组容量，i+1后不会越界
        }
        this.elem[pos] = data;//第一次没有元素时添加新元素或在pos位置放置要新增的元素
        this.usedSize++;
    }

情况一

情况二

❗💦打印顺序表，遍历数组就行了

 // 打印顺序表
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] +" ");
        }
        System.out.println();
    }

判定是否包含某个元素
判断是否包含某个元素很简单。遍历数组就行，函数返回值boolean类型，找到为真返回true，没有找到为假返回false

public boolean isEmpty() {
        return this.usedSize == 0;
    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        if(isEmpty()) return false;//如果为空直接返回
        for (int i = 0; i < this.usedSize; i++) {
            if(this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

❗💦查找某个元素对应的位置，返回对应的元素下标，如果顺序表为空，没有找到返回-1

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

❗💦获取 pos 位置的元素
因为pos是作为数组下标，返回对应位置的元素的，所pos的取值为0~usedSize-1(包括两个端点）

// 获取 pos 位置的元素
    public int getPos(int pos) {
        if(isEmpty()) {
            //return -1; 业务的处理，返回-1我们应该知道顺序表此时是空的
            throw new RuntimeException("顺序表是空的");//手动抛出错误(异常)
        }
        if(pos < 0 || pos >= this.usedSize) {//判断位置的合法性
            throw new RuntimeException("pos不合法");//手动抛出错误(异常)
        }

        return this.elem[pos];
    }

获取顺序表长度，直接返回成员属性udedSize的值

 // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }

❗💦给 pos 位置的元素设为 value，pos也作为数组下标，pos为0表示给0位置的元素，第一个元素设为value值，以此类推，所以判断pos合法性的时候，pos要小于usedSize.

 // 给 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("顺序表为空！");//不判断是否为空也行，如果为空，usedsize 为0了数组长度为0，上面判断pos的合法性，不论你输入什么，都是不合法的
            return;
        }
        this.elem[pos] = value;
    }

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

 //删除第一次出现的关键字key
    public void remove(int toRemove) {
        if(isEmpty()) return;
        int index = search(toRemove);
        if(index == -1) {
            System.out.println("没有你要删除的数字");
            return;
        }
        for (int i = index; i < this.usedSize-1; i++) {//usedsize要减1，防止越界产生
            this.elem[i] = this.elem[i+1];//删除时向数组下标小的位置移动
        }
        this.usedSize--;//最后一个没有移动的元素也可以通过打印函数删除
    }

💥❇️清空顺序表,把所有元素设置为0，元素个数usedSize也置为0即可。

 // 清空顺序表
    public void clear() {
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = 0;
        }
        this.usedSize = 0;
    }
}

💥❇️把上面的所有代码复制到MyArrayList类里面就是完整的代码，下面是一个测试类，测试顺序表的功能的。

public class TestDemo {

    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        //myArrayList.add(-1, 1);
        myArrayList.add(0, 2);
        myArrayList.add(1, 3);
        myArrayList.add(2, 4);
        myArrayList.add(3, 4);
        myArrayList.remove(4);
    //    myArrayList.add(5, 4);
        myArrayList.display();
        }
        }

︿(￣︶￣)︿ (^▽) ( ＾∀＾）／欢迎＼( ＾∀＾）
记🉐点👍🏻🍹持👇🏻