深入学习链表实现原理

最新推荐文章于 2023-02-14 13:57:49 发布
最新推荐文章于 2023-02-14 13:57:49 发布
阅读量870 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40205116/article/details/111036162

文章目录

链表

链表是一种线性结构，结构如下下图所示
在这里插入图片描述
链表的每个结点分为两部分，结点的元素值data以及结点的指针，指向下一个结点，从而实现相互关联。

上图为单链表，只向一个方向遍历，所有操作中间结点效率比较低。链表为是链式存储，所以长度没有限制，不会浪费空间。

链表实现

通过上面对链表的了解，下面我们来看看链表一些基本方法的实现。

结点类

链表是由多个结点组成的，结点中包含了元素值和结点的指针，这里先定义一个声明结点的类。代码如下

public class Node{
    public Object data; //链表数据
    public Node next;   //链表指针，指向下一个结点

    public Node() {
    }

    public Node(Object data) {
        this.data = data;
    }

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }
}

结点类中包含了两个属性，元素值和结点指针；以及构造方法。

属性及构造方法

在编写方法之前需要先声明两个属性，链表的头指针和结点的数量；以及构造方法，代码如下

//定义链表的头指针
public Node head;

//结点数量
public Integer size;

//构造函数
public LinkList() {
    this.head = null;
    this.size = 0;
}

getSize()方法

getSize()方法返回结点数量，在属性中定义了一个结点数量的属性size，所以这里直接返回size属性即可。

public Integer getSize(){
   	return size;
}

isEmpty()方法

isEmpty()方法判断链表是否为空，如果size结点的数量等于0即链表为空。

public Boolean isEmpty(){
    return size == 0;
}

traverse()方法

traverse()方法遍历链表中的所有结点数据。利用while循环依次遍历，直到结点为空结束。

代码实现

//遍历结点
public void traverse(){
    //创建一个临时结点，赋值为链表头
    Node temp = head;
    //遍历链表
    while(temp != null){
        System.out.println("编程小马：" + temp.data);
        //指向下一个结点
        temp = temp.next;
    }
}

add(Object data)方法

add()方法添加结点在链表头。定义属性时定义了链表头属性，所以在链表头添加结点效率很高，也很简单，只需要将新结点的指针指向原链表头结点即可。示意图如下
在这里插入图片描述
将新结点的指针指向原链表头结点，新结点变为链表头。

代码实现

/**
 * 添加结点，在链表头
 * @param data 添加结点的元素值
 * @return Boolean
 */
public Boolean add(Object data){
    try{
        //实例一个新结点，添加的结点
        Node newNode = new Node(data);
        //新结点的指针指向原链表头结点
        newNode.next = head;
        //改变头结点
        head = newNode;
        //结点数量自增
        size++;
        return true;
    }catch (Exception e){
        return false;
    }
}

注意：因为在链表头添加结点，所以先添加的结点在链表的后面。

add()方法测试
在这里插入图片描述

addLast(Object data)方法

addLast(Object data)方法在链表的末尾添加结点，在链表的末尾添加结点，要先找到最后一个结点，需要访问整个链表，所以效率比较低。找到最后一个结点，把最后一个结点的指针指向新结点即可。示意图如下
在这里插入图片描述
代码实现

/**
 * 添加结点，添加在链表尾
 * @param data 添加的元素值
 * @return  返回Boolean
 */
public Boolean addLast(Object data){
    try {
        //实例一个新结点，添加的结点
        Node newNode = new Node(data);
        //创建一个临时结点，赋值为链表头
        Node temp = head;
        //如果链表为空，则把新结点插入到链表头
        if(size == 0){
            head = newNode;
        }else{
            //如果链表不为空，则找到链表尾结点
            while(temp.next != null){
                //获取下一个结点
                temp = temp.next;
            }
            //将尾结点指针指向新结点，添加结点
            temp.next = newNode;
        }
        //结点数量自增
        size++;
        return true;
    }catch (Exception e){
        return false;
    }
}

在链表尾添加结点可以分为以下几步

  • 实例一个新结点
  • 创建一个临时结点，赋值为链表头
  • 判断链表是否为空，如果链表为空，则把新结点插入到链表头；如果链表不为空，则找到链表尾结点，将尾结点指针指向新结点，添加结点
  • 结点数量自增

addLast()方法测试
在这里插入图片描述
可以看出addLast()方法和add()方法插入的数据顺序是相反方向的，一个从链表头插入一个从链表尾插入。

insertNode(int index, Object data)方法

insertNode(int index, Object data)方法在指定位置插入结点。在指定位置插入结点，需要先判断位置参数是否合法；如果指定的位置为第一个结点位置，则直接将新结点的指针指向链表头，新结点作为新的链表头即可；如果指定的位置不为第一个结点位置，则先找到插入位置的前一个结点，在进行插入操作。示意图如下
在这里插入图片描述
代码实现

/**
 * 在指定位置插入结点
 * @param index 插入的位置
 * @param data  //插入的元素值
 * @return  返回Boolean
 */
public Boolean insertNode(int index, Object data){
    try{
        //判断位置是否合法
        if(index < 1 || index > size){
            System.out.println("插入位置不合法！");
            return false;
        }
        //创建一个临时结点，赋值为链表头
        Node temp = head;
        //实例一个新结点，添加的结点
        Node newNode = new Node(data);

        //如果插入的位置是在第一个结点位置
        if (index == 1){
            //新结点的指针指向原链表头结点
            newNode.next = head;
            //改变头结点
            head = newNode;
        }else {
            for (int i = 1; i < size; i++) {
                //找到插入位置的前一个结点
                if (i == index - 1) {
                    //temp为插入位置的前一个结点
                    //新结点的指针指向插入位置的结点
                    newNode.next = temp.next;
                    //插入位置的前一个结点指针指向新结点
                    temp.next = newNode;
                    break;
                }
                //指向下一个结点
                temp = temp.next;
            }
        }
        size++;
        return true;
    }catch (Exception e){
        return false;
    }
}

在链表指定位置插入结点可以分为以下几步

  • 判断位置是否合法
  • 创建一个临时结点，赋值为链表头
  • 实例一个新结点，添加的结点
  • 判断插入的位置是否是第一个结点位置，如果插入的位置是在第一个结点位置，则直接将新结点的指针指向链表头，新结点作为新的链表头即可；如果插入的位置不是第一个结点位置，则找到插入位置的前一个结点，新结点的指针指向插入位置的结点、插入位置的前一个结点指针指向新结点。
  • 结点数量自增

insertNode()方法测试
在这里插入图片描述

deleteNode(Integer index)方法

deleteNode(Integer index)方法删除index位置的结点，deleteNode(Integer index)方法和insertNode(int index, Object data)方法很相似，删除方法示意图如下
在这里插入图片描述
如上图所示，删除结点只需要改变删除结点的前结点指针指向删除结点的后一个指针即可。

代码实现

/**
 * 删除指定位置的结点
 * @param index 删除的结点位置索引
 * @return  Boolean
 */
public Boolean deleteNode(Integer index){
    try{
        //判断位置是否合法
        if(index < 1 || index > size){
            System.out.println("插入位置不合法！");
            return false;
        }
        //创建一个临时结点，赋值为链表头
        Node temp = head;
        //判断删除的是否为第一个结点
        if(index == 1){
            //将头结点的下一个结点作为新的头结点
            Node newHead = head.next;
            //改变头结点
            head = newHead;
        }else{
            for(int i = 1; i < size; i++){
                //找到删除结点位置的前一个结点
                if(i == index - 1){
                    //temp为删除位置的前一个结点
                    //保存将要删除的结点
                    Node delNode = temp.next;
                    //将删除结点的前一个结点指针指向删除结点的下一个结点
                    temp.next = delNode.next;
                    //将删除结点置为空
                    delNode = null;
                    break;
                }
                temp = temp.next;
            }
        }
        size--;
        return true;
    }catch (Exception e){
        return false;
    }
}

删除指定位置的结点可分为以下几步

  • 判断位置是否合法
  • 创建一个临时结点，赋值为链表头
  • 判断删除的是否为第一个结点，如果删除的是第一个结点，则将头结点的下一个结点作为新的头结点；如果删除的不是第一个结点，则找到删除结点位置的前一个结点，将删除结点的前一个结点指针指向删除结点的下一个结点
  • 结点数量自减

deleteNode()方法测试
在这里插入图片描述

findNode(Integer index)方法

findNode(Integer index)方法查找链表中指定位置的结点对象，并返回。findNode相对来说，比前几个方法要简单一点。先判断位置是否合法，循环找到index位置的结点即可。

代码实现

/**
 * 查找链表中指定位置的结点，并返回
 * @param index 指定位置
 * @return  该位置的结点对象
 */
public Node findNode(Integer index){
    try{
        //判断位置是否合法
        if(index < 1 || index > size){
            System.out.println("插入位置不合法！");
            return null;
        }
        //创建一个临时结点，赋值为链表头
        Node temp = head;

        for(int i = 1; i <= size; i++){
            //temp即当前位置的结点，找到index位置即返回该结点
            if(index == i){
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }catch (Exception e){
        return null;
    }
}

findNode()方法测试
在这里插入图片描述

updateNode(Integer index, Object data)

updateNode(Integer index, Object data)方法修改指定位置结点的元素值，利用上面的findNode(index)方法找到指定位置的结点对象，修改此对象的元素值即可。

代码实现

/**
 * 修改指定位置结点的元素值
 * @param index 指定位置
 * @param data  修改的元素值
 * @return  Boolean
 */
public Boolean updateNode(Integer index, Object data){
    try{
        //根据findNode(Integer index)方法查找到index位置的结点
        Node node = findNode(index);
        //修改元素值
        node.data = data;
        return true;
    }catch (Exception e){
        return false;
    }
}

updateNode()方法测试
在这里插入图片描述

完整代码

以上就是单链表的一些常用方法。写的比较零散，下面是上述案例完整代码。有错误地方欢迎指出。

public class LinkList {
    //定义一个内部类，作为链表的结点
    public class Node{
        public Object data; //链表数据
        public Node next;   //链表指针，指向下一个结点

        public Node() {
        }

        public Node(Object data) {
            this.data = data;
        }

        public Node(Object data, Node next) {
            this.data = data;
            this.next = next;
        }
    }

    //定义链表的头指针
    public Node head;

    //结点数量
    public Integer size;

    //构造函数
    public LinkList() {
        this.head = null;
        this.size = 0;
    }

    //返回结点的数量
    public Integer getSize(){
        return size;
    }

    //链表是否为空
    public Boolean isEmpty(){
        return size == 0;
    }

    /**
     * 添加结点，添加在链表尾
     * @param data 添加的元素值
     * @return  返回Boolean
     */
    public Boolean addLast(Object data){
        try {
            //实例一个新结点，添加的结点
            Node newNode = new Node(data);
            //创建一个临时结点，赋值为链表头
            Node temp = head;
            //如果链表为空，则把新结点插入到链表头
            if(size == 0){
                head = newNode;
            }else{
                //如果链表不为空，则找到链表尾结点
                while(temp.next != null){
                    //获取下一个结点
                    temp = temp.next;
                }
                //将尾结点指针指向新结点，添加结点
                temp.next = newNode;
            }
            //结点数量自增
            size++;
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /**
     * 添加结点，在链表头
     * @param data 添加结点的元素值
     * @return Boolean
     */
    public Boolean add(Object data){
        try{
            //实例一个新结点，添加的结点
            Node newNode = new Node(data);
            //新结点的指针指向原链表头结点
            newNode.next = head;
            //改变头结点
            head = newNode;
            //结点数量自增
            size++;
            return true;
        }catch (Exception e){
            return false;
        }
    }

    //遍历结点
    public void traverse(){
        //创建一个临时结点，赋值为链表头
        Node temp = head;
        //遍历链表
        while(temp != null){
            System.out.println("编程小马：" + temp.data);
            //指向下一个结点
            temp = temp.next;
        }
    }

    /**
     * 在指定位置插入结点
     * @param index 插入的位置
     * @param data  //插入的元素值
     * @return  返回Boolean
     */
    public Boolean insertNode(int index, Object data){
        try{
            //判断位置是否合法
            if(index < 1 || index > size){
                System.out.println("插入位置不合法！");
                return false;
            }
            //创建一个临时结点，赋值为链表头
            Node temp = head;
            //实例一个新结点，添加的结点
            Node newNode = new Node(data);

            //如果插入的位置是在第一个结点位置
            if (index == 1){
                //新结点的指针指向原链表头结点
                newNode.next = head;
                //改变头结点
                head = newNode;
            }else {
                for (int i = 1; i < size; i++) {
                    //找到插入位置的前一个结点
                    if (i == index - 1) {
                        //temp为插入位置的前一个结点
                        //新结点的指针指向插入位置的结点
                        newNode.next = temp.next;
                        //插入位置的前一个结点指针指向新结点
                        temp.next = newNode;
                        break;
                    }
                    //指向下一个结点
                    temp = temp.next;
                }
            }
            size++;
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /**
     * 删除指定位置的结点
     * @param index 删除的结点位置索引
     * @return  Boolean
     */
    public Boolean deleteNode(Integer index){
        try{
            //判断位置是否合法
            if(index < 1 || index > size){
                System.out.println("插入位置不合法！");
                return false;
            }
            //创建一个临时结点，赋值为链表头
            Node temp = head;
            //判断删除的是否为第一个结点
            if(index == 1){
                //将头结点的下一个结点作为新的头结点
                Node newHead = head.next;
                //改变头结点
                head = newHead;
            }else{
                for(int i = 1; i < size; i++){
                    //找到删除结点位置的前一个结点
                    if(i == index - 1){
                        //temp为删除位置的前一个结点
                        //保存将要删除的结点
                        Node delNode = temp.next;
                        //将删除结点的前一个结点指针指向删除结点的下一个结点
                        temp.next = delNode.next;
                        //将删除结点置为空
                        delNode = null;
                        break;
                    }
                    temp = temp.next;
                }
            }
            size--;
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /**
     * 查找链表中指定位置的结点，并返回
     * @param index 指定位置
     * @return  该位置的结点对象
     */
    public Node findNode(Integer index){
        try{
            //判断位置是否合法
            if(index < 1 || index > size){
                System.out.println("插入位置不合法！");
                return null;
            }
            //创建一个临时结点，赋值为链表头
            Node temp = head;

            for(int i = 1; i <= size; i++){
                //temp即当前位置的结点，找到index位置即返回该结点
                if(index == i){
                    return temp;
                }
                temp = temp.next;
            }
            return null;
        }catch (Exception e){
            return null;
        }
    }

    /**
     * 修改指定位置结点的元素值
     * @param index 指定位置
     * @param data  修改的元素值
     * @return  Boolean
     */
    public Boolean updateNode(Integer index, Object data){
        try{
            //根据findNode(Integer index)方法查找到index位置的结点
            Node node = findNode(index);
            //修改元素值
            node.data = data;
            return true;
        }catch (Exception e){
            return false;
        }
    }

    public static void main(String[] args) {
        //实例一个链表
        LinkList linkList = new LinkList();
        //向链表中添加元素
        linkList.addLast(1);
        linkList.addLast(2);
        System.out.println("插入前的链表");
        //遍历链表
        linkList.traverse();

        Node node = linkList.findNode(2);
        System.out.println("修改前链表中第2个结点的元素为：" + node.data);
        linkList.updateNode(2, 10);
        node = linkList.findNode(2);
        System.out.println("修改后链表中第2个结点的元素为：" + node.data);

        System.out.println();
        System.out.println("插入后的链表");
        //插入结点
        linkList.insertNode(1, 4);
        linkList.insertNode(3, 5);
        linkList.traverse();

        System.out.println();
        System.out.println("删除后的链表");
        linkList.deleteNode(1);
        linkList.traverse();

        System.out.println();
        node = linkList.findNode(2);
        System.out.println("链表中第2个结点的元素为：" + node.data);

        System.out.println();
    }
}
链表原理
mark_0518的专栏
06-17 1273
1 链式存储概念 (1)顺序存储： 我们所学的数组是一种连续的顺序存储方式，知道了数组某一个元素的地址，由于连续，则可以通过地址的计算能够算出每一个元素的地址。 (2)链式存储: 该方式是每个单元的存储位置是不连续的，随机的，但是可以通过在前一个存储单元中记录下一个存储单元的地址来把所有的存储单元联系起来，就像生活中的链条一样一环套一环,每个存储单元我们叫做节点。 每个节点可以分为两部分
链表实现原理与头尾插入
qq_40334837的博客
07-13 1094
一、链表原理 （1）链表的组成         链表是由若干个节点组成的（链表的各个节点结构是完全类似的），节点是由有效数据和指针组成的。有效数据区域用来存储信息完成任务的，指针区域用于指向链表的下一个节点从而构成链表。 （2）链表的作用         时刻谨记：链表就是用来解决数组的大小不能动态扩展的问题，所以链表其实就是当数组用的。直白点：链表能完成的任务用数组也能完成，数组能完成的...
数据结构中链表结构原理及其算法实现
一笑的博客
04-05 2579
C语言数据结构中常见的一些基础的链表操作，原来这么简单！
链表（快速懂原理）
Whynotwu的博客
03-04 2117
什么是链表？ 链表是通过指针将一组零散的内存块串联在一起。其中，我们把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址。 链表与数组的区别 数组需要一块连续的内存空间来存储，对内存的要求比较高。如果我们申请一个 100MB 大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB，仍然会申请失败。而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用，所以如果我
链表基本原理
m0_46926492的博客
02-14 794
【代码】链表基本原理。
数据结构实验报告-利用链表实现简易学生信息管理系统(C语言)
04-07
本次实验旨在加深学生对链表工作原理的理解。 2. **掌握链表的操作方法**：包括链表的初始化、插入、删除、查找等基本操作，以及如何统计链表中元素的数量。 3. **实践C语言编程技能**：通过实际编写代码来增强学生...
JAVA栈（链表实现）
最新发布
11-28
在Java集合框架中，虽然已经提供了诸如Stack类和Deque接口等现成的栈实现，但理解如何从头实现一个栈对于深入学习数据结构和算法是非常有价值的。它不仅可以帮助开发者更好地理解这些集合类的工作原理，还能在实际...
C++版本从头到尾或者从尾到头打印链表原理及代码实现
07-02
本篇文章将详细介绍如何使用C++来实现从头到尾以及从尾到头打印单向链表的方法，并深入探讨其背后的原理。 #### 二、链表基础知识回顾 在深入了解本文主题之前，我们需要先回顾一下链表的基本概念和特性： 1. **...
c++链表实现以及简易学生管理系统例子
01-27
在C++编程中，链表是一种非常重要的...通过学习这个例子，开发者能够深入理解链表的工作原理，以及如何在实际项目中利用链表进行数据管理。这将有助于提升C++编程技能，特别是处理动态数据集时的数据结构选择和操作。
单向链表实现
04-08
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表不连续存储元素，而是通过节点之间的指针连接...通过深入学习和实践，可以灵活运用链表解决实际问题，提高程序的效率和灵活性。
用C实现链表原理
02-18
链表是C里面一个比较重要的应用，此代码就是用链表来实现的
【数据结构】数组和链表
a15919528001的博客
09-06 210
目录 数组 单向链表 单链表删除节点 单链表添加节点 双向链表 双链表删除节点 双链表添加节点 简单总结 线性表是一种线性结构，它是具有相同类型的n(n≥0...
链表的实现（原理篇）
难波儿万的博客
04-26 2830
1.概述 第一次接触链表的时候是大学的数据结构课上，当时设计的链表就是针对某种数据结构的链表。后来学习了C++，由于C++支持泛型编程所以链表可以被设计成可以应用在任意的数据类型中。但是，如何能将C语言的链表应用在任意数据类型的应用场景下是一直困扰我的问题。直到我接触了Linux的内核链表，它的设计思想直接惊艳到了我。 下面我们先从使用者的角度去试着理解其内部设计的精妙之处。 2.既然链表不能包含所有数据类型那就让所有数据类型都可以包含链表 标题既是Linux内核设计链表的核心思想，Linux内核链表是一
链表的基本原理和基本接口实现
extern_valuable的博客
06-14 237
链表总结复习 1.链表的基本概念 1.1 链表和数组的区别 链表和数组同为线性存储结构，在逻辑上并无本质上的不同，因为在逻辑上存储的数据是连续的，但是数组存储数据在逻辑和物理两个层面上都是连续的，链表在物理上并不连续。 链表由于在物理上不连续，所以链式存储结构只能从头指针开始顺序存取，数组由于物理上的连续性，所以可以实现数据的随机存取。 数组的缺点是在插入和删除元素的时候，需要大量的数据搬运工作，所以不适合用来作为频繁增删的数据结构。 1.2 链表和数组各自的优缺点 配图如下： 两种结构都有自己各自的
链表----链表原理
Loving you
12-18 622
链表原理
链表原理及实现理解
xul999的博客
11-05 800
链表 链表是有序的列表。 链表是以节点的方式来存储，链式存储 每个节点包含data域，next域，指向下一个节点 链表的各个节点不一定是连续的存储 链表分带头节点的节点和没有带头结点的链表 应用实例代码实现（108好汉，无序、有序） /** * */ package com.stone.dataStructures; /** * @author Final * */ public class singleLinkedList { /** * @param args */ pu
链表的实现原理
Ant
04-03 2952
首先我们要建立一个数据结构来存放链表的节点，可以通过结构体来实现 typedef struct node { unsigned long int data; struct node* next; }node_t; 一、创建一个节点 第一步，实现定义一个临时变量，并将其初始化 第二步，判断其头结点是否为空节点，如果是空节点，则将临时头指针指向临时变量 第...
单链表的原理及实现
llwsg_srsnh的博客
12-02 1758
版权声明：本文为博主原创文章，转载或其它用途请注明出处 https://blog.youkuaiyun.com/llwsg_srsnh/article/details/84727817                                                                                   单链表的原理及实现 在数据结构中，链表是通过线性结构链式存储...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值