数据结构与算法之单向链表

最新推荐文章于 2022-07-02 15:08:10 发布
原创 最新推荐文章于 2022-07-02 15:08:10 发布 · 441 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法

本文主要介绍单向链表，它是以节点形式存储，逻辑上连续但内存中不一定连续。详细阐述了带头节点单向链表的实现，包括添加、删除、修改、获取长度、查找倒数第k个结点、链表反转及遍历显示数据等功能，并给出了各操作的实现思路和完整示例代码。

前言

链表是一中有序的线性列表，链表与数组不同的是，数组是一种连续存储的线性结构，而链表是以节点的形式来存储的。
链表有分为好几类，分别是：

  1. 单向链表：一个节点指向下一个节点
  2. 双向链表：一个节点有两个指针域，分别指向前一个节点和后一个节点
  3. 环形链表：能通过任何一个节点找到其他所有的节点，将两种(双向/单向)链表的最后一个结点指向第一个结点从而实现循环

此处先讲解单向链表，单向链表每个节点都包含data域和next域，next域是用来指向下一个节点，如果next节点为空，则代表此节点为最后一个节点。链表的各个节点在内存种分布的时候不一定是连续存储的，只是逻辑结构上是连续的。
链表分为带头节点的链表和不带头节点的链表。

单向链表内存结构图：

单向链表逻辑结构图：

单向链表实现

下面我将使用代码来实现带头节点的单向链表,并实现以下功能：

  • 增加
  • 删除
  • 修改
  • 获取链表长度
  • 查找
  • 链表反转
  • 显示链表数据

添加

实现思路：

  1. 定义一个头节点，代表链表头部
  2. 定义一个临时变量，辅助遍历整个链表
  3. 遍历整个链表，直到找到最后一个节点
  4. 将最后一个节点的next指向新增的节点
public boolean add(T item){
    Node<T> newNode = new Node<>(item);

    Node<T> tempNode = head; // 将头节点赋值给临时节点
    while(tempNode.next != null){ // 遍历找到最后一个节点
        tempNode = tempNode.next;
    }

    tempNode.next = newNode; // 将最后一个节点的next指向新的节点
    return true;
}

删除

实现思路：

  1. 先判断链表是否为空，为空的条件就是：head.next = null;
  2. 遍历链表，找个需要删除的这个节点的前一个节点
  3. 将需要删除的这个节点的前一个节点的next指向需要删除的这个节点的下一个节点： tempNode.next = tempNode.next.next
  4. 被删除的这个节点将不会再被引用，垃圾回收机制会自动回收
public boolean remove(T item) {
    if (this.isEmpty()) {
        System.out.println("linkedList is empty");
        return false;
    }

    Node<T> tempNode = head; // 将头节点赋值给临时节点
    while (true) {
        if (tempNode.next == null) {
            System.out.println("node next is empty");
            break;
        }
        if (item.equals(tempNode.next.item)) {
            tempNode.next = tempNode.next.next;
            return true;
        }
        tempNode = tempNode.next;
    }
    System.out.println("not find node item");
    return false;
}

修改

实现思路：

  1. 遍历链表，找到需要修改的节点
  2. 将新的数据赋值给修改的节点
public boolean update(T sourceItem, T tragetItem) {
    if (this.isEmpty()) {
        System.out.println("linkedList is empty");
        return false;
    }

    Node<T> tempNode = head; // 将第一个节点赋值给临时节点
    while (true) {
        if (tempNode == null) {
            System.out.println("node is empty");
            break;
        }
        if (sourceItem.equals(tempNode.item)) {
            tempNode.item = tragetItem;
            return true;
        }
        tempNode = tempNode.next;
    }

    return false;
}

获取链表长度

实现思路：

  1. 遍历链表，每得到一个节点，size+1
public int size() {
    if (this.isEmpty()) {
        return 0;
    }

    int size = 0;
    Node<T> tempNode = head; // 将头节点赋值给临时节点
    while (tempNode.next != null) { // 遍历找到最后一个节点
        size++;
        tempNode = tempNode.next;
    }

    return size;
}

查找（查找单链表中的倒数第k个结点）

实现思路：

  1. 先做基础校验，链表为空、下标小于等于0、下标大于链表长度等都返回空
  2. 获取链表长度
  3. 遍历链表，总共遍历size - index次，就可以得到倒数第k个节点，比如说链表长度为5要获取倒数第一个节点，那么就是5-1 = 4，第四个节点就是倒数第1个节点
public Node<T> findLastIndexNode(int index){
    if(this.isEmpty()){
        return null;
    }

    int size = this.size(); // 获取链表长度
    if(index <= 0 || index > size){
        return null;
    }

    Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
    for (int i = 0; i < size - index; i++) {
        tempNode = tempNode.next;
    }

    return tempNode;
}

链表反转

实现思路：

链表反转有两种实现方式，一种是递归反转，一种是非递归反转，两种方式的操作顺序不太一样。

非递归反转：

非递归反转，是从链表头部第一个有效节点开始，依次遍历，替换当前节点的下一节点为前一个节点
反转示意图：

public Node<T> reverseLinkList() {
    // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
    if (this.isEmpty() || head.next.next == null) {
        return head;
    }

    Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
    Node<T> prev = null; // 临时变量前一个节点
    while (tempNode != null) {
        Node<T> next = tempNode.next; // 当前节点的下一个节点
        Node<T> currentNode = tempNode; // 当前遍历的节点
        // 将前一个节点赋值给当前节点的下一个节点(此处是进行节点反转)
        // 比如有a、b、c、d、e等5个几点，那第一个节点为a
        // 进行反转的话，a就成了最后一个节点，所以a的next = prev（当遍历第一个节点的时候，prev就等于null）
        // 遍历第二个节点b的时候，b的next就是prev，前一个节点为a，所以b就到了a的前面
        // 后面依次遍历
        currentNode.next = prev;
        // 将当前节点赋值给临时变量 -> 前一个节点
        prev = currentNode;
        tempNode = next; // 往后移动一个节点（a -> b）
    }
    return prev;
}

递归反转：
递归反转是从链表尾部节点开始

反转示意图：

public Node<T> recursionReverseLinkList() {
    // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
    if (this.isEmpty() || head.next.next == null) {
        return head;
    }
    return recursionReverse(head);
}

public Node<T> recursionReverse(Node<T> node){
    Node<T> prev = null;
    if (node == null || node.next == null) {
        return node;
    } else {
        // 递归找到最后一个节点
        prev = recursionReverse(node.next);
        // 设置当前节点的下一个下一个节点为前一个节点
        node.next.next = node;
        // 设置当前节点的下一个节点为null
        node.next = null;
    }
    return prev;
}

遍历显示链表数据

实现思路：

  1. 判断链表是否为空
  2. 定义一个临时变量，用于遍历的时候，节点向后移动
  3. 遍历整个链表，依次打印输出
public void showLinkedList(Node<T> node){
    if (node == null || node.next == null) {
        System.out.println("linkedList is empty");
        return;
    }

    Node<T> tempNode = node; // 将头节点赋值给临时节点
    while (true){
        System.out.println(tempNode); // 输出节点信息
        if(tempNode.next == null){ // 判断是不是最后一个节点
            break;
        }
        tempNode = tempNode.next; // 节点向后移动
    }
}

完整示例代码

public class SingleLinkedList<T> {

    private Node<T> head = new Node<>(); // 头节点

    /**
     * 判断链表是否为空
     *
     * @return
     */
    public boolean isEmpty(){
        return head == null || head.next == null;
    }

    /**
     * 添加节点到单向链表
     *
     * @param item
     * @return
     */
    public boolean add(T item){
        Node<T> newNode = new Node<>(item);

        Node<T> tempNode = head; // 将头节点赋值给临时节点
        while(tempNode.next != null){ // 遍历找到最后一个节点
            tempNode = tempNode.next;
        }

        tempNode.next = newNode; // 将最后一个节点的next指向新的节点
        return true;
    }

    /**
     * 修改节点数据
     *
     * @param sourceItem 节点原数据
     * @param tragetItem 节点新数据
     * @return
     */
    public boolean update(T sourceItem, T tragetItem) {
        if (this.isEmpty()) {
            System.out.println("linkedList is empty");
            return false;
        }

        Node<T> tempNode = head; // 将第一个节点赋值给临时节点
        while (true) {
            if (tempNode == null) {
                System.out.println("node is empty");
                break;
            }
            if (sourceItem.equals(tempNode.item)) {
                tempNode.item = tragetItem;
                return true;
            }
            tempNode = tempNode.next;
        }

        return false;
    }

    /**
     * 删除节点
     *
     * @param item 节点数据
     * @return
     */
    public boolean remove(T item) {
        if (this.isEmpty()) {
            System.out.println("linkedList is empty");
            return false;
        }

        Node<T> tempNode = head; // 将头节点赋值给临时节点
        while (true) {
            if (tempNode.next == null) {
                System.out.println("node next is empty");
                break;
            }
            if (item.equals(tempNode.next.item)) {
                tempNode.next = tempNode.next.next;
                return true;
            }
            tempNode = tempNode.next;
        }
        System.out.println("not find node item");
        return false;
    }

    /**
     * 获取队列长度
     *
     * @return
     */
    public int size() {
        if (this.isEmpty()) {
            return 0;
        }

        int size = 0;
        Node<T> tempNode = head; // 将头节点赋值给临时节点
        while (tempNode.next != null) { // 遍历找到最后一个节点
            size++;
            tempNode = tempNode.next;
        }

        return size;
    }

    /**
     * 查找（查找单链表中的倒数第k个结点）
     *
     * @param index
     * @return
     */
    public Node<T> findLastIndexNode(int index){
        if(this.isEmpty()){
            return null;
        }

        int size = this.size(); // 获取链表长度
        if(index <= 0 || index > size){
            return null;
        }

        Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
        for (int i = 0; i < size - index; i++) {
            tempNode = tempNode.next;
        }

        return tempNode;
    }

    /**
     * 非递归反转链表：从头部开始处理，依次替换位置
     *
     * @return
     */
    public Node<T> reverseLinkList() {
        // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
        if (this.isEmpty() || head.next.next == null) {
            return head;
        }

        Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
        Node<T> prev = null; // 临时变量前一个节点
        while (tempNode != null) {
            Node<T> next = tempNode.next; // 当前节点的下一个节点
            Node<T> currentNode = tempNode; // 当前遍历的节点
            // 将前一个节点赋值给当前节点的下一个节点(此处是进行节点反转)
            // 比如有a、b、c、d、e等5个几点，那第一个节点为a
            // 进行反转的话，a就成了最后一个节点，所以a的next = prev（当遍历第一个节点的时候，prev就等于null）
            // 遍历第二个节点b的时候，b的next就是prev，前一个节点为a，所以b就到了a的前面
            // 后面依次遍历
            currentNode.next = prev;
            // 将当前节点赋值给临时变量 -> 前一个节点
            prev = currentNode;
            tempNode = next; // 往后移动一个节点（a -> b）
        }
        return prev;
    }

    /**
     * 递归反转node节点：从尾部开始处理
     *
     * @return
     */
    public Node<T> recursionReverseLinkList() {
        // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
        if (this.isEmpty() || head.next.next == null) {
            return head;
        }
        return recursionReverse(head);
    }

    /**
     * 递归反转
     *
     * @param node
     * @return
     */
    public Node<T> recursionReverse(Node<T> node){
        Node<T> prev = null;
        if (node == null || node.next == null) {
            return node;
        } else {
            // 递归找到最后一个节点
            prev = recursionReverse(node.next);
            // 设置当前节点的下一个下一个节点为前一个节点
            node.next.next = node;
            // 设置当前节点的下一个节点为null
            node.next = null;
        }
        return prev;
    }

    /**
     * 显示链表数据
     *
     */
    public void showLinkedList(){
        if (this.isEmpty()) {
            System.out.println("linkedList is empty");
            return;
        }

        Node<T> tempNode = head; // 将头节点赋值给临时节点
        while (true){
            System.out.println(tempNode); // 输出节点信息
            if(tempNode.next == null){ // 判断是不是最后一个节点
                break;
            }
            tempNode = tempNode.next; // 节点向后移动
        }
    }

    /**
     * 根据指定节点显示链表数据
     *
     * @param node
     */
    public void showLinkedList(Node<T> node){
        if (node == null || node.next == null) {
            System.out.println("linkedList is empty");
            return;
        }

        Node<T> tempNode = node; // 将头节点赋值给临时节点
        while (true){
            System.out.println(tempNode); // 输出节点信息
            if(tempNode.next == null){ // 判断是不是最后一个节点
                break;
            }
            tempNode = tempNode.next; // 节点向后移动
        }
    }

    /**
     * 链表节点类
     *
     * @param <T>
     */
    private class Node<T>{
        private T item; // 节点数据
        private Node<T> next; // 下一个节点

        public Node(){
        }

        public Node(T item){
            this.item = item;
        }

        public Node(T item,Node<T> next){
            this.item = item;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node{" + "item=" + item + '}';
        }
    }
}

public class SingleLikedListTest {
    public static void main(String[] args) {

        SingleLinkedList singleLikedList = new SingleLinkedList<String>();
        singleLikedList.add("a");
        singleLikedList.add("b");
        singleLikedList.add("c");
        singleLikedList.add("d");
        singleLikedList.add("e");
        System.out.println("删除前：");
        singleLikedList.showLinkedList();

        singleLikedList.remove("b");
        System.out.println("删除d后：");
        singleLikedList.showLinkedList();

        singleLikedList.update("e","f");
        System.out.println("将e修改为f后：");
        singleLikedList.showLinkedList();

        System.out.println("链表节点个数：" + singleLikedList.size());

        System.out.println("查找链表种倒数第1个节点："+ singleLikedList.findLastIndexNode(1));

        System.out.println("非递归反转链表：");
//        singleLikedList.showLinkedList(singleLikedList.reverseLinkList());

        System.out.println("递归反转链表：");
        singleLikedList.showLinkedList(singleLikedList.recursionReverseLinkList());
    }
}
数据结构与算法 -- 链表
u012967763的专栏
08-21 716
一点一滴学算法，算法从入门到放弃
【数据结构与算法】---链表
weixin_67900732的博客
08-04 4164
今天小编带大家学习数据结构中的链表。
单向链表
Mj_yong的博客
08-05 374
单链表的创建、删除、逆置、奇偶数结点链表 1.链表的创建、逆序数据建立链表 （1）创建链表 以学生信息管理系统为例，利用scanf从输入中获取学生的信息，并将其组织成单向链表。链表节点结构定义如下： struct stud_node { int num; /*学号*/ char name[20]; /*姓名*/ int score; /*成绩*/ struct stud_node *n
《数据结构与算法》之链表
菜鸟的向往
05-14 373
最近因为在学习《数据机构与算法》，所以有一段时间没有更新博客了。现在通个写一篇关于链表的博客和一个demo来巩固一下最近的学习，把理论转换为“实战”。 链表结构五花八门，其中最常见的链表结构有单链表、双向链表和循环链表。顺便一提，如果在面试中涉及到到链表，面试官老喜欢问你一句：数组和链表的区别。只要我们理解掌握了什么是链表才能从结构、存储数据、插入、删除上的差异来回答。 在这篇文章先说一下单链表。 首先手写一个单链表 要写一个单链表就必须弄清楚它的数据结构，来一张图看下它长什么样子 清楚了它的数据结构
数据结构与算法-链表
wdfscsdn2015的博客
09-23 1014
在讲述链表之前让我们对数据结构进行一个简单的回顾：我们知道，数据结构指的是描述实际问题中各个数据项节点之间的前后逻辑结构关系，即要么是线性结构（即某一数据项的前继节点和后继节点有且只有一个）要么是非线性结构（即某一数据节点的前驱或者后继节点不止一个）。在确定了实际数据项的数据结构之后，我们要采用某种存储方式对其进行存储，常见的数据结构的存储方式有：顺序存储、链式存储、散列存储以及索引存储。每一种存...
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，单向链表是指链表中的每个节点 chỉ指向下一个节点的数据结构。今天，我们将...
数据结构与算法-单向链表结构设计学生信息管理系统设计.docx
最新发布
08-25
首先，文档提及的单向链表是一种常见的数据结构，用于存储数据元素序列。在学生信息管理系统中，每个链表节点包含学生的基本信息，如学号、姓名、年龄、电话和成绩等。节点之间通过指针链接，形成一个链式存储结构，...
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
数据结构与算法 python–第三节 链表之单向链表
01-20
文章目录3 链表3.1 单向链表单链表的操作单链表是否为空、长度、遍历操作头部添加元素 add()尾部添加元素append()指定位置添加元素insert(pos,item)删除节点remove(item)查找节点是否存在search（item）完整代码链表...
数据结构与算法—链表
weixin_49757069的博客
05-22 394
链表 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。 链表与数组的对比： 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。在数组中，我们可以直接访问任何元位置的任何元素，而要想访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。 class Node { constructor(element) { this.el
数据结构与算法——链表
LoveXming的博客
03-12 1741
数据结构与算法——链表
一步一步写算法（之单向链表）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
10-07 12万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一
数据结构与算法---链表
weixin_55938630的博客
07-02 230
数据结构与算法--单链表
＜数据结构＞单向链表
bit_zyx的博客
03-17 1860
目录 一、对比顺序表 二、概念 三、必备工作 3.1、创建单链表 3.2、动态申请节点 3.3、单链表打印 3.4、销毁单链表 四、增删查改 4.1、插入数据 头插 尾插 在pos位置后插入x 在pos位置前插入x 4.2、删除数据 头...
【数据结构】单向链表
ice's blog
12-30 382
单向链表
数据结构——单向链表
chenchen_fcj程序猿的博客
07-23 414
开始学习数据结构，虽然部分之前C都学过，还是总结一下。内容比较多 直接看例子 list.h  //头文件 #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; typedef struct _Node       //节点定义 {         int data;                   //数据域         struct N...
数据结构—单向链表
想要上进的coder的博客
10-25 1010
什么是链表？ 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 链表一共有8种，带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、无头单向循环链表、无头单向非循环链表、无头双向循环链表、无头双向非循环链表。 本篇讲解的是无头单向非循环链表 ..
数据结构-单向链表
wenronglili的专栏
11-11 794
数据结构-单向链表 前言：作为经常要使用的数据结构，单链和双链，c语言不像c++一样可以使用多态的特性，但我们又希望能够设计一组api，实现单链和双链的基本操作，可以用于任何数据结构，好比一条晾东西的铁链一样，每个环都有一个钩子，任何东西，只要能勾上哪个钩子，就可以晾在铁链上，这里需要用到"C语言基础（一）"里面提到的一个小技巧，通过结构体成员，计算offset。从而获得结构体的地址，从而可以访
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值