【数据结构】Java -- 顺序表(详解)

于 2024-07-21 23:31:42 发布
阅读量906 收藏 6
点赞数 25
分类专栏： 数据结构 文章标签： 数据结构 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75724363/article/details/140596122
版权

🎇🎉🎉🎉点进来你就是我的人了
博主主页：🙈🙈🙈戳一戳，欢迎大佬指点！
欢迎志同道合的朋友一起加油喔 💪💪💪
谢谢你这么帅气美丽还给我点赞！比个心**

目录

1. 什么是List

在集合框架中，List是一个接口，继承自Collection。
在这里插入图片描述

1.1 Collection

Collection 也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示：
在这里插入图片描述

1.2 Iterable

Iterable 也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，具体如下：
在这里插入图片描述
List的官方文档

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

1.3【面试题】

Collection中有那些方法？

2. List常见接口介绍

2.1 List

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 subList(int fromIndex, int toIndex)截取部分 list

3. List的使用

注意： List是个接口，并不能直接用来实例化。
如果要使用，必须去实例化List的实现类。在集合框架中， ArrayList 和 LinkedList 都实现了 List 接口。

4. 线性表(☆☆☆)

线性表 （linear list）是 n 个具有 相同特性 的数据元素的有限序列。

线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…

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

在这里插入图片描述

5. 顺序表

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

在这里插入图片描述

5.1 接口的实现

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 toRemove);
    // 获取顺序表长度
    int size();
    // 清空顺序表
    void clear();
    // 打印顺序表 ，注意 ：该方法并不是顺序表中的方法 ，为了方便看测试结果给出的
    void display();
    //判断 数组是否满了
    boolean isFull();
    // pos 位置合法 判断顺序表是否为空
    boolean isEmpty();
}

6. ArrayList简介

在集合框架中， ArrayList是一个普通的类，实现了List接口，具体框架图如下：

在这里插入图片描述

【说明】

  1. ArrayList是以泛型方式实现的，使用时必须要先实例化
  2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  5. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者 CopyOnWriteArrayList
  6. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

7. ArrayList使用

7.1 ArrayList的构造

方法解释
ArrayList()无参构造
ArrayList(Collection<? extends E> c)利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity)指定顺序表初始容量
public static void main(String[] args) {
// ArrayList创建 ，推荐写法 // 构造一个空的列表
    List<Integer> list1 = new ArrayList<>();
// 构造一个具有10个容量的列表
    List<Integer> list2 = new ArrayList<>(10);
    list2.add(1);
    list2.add(2);
    list2.add(3);
// list2.add("hello");  // 编译失败 ， List<Integer>已经限定了 ，list2中只能存储整形元素
// list3构造好之后 ，与list中的元素一致
    ArrayList<Integer> list3 = new ArrayList<>(list2);
// 避免省略类型 ，否则 ：任意类型的元素都可以存放 ，使用时将是一场灾难
    List list4 = new ArrayList();
    list4.add("111");
    list4.add(100);
}

7.2 ArrayList常见操作

ArrayList虽然提供的方法比较多，但是常用方法如下所示，需要用到其他方法时，可自行查看ArrayList的帮助文档。

方法解释
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 subList(int fromIndex, int toIndex)截取部分 list

代码示例：

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("JavaSE");
    list.add("JavaWeb");
    list.add("JavaEE");
    list.add("JVM");
    list.add("测试课程");
    System.out.println(list);
// 获取list中有效元素个数
    System.out.println(list.size());
// 获取和设置index位置上的元素 ，注意index必须介于[0, size)间
    System.out.println(list.get(1));
    list.set(1, "JavaWEB");
    System.out.println(list.get(1));
// 在list的index位置插入指定元素 ，index及后续的元素统一往后搬移一个位置
    list.add(1, "Java数据结构");
    System.out.println(list);
// 删除指定元素 ，找到了就删除 ，该元素之后的元素统一往前搬移一个位置
    list.remove("JVM");
    System.out.println(list);
// 删除list中index位置上的元素 ，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
    list.remove(list.size() - 1);
    System.out.println(list);
// 检测list中是否包含指定元素 ，包含返回true ，否则返回false
    if (list.contains("测试课程")) {
        list.add("测试课程");
    }
// 查找指定元素第一次出现的位置：indexOf从前往后找 ，lastIndexOf从后往前找
    list.add("JavaSE");
    System.out.println(list.indexOf("JavaSE"));
    System.out.println(list.lastIndexOf("JavaSE"));
// 使用list中[0, 4)之间的元素构成一个新的SubList返回,但是和ArrayList共用一个elementData数组
    List<String> ret = list.subList(0, 4);
    System.out.println(ret);
    list.clear();
    System.out.println(list.size());
}

7.3 ArrayList的遍历

ArrayList 可以使用三方方式遍历： for循环+下标、foreach、使用迭代器

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
// 使用下标+for遍历
    for (int i = 0; i < list.size(); i++) {
        System.out.print(list.get(i) + " ");
    }
    System.out.println();
// 借助foreach遍历
    for (Integer integer : list) {
        System.out.print(integer + " ");
    }
    System.out.println();
    Iterator<Integer> it = list.listIterator();
    while (it.hasNext()) {
        System.out.print(it.next() + " ");
    }
    System.out.println();
}

注意：

  1. ArrayList最长使用的遍历方式是： for循环+下标 以及 foreach
  2. 迭代器是设计模式的一种，后序容器接触多了再给大家铺垫

7.4 ArrayList的扩容机制

下面代码有缺陷吗？为什么？


public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        list.add(i);
    }
}

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容。以下是ArrayList源码中扩容方式：
源码理解：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

Object[] elementData;  // 存放元素的空间
private static fi nal
Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  // 默认空间 private static fi nalint DEFAULT_CAPACITY = 10;  // 默认容量大小

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!! elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

// overflow-conscious code
    if (minCapacity - elementData.length > 0) grow(minCapacity);
}

private static fi nalint
MAX_ARRAY_SIZE =Integer.MAX_VALUE -8;

private void grow(int minCapacity) {
// 获取旧空间大小
    int oldCapacity = elementData.length;
// 预计按照1.5倍方式扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果用户需要扩容大小 超过 原空间1.5倍 ，按照用户所需大小扩容
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
// 如果需要扩容大小超过MAX_ARRAY_SIZE ，重新计算容量大小
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
// 调用copyOf扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
// 如果minCapacity小于0 ，抛出OutOfMemoryError异常
    if (minCapacity < 0)
        throw new OutOfMemoryError();

    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

【总结】

  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小
    初步预估按照1.5倍大小扩容
    如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容 。
    真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  3. 使用copyOf进行扩容

8. 自己简单实现ArrayList

8.1 IList接口

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 toRemove);
    // 获取顺序表长度
    int size();
    // 清空顺序表
    void clear();
    // 打印顺序表 ，注意 ：该方法并不是顺序表中的方法 ，为了方便看测试结果给出的
    void display();
    boolean isFull();
    // pos 位置合法 但为空
    boolean isEmpty();
}

8.2 异常类

public class PosException extends RuntimeException{
    //运行时异常

    public PosException() {

    }

    public PosException(String message) {
        super(message);
    }
}


public class EmptyException extends RuntimeException{
    public EmptyException() {

    }

    public EmptyException(String message) {
        super(message);
    }
}

8.3 MyArrayList类

//对数组进行各式各样的操作

import java.util.Arrays;

public class MyArrayList implements IList {
    //首先，MyArrayList 底层操纵的是一个数组
    //需要定义一个  数组
    public int[] elem;
    // usedSize 相当于数组里面 有效元素的个数
    // 当数组里面增加元素或者减少元素的时候，usedSize 加或减
    public int usedSize;
    //默认的数组容量
    public static final int DEFAULT_CAPACITY = 5;

    public MyArrayList() {
        //在构造方法里面可以初始化 数组
        this.elem = new int[DEFAULT_CAPACITY];

    }
    //接下来可以对数组进行增删查改的操作
    // 可以把这些操作全部放在接口里面

    /*
    打印顺序表当中所有的元素
     */
    @Override
    public void display() {
        //可以通过 usedSize 来确定 数组里面元素的个数
        for (int i = 0; i < usedSize; i++) {
            System.out.print(elem[i] + " ");
        }
        System.out.println();
    }
    /**
     * 添加元素，默认添加到数组的最后位置
     *
     * @param data 元素
     */
    @Override
    public void add(int data) {
        //1.首先在 添加元素之前 要对数组里面的元素个数进行判断
        // 如果数组满了，要对数组进行扩容
        if (isFull()) {
            //满了
            //Arrays.copyOf 返回值还是一个 int 类型的数组
            // 相当于 对 elem 数组进行操作
            // 拷贝完成之后 让elem指向新的数组
            elem = Arrays.copyOf(elem, 2 * elem.length);
        }
        //usedSize 位置放元素
        elem[usedSize] = data;
        usedSize++;

    }

    // 判断数组是否满了
    @Override
    public boolean isFull() {
        // 如何判断呢？
        // 这时需要对 usedSize 进行判断
        return usedSize == elem.length;
    }




    /**
     * 给 pos 位置添加一个元素
     *
     * @param pos  //
     * @param data
     */
    @Override
    public void add(int pos, int data) {
        //1.首先还要进行 边界条件的判断
        //pos位置判断
        checkPosOfAdd(pos);
        //2.满的话
        if (isFull()) {
            elem = Arrays.copyOf(elem, 2 * elem.length);
        }
        // 2.比如向 下标为1的位置添加元素
        // 不可以先挪 原本 下标为 1 上的元素
        //需要从 最后一个 存储 数据元素 的位置向后挪
        //相当于  [i + 1] = [i]  i--
        for (int i = usedSize - 1; i >= pos; i--) {
            elem[i + 1] = elem[i];
        }
        elem[pos] = data;
        usedSize++;
    }

    //对 pos 位置进行判断
    private void checkPosOfAdd(int pos){
        if (pos < 0 || pos > usedSize){
            //说明pos位置不合法
            throw new PosException("pos位置为：" + pos);
        }
    }

    /**
     * 查找当前元素是否存在
     * @param toFind
     * @return
     */
    @Override
    public boolean contains(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

    /**
     * 找当前元素 下标
     * @param toFind
     * @return
     */
    @Override
    public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取 pos 位置的值
     * @param pos
     * @return
     */
    @Override
    public int get(int pos) {
        //1.pos不合法怎么办？
        checkPosOfGet(pos);
        //2.pos合法，为空怎么办？
        if (isEmpty()){
            //抛一个 空的异常
            throw new EmptyException("顺序表为空！！！");
            //也可以返回一个 -1
        }
        return elem[pos];
    }

    @Override
    public boolean isEmpty() {
        return usedSize == 0;
    }

    private void checkPosOfGet(int pos){
        if (pos < 0 || pos >= usedSize){
            //说明pos位置不合法
            throw new PosException("pos位置不合法：" + pos);
        }
    }


    /**
     * 更新 pos 位置的值
     * @param pos
     * @param value
     */
    @Override
    public void set(int pos, int value) {
        //首先 pos 要合法
        checkPosOfGet(pos);
        //其次判断是否为空
        if (isEmpty()){
            //抛一个 空的异常
            throw new EmptyException("顺序表为空！！！");
            //也可以返回一个 -1
        }
        elem[pos] = value;
    }

    /**
     * 删除 toRemove 这个数字
     * @param toRemove
     */
    @Override
    public void remove(int toRemove) {
        //首先 删除这个数字 要找到 这个数字的下标

        //如果为空 不能删
        if (isEmpty()){
            //抛一个 空的异常
            throw new EmptyException("顺序表为空！！！");
            //也可以返回一个 -1
        }
        int index = indexOf(toRemove);
        //这个时候需要 一个一个数向前覆盖
        for (int i = index; i < usedSize - 1; i++) {
            elem[i] = elem[i + 1];
        }
        usedSize--;
    }

    @Override
    public int size() {
        return this.usedSize;
    }
    
    /**
     * 清空顺序表 防止内存泄漏
     */
    @Override
    public void clear() {
        //如果数组里面放的是引用类型
        //说明每个 元素存的是 地址
        //现在里面放的是 int类型
        usedSize = 0;
    }
}

8.4 TestDemo类

import java.util.ArrayList;

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        myArrayList.add(4);
        myArrayList.add(5);
        myArrayList.add(6);

        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
    }
}

明志-
关注
  • 25
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法代码详解JAVA版
08-26
本资源"数据结构与算法代码详解JAVA版"聚焦于使用Java语言来理解和实现这些核心概念。 首先，数据结构是组织和存储数据的方式，它为高效地执行各种操作提供了便利。常见的数据结构包括数组、链表、栈、队列、树（如...
Java 集合与数据结构详解1
08-03
本文将深入探讨Java集合框架的核心概念、数据结构以及相关的算法。 首先，集合框架主要由两个核心部分组成：集合（Collection）和图（Map）。集合是用来存储单一元素的容器，而图则用于存储键值对映射关系。在...
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5554
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
java数据结构-链表详解
m0_63526467的博客
05-04 4058
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
《java数据结构》--顺序表详解
hyldzbg的博客
05-27 954
接下来开始添加，既然要指定位置添加数据那么原来的数据顺序肯定不能变而且被指定的位置肯定还要是可覆盖的，我们直接让那个位置以后的数据都向后移动一步就行，然后用要添加的数据直接覆盖掉那个位置就行。//这里改了list 3，结果list 1也跟着改了，是因为，sublist方法，并不是返回一个新的数组，而是返回原来数组的sublist的方法的第一个参数下标处的地址也就是返回1下标处的地址，还是在对同一个数组操作。到这里我们的顺序表就实现完了，但是Java中的顺序表还有很多方法有兴趣的小伙伴可以自己去实现一下。
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）
iiiiiihuang的博客
09-03 2486
前言：这篇博客我们重点讲线性表中的顺序表、链表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
数据结构--哈希表详解
5:00A.M的博客
04-02 2357
【哈希表】目录1. 什么是哈希表 ？2. 什么是 key ？3. 什么是哈希冲突 ？4. 怎样尽可能降低冲突率 ？5.如何处理哈希冲突 ？5.1 开放地址法 (闭散列)(1). 线性探测(2). 二次探测(3). 再哈希法5.2 链表法 (开散列、哈希桶)6. 哈希表主要方法实现get() 方法put() 方法growCapacity() 扩容方法remove() 方法size() 方法isEmpty() 方法总结 1. 什么是哈希表 ？ 哈希表 ：Hash table，也叫散列表，它是专门研究动态数据集查
3.5W 字详解 Java 数据结构.pdf
11-18
Java 数据结构是编程基础的重要组成部分，对于任何Java开发者来说，理解和掌握各种数据结构至关重要。本文主要探讨了Java集合框架中的核心概念，特别是`Iterable`和`Collection`接口，以及它们如何构成了Java数据...
Java数据结构：详解及使用场景.pdf
11-18
这些Java数据结构在实际编程中有着广泛的应用。例如： - 数组适用于存储固定大小且类型相同的元素集合，常用于基础计算和内存效率要求高的场景。 - 列表（如ArrayList和LinkedList）在需要动态调整大小和频繁增删...
Java 数据结构链表操作实现代码
09-01
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点间的引用关系连接。在Java中，我们可以使用对象来实现链表。链表分为单链表、循环链表和双向链表。 单链表是每个节点包含数据部分和指向下一...
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 279
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1020
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 254
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 698
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 215
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1075
如有错误，欢迎指出~
数据结构第32节 无锁编程
hummhumm的专栏
07-17 845
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
数据结构——栈
weixin_45942515的博客
07-19 241
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构之细说链表
m0_73634434的博客
07-17 1046
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值