数据结构-线性表（顺序表的实现）

小鱼的学习笔记

已于 2023-04-05 19:41:54 修改

阅读量468

点赞数 5

分类专栏：数据结构&MySQL 文章标签：数据结构 java 开发语言

于 2023-03-31 22:36:02 首次发布

本文链接：https://blog.csdn.net/qq_58969626/article/details/129881025

版权

数据结构&MySQL 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

向指定位置插入元素void add(int index,E e);

把index位置元素从线性表中删除并返回 E remove(int index);

找到从前往后的第一个e并删除boolean remove(E e);

获取index位置的元素并返回E get(int index);

设置index位置的元素为e并返回原来的元素E set(int index,E e);

清空线性表void clear();

返回第一个e所在下标int indexOf(E e);

返回最后一个e所在下标int lastIndexOf(E e);

判断线性表中是否包含元素eboolean contains();

线性表中的元素个数int size();

判断线性表中元素个数是否为空boolean isEmpty();

线性表整体代码以及测试代码

数据结构(Data Structure)，研究数据是如何进行组织的。

容器(Collection):按照特性方式组织数据的一个结构。

元素(Element):存放在容器中的数据。

空：容器不存在（null）VS 容器存在但是没有元素（empty）。

对于空这个概念，我们举一个现实生活中的例子来看：比如说一个桶是空的，可以理解为桶里没有水（empty），也可以认为桶不存在（null）。

用数组来看就是：

int[] array;
array = null;        //null
array = new int[0];  //empty

线性表（List）

线性表中的所有元素，除了第一个元素和最后一个元素之外，其余的每个元素都有唯一的前置元素和唯一的后继元素。

线性表是一个有序的集合，即只在位置上有序，不要求大小有序。

线性表是有下标的（index），因为元素排列是有序的，有下标才有排序的能力。

合法的下标[0,size) size即元素个数（类似于数组）

最终在实现线性表时，有顺序表（ArrayList）和链表（LinkedList）两种方式。

由于线性表是抽象的，顺序表和链表是具体的，所以表现在代码中时：线性表是一个接口（java.util.List<E>）,顺序表（java.util.ArrayList<E>）和链表（java.util.LinkedList<E>）是类。即ArrayList和LinkedList实现了List接口。

我们可以通过以下步骤来查看ArrayList：

可以看到ArrayList是一个类，可以看到ArrayList实现了List接口：

我们还可以通过以下步骤查看ArrayList继承的类和实现的接口：

List接口下的常见方法

方法	作用
boolean add(E e);	尾插，只会返回true（往队尾插元素永远可以插进去）
void add(int index,E e);	把e放入index位置 [a,b,c,d]->add(2,e)->[a,b,e,c,d] index的取值范围：[0,size] （index=0即为头插）
boolean addAll(Collection<E> c);	把c中的所有元素按照一定顺序添加到线性表中（末尾）
E remove(int index);	把index位置的元素从线性表中删除并且返回 index的取值范围：[0,size)
boolean remove(E e);	从线性表中从前到后，找到第一个遇到的e并删除
E get(int index);	获取index位置的元素并返回，但是不会从线性表中删除该元素 index的取值范围：[0,size)
E set(int index,E e);	设置index位置的元素为e并返回原来的元素 index的取值范围：[0,size)
void clear();	清空（empty）线性表
boolean contains();	判断线性表中是否包含元素e
int indexOf(E e);	返回第一个e所在下标
int lastindexOf(E e);	返回最后一个e所在的下标
List<E> subList(int fromIndex,int toIndex)	[a,b,c,d,e,f]获取[1,3)序列->[b,c]
int size();	线性表中的元素个数
boolean isEmpty();	判断线性表中元素个数是否为空，等价于size()==0

注意：只有add方法在使用时可以取到size。

顺序表(ArrayList)

1.顺序表是一种线性表，元素严格按照逻辑的前后顺序在内存中排列（类似于数组）；

2.需要两个属性来管理顺序表：array（保存元素的数组）、size（保存元素个数）；

3.array.length（容量） VS size（元素个数）。

（我们为了区分元素和下标，固定Long包装类对象来作为元素类型）。

关于array.length和size: 比如，一个教室可以容纳30个人，那么它的length就是30，但是不上课的时候教室里面是没有人的，所以说size就是0。

在具体的实现顺序表中的方法之前，我们先定义一个类：

class MyArrayList{
    private Long[] array;    /null代表没有元素
    private int size;
}

那么如何写对象呢？

MyArrayList list = new MyArrayList();
list.array = null;
list.size = -3;

上面的的是符合约束的吗？答案是否定的，因为size即线性表中的元素个数是不能为空的。

因此如何写一个合法的对象以及对对象进行约束呢？

1.size>=0;

2.size<=capacity即array.length（元素个数小于等于线性表的容量）；

3.array在[0,size)范围内不能为空，在[size,capacity)范围内必须为null；

顺序表的实现

构造对象的方法在语法上有两种体现：1.构造方法 2.示例代码块

尾插boolean add(E e);

//尾插
//时间复杂度：O(1)
public boolean add(Long e){
    //TODO:扩容随后完成
    array[size] = e;    //插入到最后面
    size++;             //尾插后元素个数增加
    return true;        //顺序表中不会出现插入失败
}

向指定位置插入元素void add(int index,E e);

在向指定位置插入元素之前，需要先将index位置空出来，因此将[index,size]之间的元素都向后移动一个位置，为了避免后面的值覆盖前面的值，采用从后往前移动的方式，即先将元素D向后移动一个位置，再将元素C向后移动一个位置，此时index位置已经空出，这时将元素E放入即可。

//向指定位置插入元素
public void add(int index,Long e){
    //TODO:扩容随后完成
    for (int i = size - 1; i >= index ; i--) {
        array[i + 1] = array[i];  //从后往前移动元素
     }
    array[index] = e;   //在指定位置放入元素
    size++;
}

//向指定位置插入元素
public void add(int index,Long e){
    for (int i = size; i > index ; i--) {
    array[i] = array[i - 1];  //从后往前移动元素
     }
    array[index] = e;   //在指定位置放入元素
    size++;             //元素个数增加
}

以上两段代码均可以正确执行，只是角度不同。

行为未定义

C语言：int array[10];

(0,10]下标时，必须给用户一个对应位置的值。当其他下标时，则是行为未定义。

Java语言：int[10] array;

(0,10]下标时，必须给用户一个对应位置的值。当其他下标时，必须给用户一个异常。

array[11]; 在C语言中时行为未定义，在Java中规定是异常。

把index位置元素从线性表中删除并返回 E remove(int index);

public Long remove(int index){
    //合法的下标
    Long e = array[index];
    if(index < 0 || index >= size){
        throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
    }
    for (int i = index + 1; i < size ; i++) {
    array[i - 1] = array[i];
    //System.arraycopy  不会产生新的对象
    //Arrays.copyOfRange 复制并产生一个新的对象
    }
    array[size - 1] = null; //移动后将原来的位置置空
    size--;
    return e;
}

public Long remove(int index){
    //合法的下标
    Long e = array[index];
    if(index < 0 || index >= size){
        throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
    }
    for (int i = index; i <= size - 2 ; i++) {
    array[i] = array[i + 1];
    //System.arraycopy  不会产生新的对象
    //Arrays.copyOfRange 复制并产生一个新的对象
    }
    array[size - 1] = null; //移动后将原来的位置置空
    size--;
    return e;
}

找到从前往后的第一个e并删除boolean remove(E e);

引用的比较：

== ：同一性（即两个的是不是同一个）。

equals：比较引用的值是否相等。

解引用操作：根据引用找到对象，然后操作对象。

x[n] --r.m --r,m()

public boolean remove(Long e){
    for (int i = 0; i < size; i++) {
        //array[i]是Long类型，e也是类型
        //引用 == 比较：同一性（即两个的是不是同一个）
        if(array[i].equals(e)){
        //array[i].equals(e)是解引用操作
        // 解引用合法的前提：引用得指向某个对象 r != null
        remove(i);    //删除相等的第一个元素
        return true;//找到了e并成功删除
        }
    }
    return false;
}

获取index位置的元素并返回E get(int index);

//获取index位置的元素并返回
//时间复杂度：O(1)
    public Long get(int index){
    //合法的下标
    if(index < 0 || index > size){
        throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
    }
    return array[index];
}

设置index位置的元素为e并返回原来的元素E set(int index,E e);

//设置index位置的元素为e并返回原来的元素
//时间复杂度：O(1)
public Long set(int index,Long e){
    //合法的下标
    if(index < 0 || index > size){
        throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
    }
    Long m = array[index];  //将原来index位置的元素保存起来
    array[index] = e;       //将index位置的元素设置为e
    return m;               //返回原来index位置的元素
}

清空线性表void clear();

//清空线性表
//时间复杂度：O(n)
public void clear(){
    for (int i = 0; i < size; i++) {
        array[i] = null;  //原有的元素均置空
    }
    size = 0;
}

返回第一个e所在下标int indexOf(E e);

//返回第一个e所在下标
//时间复杂度：O(n)
public int indexOf(Long e){
    for (int i = 0; i < size; i++) {
        if(array[i].equals(e)){
            return i;
        }
    }
return -1;
}

返回最后一个e所在下标int lastIndexOf(E e);

//返回最后一个e所在下标
//时间复杂度：O(n)
public int lastIndexOf(Long e){
    for (int i = size - 1; i >= 0; i++) {
        if(array[i].equals(e)){
            return i;
         }
    }
return -1;
}

判断线性表中是否包含元素eboolean contains();

//判断线性表中是否包含元素e
public boolean contains(Long e){
    return indexOf(e) != -1;
}

线性表中的元素个数int size();

//线性表中的元素个数
public int size(){
    return size;
}

判断线性表中元素个数是否为空boolean isEmpty();

//判断线性表中元素个数是否为空
public boolean ieEmpty(){
    return size == 0;
}

线性表整体代码以及测试代码

测试部分代码

//测试部分
    //检查语法情况
    public void whetherlegal(){
        if(size < 0){
            throw new RuntimeException("size 小于 0 了");
        }
        if(array == null){
            throw new RuntimeException("array 是 null 了");
        }
        if(size > array.length){
            throw new RuntimeException("size 大于 capacity 了");
        }
        for (int i = 0; i < size; i++) {
            if(array[i] == null){
                throw new RuntimeException("array[0,size) 出现了 null 了，i = "+i);
            }
        }
        for (int i = size; i < array.length; i++) {
            if(array[i] != null){
                throw new RuntimeException("array[size,array.length) 出现了 !null 了，i = "+i);
            }
        }
    }
    //检查元素清况
    public void Elements(long[] exceptElements){
        if(size != exceptElements.length){
            throw new RuntimeException("当前 size 不符合预期 size，size = " + size);
        }
        for (int i = 0; i < size; i++) {
            if(array[i] != exceptElements[i]){
                //array是Long类型，exceptElements是long类型，编译器会自动拆箱
                throw new RuntimeException("元素和预期的元素不符，i = " + i);
            }
        }
    }

完整代码

public class MyArrayList {
    //属性定义
    private Long[] array;
    private int size;

    //构造方法
    public MyArrayList(){
        //对变量进行初始化
        array = new Long[20];   //由于Long是包装类型（引用类型），初始值为null
        size=0;
    }
    //尾插
    //时间复杂度：O(1)
    public boolean add(Long e){

        //TODO:扩容随后完成
        array[size] = e;    //插入到最后面
        size++;             //尾插后元素个数增加
        return true;        //顺序表中不会出现插入失败
    }
    //向指定位置插入元素
    //时间复杂度：O(n)
    public void add(int index,Long e){
        //合法的下标
        if(index < 0 || index > size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        //TODO:扩容随后完成
        for (int i = size-1; i >= index ; i--) {
            array[i + 1] = array[i];  //从后往前移动元素
        }
        array[index] = e;   //在指定位置放入元素
        size++;             //元素个数增加
    }
    //把index位置元素从线性表中删除并返回
    //时间复杂度：O(n)
    public Long remove(int index){
        //合法的下标
        Long e = array[index];
        if(index < 0 || index >= size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        for (int i = index + 1; i < size ; i++) {
            array[i - 1] = array[i];
            //System.arraycopy  不会产生新的对象
            //Arrays.copyOfRange 复制并产生一个新的对象
        }
        array[size - 1] = null; //移动后将原来的位置置空
        size--;
        return e;
    }
    //找到从前往后的第一个e删除
    //时间复杂度：O(n)
    public boolean remove(Long e){
        for (int i = 0; i < size; i++) {
            //array[i]是Long类型，e也是类型
            //引用 == 比较：同一性（即两个的是不是同一个）
            if(array[i].equals(e)){
                //array[i].equals(e)是解引用操作
                // 解引用合法的前提：引用得指向某个对象 r != null
                remove(i);  //删除相等的第一个元素
                return true;//找到了e并成功删除
            }
        }
        return false;
    }
    //获取index位置的元素并返回
    //时间复杂度：O(1)
    public Long get(int index){
        //合法的下标
        if(index < 0 || index > size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        return array[index];
    }
    //设置index位置的元素为e并返回原来的元素
    //时间复杂度：O(1)
    public Long set(int index,Long e){
        //合法的下标
        if(index < 0 || index > size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        Long m = array[index];  //将原来index位置的元素保存起来
        array[index] = e;       //将index位置的元素设置为e
        return m;               //返回原来index位置的元素
    }
    //清空线性表
    //时间复杂度：O(n)
    public void clear(){
        for (int i = 0; i < size; i++) {
            array[i] = null;
        }
        size = 0;
    }
    //返回第一个e所在下标
    //时间复杂度：O(n)
    public int indexOf(Long e){
        for (int i = 0; i < size; i++) {
            if(array[i].equals(e)){
                return i;
            }
        }
        return -1;
    }
    //返回最后一个e所在下标
    //时间复杂度：O(n)
    public int lastIndexOf(Long e){
        for (int i = size - 1; i >= 0; i++) {
            if(array[i].equals(e)){
                return i;
            }
        }
        return -1;
    }
    //判断线性表中是否包含元素e
    public boolean contains(Long e){
        return indexOf(e) != -1;
    }
    //线性表中的元素个数
    public int size(){
        return size;
    }
    //判断线性表中元素个数是否为空
    public boolean ieEmpty(){
        return size == 0;
    }

    //测试部分
    //检查语法情况
    public void whetherlegal(){
        if(size < 0){
            throw new RuntimeException("size 小于 0 了");
        }
        if(array == null){
            throw new RuntimeException("array 是 null 了");
        }
        if(size > array.length){
            throw new RuntimeException("size 大于 capacity 了");
        }
        for (int i = 0; i < size; i++) {
            if(array[i] == null){
                throw new RuntimeException("array[0,size) 出现了 null 了，i = "+i);
            }
        }
        for (int i = size; i < array.length; i++) {
            if(array[i] != null){
                throw new RuntimeException("array[size,array.length) 出现了 !null 了，i = "+i);
            }
        }
    }
    //检查元素清况
    public void Elements(long[] exceptElements){
        if(size != exceptElements.length){
            throw new RuntimeException("当前 size 不符合预期 size，size = " + size);
        }
        for (int i = 0; i < size; i++) {
            if(array[i] != exceptElements[i]){
                //array是Long类型，exceptElements是long类型，编译器会自动拆箱
                throw new RuntimeException("元素和预期的元素不符，i = " + i);
            }
        }
    }

    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.whetherlegal();
        list.Elements(new long[0]); //期待一开始的元素个数是0个
        System.out.println(list.ieEmpty());//true

        list.add(100L);
        list.whetherlegal();
        list.Elements(new long[] { 100 });
        System.out.println(list.ieEmpty());//false

        list.add(200L);
        list.whetherlegal();
        list.Elements(new long[] { 100,200 });

        list.add(0,50L);
        list.whetherlegal();
        list.Elements(new long[] { 50,100,200 });

        list.add(list.size(),300L);
        list.whetherlegal();
        list.Elements(new long[] { 50,100,200,300 });

        long e = list.remove(0);
        list.whetherlegal();
        list.Elements(new long[] { 100,200,300 });
        System.out.println(e);

        list.clear();
        list.whetherlegal();
        list.Elements(new long[0]);

    }
}

运行结果：

加上扩容后的代码：

public class MyArrayList {
    //属性定义
    private Long[] array;
    private int size;

    //构造方法
    public MyArrayList(){
        //对变量进行初始化
        array = new Long[20];   //由于Long是包装类型（引用类型），初始值为null
        size = 0;
    }
    public MyArrayList(int capacity){
        array = new Long[capacity];
        size = 0;
    }
    public MyArrayList(Collection c){
        //等价于先创建空的顺序表
        //this.addAll(c);
    }
    //确保容量至少够放入一个元素
    //时间复杂度：O(n)
    private void ensureCapacity(){
        if(size < array.length){    //至少还可以放入一个元素
            return;
        }
        //array = Arrays.copyOf(array,array.length * 2); //扩容的另一个方法，创建一个新的数组，把元素搬过去，空余部分用null填充
        //确定数组容量大小（使用原数组大小的两倍）
        int newCapacity = array.length * 2;
        Long[] newArray = new Long[newCapacity];    //创建一个新的数组
        //把所有元素从原数组搬到新数组
        for (int i = 0; i < size; i++) {
            newArray[i] = array[size];
        }
        //让array引用指向新数组
        array = newArray;
    }
    //尾插
    //时间复杂度：O(1)
    public boolean add(Long e){
        ensureCapacity();   //扩容

        array[size] = e;    //插入到最后面
        size++;             //尾插后元素个数增加
        return true;        //顺序表中不会出现插入失败
    }
    //向指定位置插入元素
    //时间复杂度：O(n)
    public void add(int index,Long e){
        //合法的下标
        if(index < 0 || index > size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        ensureCapacity();   //扩容
        for (int i = size-1; i >= index ; i--) {
            array[i + 1] = array[i];  //从后往前移动元素
        }
        array[index] = e;   //在指定位置放入元素
        size++;             //元素个数增加
    }
    //把index位置元素从线性表中删除并返回
    //时间复杂度：O(n)
    public Long remove(int index){
        //合法的下标
        Long e = array[index];
        if(index < 0 || index >= size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        for (int i = index + 1; i < size ; i++) {
            array[i - 1] = array[i];
            //System.arraycopy  不会产生新的对象
            //Arrays.copyOfRange 复制并产生一个新的对象
        }
        array[size - 1] = null; //移动后将原来的位置置空
        size--;
        return e;
    }
    //找到从前往后的第一个e删除
    //时间复杂度：O(n)
    public boolean remove(Long e){
        for (int i = 0; i < size; i++) {
            //array[i]是Long类型，e也是类型
            //引用 == 比较：同一性（即两个的是不是同一个）
            if(array[i].equals(e)){
                //array[i].equals(e)是解引用操作
                // 解引用合法的前提：引用得指向某个对象 r != null
                remove(i);  //删除相等的第一个元素
                return true;//找到了e并成功删除
            }
        }
        return false;
    }
    //获取index位置的元素并返回
    //时间复杂度：O(1)
    public Long get(int index){
        //合法的下标
        if(index < 0 || index > size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        return array[index];
    }
    //设置index位置的元素为e并返回原来的元素
    //时间复杂度：O(1)
    public Long set(int index,Long e){
        //合法的下标
        if(index < 0 || index > size){
            throw new ArrayIndexOutOfBoundsException(index);    //抛出异常：index不合法
        }
        Long m = array[index];  //将原来index位置的元素保存起来
        array[index] = e;       //将index位置的元素设置为e
        return m;               //返回原来index位置的元素
    }
    //清空线性表
    //时间复杂度：O(n)
    public void clear(){
        for (int i = 0; i < size; i++) {
            array[i] = null;
        }
        size = 0;
    }
    //返回第一个e所在下标
    //时间复杂度：O(n)
    public int indexOf(Long e){
        for (int i = 0; i < size; i++) {
            if(array[i].equals(e)){
                return i;
            }
        }
        return -1;
    }
    //返回最后一个e所在下标
    //时间复杂度：O(n)
    public int lastIndexOf(Long e){
        for (int i = size - 1; i >= 0; i++) {
            if(array[i].equals(e)){
                return i;
            }
        }
        return -1;
    }
    //判断线性表中是否包含元素e
    public boolean contains(Long e){
        return indexOf(e) != -1;
    }
    //线性表中的元素个数
    public int size(){
        return size;
    }
    //判断线性表中元素个数是否为空
    public boolean ieEmpty(){
        return size == 0;
    }

    //测试部分
    //检查语法情况
    public void whetherlegal(){
        if(size < 0){
            throw new RuntimeException("size 小于 0 了");
        }
        if(array == null){
            throw new RuntimeException("array 是 null 了");
        }
        if(size > array.length){
            throw new RuntimeException("size 大于 capacity 了");
        }
        for (int i = 0; i < size; i++) {
            if(array[i] == null){
                throw new RuntimeException("array[0,size) 出现了 null 了，i = "+i);
            }
        }
        for (int i = size; i < array.length; i++) {
            if(array[i] != null){
                throw new RuntimeException("array[size,array.length) 出现了 !null 了，i = "+i);
            }
        }
    }
    //检查元素清况
    public void Elements(long[] exceptElements){
        if(size != exceptElements.length){
            throw new RuntimeException("当前 size 不符合预期 size，size = " + size);
        }
        for (int i = 0; i < size; i++) {
            if(array[i] != exceptElements[i]){
                //array是Long类型，exceptElements是long类型，编译器会自动拆箱
                throw new RuntimeException("元素和预期的元素不符，i = " + i);
            }
        }
    }

    public static void main(String[] args) {
        //创建了顺序表，容量=100，size=0
        MyArrayList list = new MyArrayList(100);
        Long e = list.get(5);
        //获取下标为5的元素
        //下标的合法性只和元素个数有关.与容量无关
        //[0,0)
        System.out.println(e);
//        MyArrayList list = new MyArrayList();
//        list.whetherlegal();
//        list.Elements(new long[0]); //期待一开始的元素个数是0个
//        System.out.println(list.ieEmpty());//true
//
//        list.add(100L);
//        list.whetherlegal();
//        list.Elements(new long[] { 100 });
//        System.out.println(list.ieEmpty());//false
//
//        list.add(200L);
//        list.whetherlegal();
//        list.Elements(new long[] { 100,200 });
//
//        list.add(0,50L);
//        list.whetherlegal();
//        list.Elements(new long[] { 50,100,200 });
//
//        list.add(list.size(),300L);
//        list.whetherlegal();
//        list.Elements(new long[] { 50,100,200,300 });
//
//        long e = list.remove(0);
//        list.whetherlegal();
//        list.Elements(new long[] { 100,200,300 });
//        System.out.println(e);
//
//        list.clear();
//        list.whetherlegal();
//        list.Elements(new long[0]);

    }
}

完结~~~

小鱼的学习笔记

关注

5
点赞
踩
5

收藏

觉得还不错? 一键收藏
4
评论
数据结构-线性表（顺序表的实现）

顺序表是一种线性表，元素严格按照逻辑的前后顺序在内存中排列（类似于数组）；需要两个属性来管理顺序表：array（保存元素的数组）、size（保存元素个数）。线性表中的所有元素，除了第一个元素和最后一个元素之外，其余的每个元素都有唯一的前置元素和唯一的后继元素。最终在实现线性表时，有顺序表（ArrayList）和链表（LinkedList）两种方式。
复制链接

扫一扫