集合及数据结构第四节————List与顺序表

莲雾flops2024-08-25 20:27

系列文章目录

集合及数据结构第四节------------List、ArrayList与顺序表

List、ArrayList与顺序表

  1. List的介绍
  2. 常见接口介绍
  3. .List的使用
  4. 什么是线性表
  5. 顺序表接口的定义
  6. MyArrayList类里面实现这些接口（）功能
  7. 顺序表的优缺点

文章目录

一、List的介绍

1.什么是List？

在集合框架中，List是一个接口，继承自Collection。

Collection也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示：

Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，具体如下：Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，具体如下：

站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删改查以及变量等操作

2.常见接口介绍

List中提供了好的方法，具体如下：

虽然方法比较多，但是常用方法如下：

方法 解释
boolean add(E e) 尾插 e
void add(int index, E element) 将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c) 尾插 c 中的元素
E remove(int index) 删除 index 位置元素
boolean remove(Object o) 删除遇到的第一个 o
E get(int index) 获取下标 index 位置元素
E set(int index, E element) 将下标 index 位置元素设置为 element
void clear() 清空
boolean contains(Object o) 判断 o 是否在线性表中
int indexOf(Object o) 返回第一个 o 所在下标
int lastIndexOf(Object o) 返回最后一个 o 的下标
List < E > subList(int fromIndex, int toIndex) 截取部分 list

3.List的使用（ * * ）

注意：List是个接口，并不能直接用来实例化。

如果要使用，必须去实例化List的实现类。在集合框架中，ArrayList和LinkedList都实现了List接口

二、线性表

1.什么是线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.顺序表

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

顺序表接口的定义

java 复制代码 
public interface Ilist {
    // 新增元素,默认在数组最后新增
    void add(int data);
    // 在 pos 位置新增元素
    void add(int pos, int data);
    // 判定是否包含某个元素
    boolean contains(int toFind);
    // 查找某个元素对应的位置
    int indexOf(int toFind);
    // 获取 pos 位置的元素
    int get(int pos);
    // 给 pos 位置的元素设为 value
    void set(int pos, int value);
    //删除第一次出现的关键字key
    void remove(int key);
    // 获取顺序表长度
    int size();
    // 清空顺序表
    void clear();
}

MyArrayList类里面实现这些接口（）功能

java 复制代码 
public class MyArrayList implements Ilist{

    @Override
    public void add(int data) {// 新增元素,默认在数组最后新增

    }

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

    }

    @Override
    public boolean contains(int toFind) {// 判定是否包含某个元素
        return false;
    }

    @Override
    public int indexOf(int toFind) {// 查找某个元素对应的位置
        return 0;
    }

    @Override
    public int get(int pos) {// 获取 pos 位置的元素
        return 0;
    }

    @Override
    public void set(int pos, int value) {// 给 pos 位置的元素设为 value

    }

    @Override
    public void remove(int key) {//删除第一次出现的关键字key

    }

    @Override
    public int size() {// 获取顺序表长度
        return 0;
    }

    @Override
    public void clear() {// 清空顺序表

    }
}
1.新增元素,默认在数组最后新增
  1. 判断顺序表有没有存满（新增一个private修饰的checkCapacity方法来判断）
java 复制代码 
private void checkCapacity(){//判断顺序表有没有存满，并且自动进行扩容
                                // (不是提供给用户的，只为当前这个类服务所以用private进行封装）
         if(usedsize >= elem.length){
             Arrays.copyOf(elem,elem.length * 2);//拷贝elem数组两倍长度到一个新建的顺序表中
             //然后让elem重新指向扩容后的顺序表
        }
    }
  1. 在数组最后新增元素

代码实现：

java 复制代码 
public void add(int data) { // 新增元素,默认在数组最后新增
        checkCapacity();
        this.elem[this.usedsize] = data;
        this.usedsize++;
    }
2. 在 pos 位置新增元素
  1. 在数据结构当中，每次存储数据的时候，必须有一个前驱信息。所以0 <= pos <= usedsize 才合法。（新增一个private修饰的checkPosOnAdd方法来判断）
java 复制代码 
public class PosLocationIllegality extends  RuntimeException{
    public PosLocationIllegality(String message){
        super(message);
    }
}
java 复制代码 
private void checkPosOnAdd(int pos) throws  PosLocationIllegality{//判断输入的pos位置是否合法，如果不合法就抛出一个异常。
        if(pos < 0 || pos > usedsize){
            throw new PosLocationIllegality("pos位置不合法" + pos );
        }
    }

  1. 检查顺序表有没有存满

  2. 开始新增元素

  • 从最后一个有效的数据开始往后移动（i >= pos 时）
  • 当i < pos 时就结束
  • 存放元素到 pos 位置
  • usedSize++；

代码实现：

java 复制代码 
public void add(int pos, int data) {// 在 pos 位置新增元素
        try {
            checkPosOnAdd(pos);//判断输入的pos位置是否合法，如果不合法就抛出一个异常。
        }catch (PosLocationIllegality e){
            e.printStackTrace();
            return;
        }

        checkCapacity();//判断数组有没有存满，并且自动进行扩容

        //1. 从最后一个有效的数据开始往后移动（i >= pos 时）
        //2.当i < pos 时就结束
        for (int i = usedsize - 1; i >= pos ; i--) {
            this.elem[i + 1] =this.elem[i];
        }
        //3. 存放元素到 pos 位置
        this.elem[pos] = data;

        //4. usedSize++；
        this.usedsize++;
    }
3. 判定是否包含某个元素
  1. 判断顺序表是否为空（新增一个isEmpty方法来判断）
  2. 遍历数组查找

代码实现：

java 复制代码 
public boolean isEmpty() {//判断数组是否为空
        return this.usedsize == 0;
    }
java 复制代码 
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;
    }
4. 查找某个元素对应的位置
  1. 判断数组是否为空（用isEmpty方法来判断）
  2. 遍历数组查找查找成功返回下标，失败则返回-1
    代码实现：
java 复制代码 
public int indexOf(int toFind) {// 查找某个元素对应的位置
        if(isEmpty()) {
            return -1;
        }
        for (int i = 0; i < this.usedsize; i++) {
            //如果是查找引用数据类型，一定要重写equals方法
            if (this.elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }
5. 获取 pos 位置的元素
  1. 在获取pos位置的元素时最后一个元素之后的坐标都不合法。所以0 <= pos <= usedsize 才合法。（新增一个private修饰的ccheckPosOnGet方法来判断）
  2. 判断顺序表是否为空。如果顺序表为空则抛出一个异常，否则返回pos下标的元素
java 复制代码 
  public int get(int pos) { // 获取 pos 位置的元素
       checkPosOnGet(pos);

       if (isEmpty()){//如果顺序表为空，抛出一个异常
          throw new MyArraylistEmpty("获取指定下标元素时顺序表为空");
       }
       return elem[pos];
    }
6. 获取 pos 位置的元素
  1. 在获取pos位置的元素时最后一个元素之后的坐标都不合法。所以0 <= pos <= usedsize 才合法。（新增一个private修饰的checkPosOnGetAndSet方法来判断）
  2. 将value赋值给下标为pos的elem数组

代码实现：

java 复制代码 
private void checkPosOnSet(int pos) throws  PosLocationIllegality{//判断输入的pos位置是否合法，如果不合法就抛出一个异常。
        if(pos < 0 || pos >= usedsize){
            throw new PosLocationIllegality("要设定的指定下标的元素的pos位置不合法" + pos );
        }
    }
java 复制代码 
public void set(int pos, int value) { // 给 pos 位置的元素设为 value
        checkPosOnSet(pos);//判断要设置的元素的pos位置是否合法，如果不合法就抛出一个异常。
        this.elem[pos] = value;
    }
7. 删除第一次出现的关键字key
  1. 找到要删除的数据，如果没有找到就抛出一个异常
java 复制代码 
public class ToRemoveWrong extends RuntimeException{
    public ToRemoveWrong(String message){
        super(message);
    }
}
  1. 挪动数据
  2. 修改usedSize
8. 获取顺序表长度
  1. 判断顺序表是否为空。
    代码实现：
java 复制代码 
public int size() {// 获取顺序表长度
        if (isEmpty()){//如果顺序表为空，抛出一个异常
            throw new MyArraylistEmpty("当前顺序表为空");
        }
        return this.usedsize;
    }
9. 清空顺序表

对于当前基本类型的数据来说，只需要将usedSize置为0。但是当顺序表中存放的是引用类型的数据时，就会产生内存泄漏（JVM只会在一个对象没有被引用时自动回收）。所以清空该引用类型顺序表的方法有下面几种：

  1. 直接将elem置为null（比较粗暴的方法）
  2. 写一个for循环将每一个有效数据置为null（推荐使用）
java 复制代码 
 public void clear() {
        this.usedSize=0;
    }

顺序表的优缺点

线性表的顺序存储结构，在存、读数据时，不管是哪个位置，时间复杂度都是O(1)；而插入或删除时，时间复杂度都是O(n)。这就说明，它比较适合元素个数不太变化，而更多是存取数据的应用。当然，它的优缺点还不只这些......

优点：

  1. 在给定下标要进行查找的时候，时间复杂度为O（1）

缺点：

  1. 插入数据必须移动其他数据。最坏的情况下就是插入到你位置时时间的复杂度为O（N）
  2. 删除数据必须移动其他数据。最坏的情况下就是删除0位置时时间的复杂度为O（N）
  3. 扩容之后有可能会浪费空间

顺序表比较适合进行下标查找的场景

相关推荐
sanzk4 分钟前
sql格式化工具
java·数据库·sql
IT研究室4 分钟前
计算机毕业设计选题推荐-校园车辆管理系统-Java/Python项目实战（亮点：数据可视化分析、账号锁定）
java·spring boot·python·django·毕业设计·源码·课程设计
Marchwho11 分钟前
面试—MySQL
java·数据库·mysql
Byyyi耀17 分钟前
Ascend C算子开发（中级）—— 编写Sinh算子
c语言·开发语言
转调19 分钟前
C语言-第九章：文件读写
c语言·开发语言
老马啸西风36 分钟前
cross-plateform 跨平台应用程序-05-Flutter 介绍
java
coffee_baby43 分钟前
桥接模式详解和分析JDBC中的应用
java·数据库·spring boot·java-ee·桥接模式
为为-180-3121-14551 小时前
基于R语言结构方程模型分析与实践技术应用
开发语言·r语言
孤独且没人爱的纸鹤1 小时前
C++类和对象（上）
c语言·开发语言·c++
神仙别闹1 小时前
基于Java+Mysql实现（WEB）宿舍管理系统
java·前端·mysql
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）022024年高教社杯数学建模国赛C题超详细解题思路分析03【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提04RAG 实践- Ollama+RagFlow 部署本地知识库05【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文062024 高教社杯 数学建模国赛 （A题）深度剖析|“板凳龙” 闹元宵|数学建模完整代码+建模过程全解全析07Coze扣子平台完整体验和实践（附国内和国际版对比）082024年高教杯国赛（C题）数学建模竞赛解题思路|完整代码论文集合092024 年高教社杯全国大学生数学建模竞赛题目-A 题 “板凳龙” 闹元宵10苍穹外卖面试总结