数据结构与算法-单链表（Linked List）

最新推荐文章于 2023-05-09 00:46:57 发布
最新推荐文章于 2023-05-09 00:46:57 发布
阅读量409 收藏
点赞数
分类专栏： 数据结构 java算法 文章标签： 数据结构 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/July_whj/article/details/108958930
版权

链表（Linked List）

1、链表介绍

链表是有序的列表，但是他在内存中的存储结构如下：
在这里插入图片描述

  • 链表是以节点的方式来存储的，是链式存储
  • 每个节点包含data域、next域:指向下一个节点
  • 链表的各个节点不一定是连续存储。
  • 链表分带头节点的链表和不带头节点的链表，根据实际情况来确定
    单链表（带头节点）逻辑结构示意图
    在这里插入图片描述

2、单链表应用

使用带头节点的单向链表实现-开发语言排行榜管理，完成对语言的增删改查操作。

2.1、定义链表结构

分析：

  • 使用带头节点的链表，我们需要定义头节点属性；
  • 链表包涵data域和next域，我们这里需要排序新增no排序属性、name语言名称属性
    我们定义如下Node结构：
/**
     * 单链表节点
     */
    public class LanguageNode {
        /**
         * 排序
         */
        private int no;
        /**
         * 语言名称
         */
        private String language;
        /**
         * 语言描述
         */
        private String languageDescribe;
        /**
         * 下个节点
         */
        private LanguageNode next;


        public LanguageNode(int no, String language, String languageDescribe, LanguageNode next) {
            this.no = no;
            this.language = language;
            this.languageDescribe = languageDescribe;
            this.next = next;
        }

        @Override
        public String toString() {
            return "LanguageNode{" +
                    "no=" + no +
                    ", language='" + language + '\'' +
                    ", languageDescribe='" + languageDescribe + '\'' +
                    '}';
        }

    }

2.2 新增节点

我们定义个SingleLinkedList链表管理器，在链表管理器中完成链表的增删改查操作。

下面我们实现链表的新增操作：

  • 第一种方式在添加语言时，直接添加在链表的尾部

思路分析示意图：
在这里插入图片描述

  • 第二种在添加语言时，根据排名将语言插入到相应的位置（如果有这个排名，则添加失败，并给出提示）

思路分析示意图
在这里插入图片描述

代码实现：

/**
     * 根据顺序添加节点
     *
     * @param node 添加数据
     * @return 当前节点
     */
    public LanguageNode addByOrder(LanguageNode node) {
        //因为头节点不能移动，定义临时变量tmp
        LanguageNode tmp = this.head;
        //定义链表添加标识符
        boolean flag = false;
        while (true) {
            if (tmp.next == null) {
                break;
            }
            if (tmp.next.no > node.no) {
                break;
            } else if (tmp.next.no == node.no) {
                //说明该顺序已经存在
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if (flag) {
            System.out.printf("插入的位置%d已存在，不能插入\n", node.no);
        } else {
            node.next = tmp.next;
            tmp.next = node;
        }
        return node;
    }

    /**
     * 添加节点
     *
     * @param node 添加数据
     * @return
     */
    public LanguageNode add(LanguageNode node) {
        //因为头节点不能移动，定义临时变量tmp
        LanguageNode tmp = this.head;
        //将数据添加到最后，便利链表
        while (tmp.next != null) {
            tmp = tmp.next;
        }
        tmp.next = node;
        return node;
    }

测试：

  • 首先使用add尾部添加
public static void main(String[] args) {
        SingleLinkedList linkedList = new SingleLinkedList();
        LanguageNode java = new LanguageNode(1, "java", "超级好用");
        LanguageNode python = new LanguageNode(2, "python", "python");
        LanguageNode goLang = new LanguageNode(3, "goLang", "goLang");
        LanguageNode js = new LanguageNode(4, "js", "js");
        LanguageNode php = new LanguageNode(5, "php", "php是世界上最好的语言");
        linkedList.add(python);
        linkedList.add(java);
        linkedList.add(js);
        linkedList.add(php);
        linkedList.add(goLang);
        linkedList.list();
}

执行结果如下：
在这里插入图片描述

从结果看出：打印的顺序和我们插入的顺序一致，没有按照no进行排序操作

  • 使用addByOrder测试
public static void main(String[] args) {
        SingleLinkedList linkedList = new SingleLinkedList();
        LanguageNode java = new LanguageNode(1, "java", "超级好用");
        LanguageNode python = new LanguageNode(2, "python", "python");
        LanguageNode goLang = new LanguageNode(3, "goLang", "goLang");
        LanguageNode js = new LanguageNode(4, "js", "js");
        LanguageNode php = new LanguageNode(5, "php", "php是世界上最好的语言");
        linkedList.addByOrder(python);
        linkedList.addByOrder(java);
        linkedList.addByOrder(js);
        linkedList.addByOrder(php);
        linkedList.addByOrder(goLang);
        linkedList.list();
}

执行结果如下：
在这里插入图片描述

从结果看出：打印的顺序和我们插入的顺序不致，按照no进行排序插入。

2.3 修改节点信息

思路：修改节点功能比较简单，通过遍历先找到该节点信息，在对该节点内容进行修改即可。
代码实现

public void update(LanguageNode node) {
        LanguageNode tmp = this.head;
        if (tmp.next == null) {
            System.out.println("链表为空");
            return;
        }
        while (true) {
            if (tmp.next == null) {
                System.out.println("被修改的数据不存在");
                break;
            }
            if (tmp.next.no == node.no) {
                node.next = tmp.next.next;
                tmp.next = node;
                break;
            }
            tmp = tmp.next;
        }
    }

2.4 删除节点

思路：先找到被删除的节点的前一个节点，定义为temp,我们将temp.next=temp.next.next将节点的饮用指要删除的向下个节点。
在这里插入图片描述

代码实现：

public void delete(LanguageNode node) {
        LanguageNode tmp = this.head;
        if (tmp.next == null) {
            System.out.println("链表为空");
            return;
        }
        while (true) {
            if (tmp.next == null) {
                System.out.println("被删除的数据不存在");
                break;
            }
            if (tmp.next.no == node.no) {
                tmp.next = tmp.next.next;
                break;
            }
            tmp = tmp.next;
        }
}

以上完成了链表的增删改查；

附录：完整代码

public class SingleLinkedList {
    /**
     * 定义头节点
     */
    private LanguageNode head = new LanguageNode(0, "", "");


    public static void main(String[] args) {
        SingleLinkedList linkedList = new SingleLinkedList();
        LanguageNode java = new LanguageNode(1, "java", "超级好用");
        LanguageNode python = new LanguageNode(2, "python", "python");
        LanguageNode goLang = new LanguageNode(3, "goLang", "goLang");
        LanguageNode js = new LanguageNode(4, "js", "js");
        LanguageNode php = new LanguageNode(5, "php", "php是世界上最好的语言");
        LanguageNode node = new LanguageNode(4, "node", "node");
        linkedList.addByOrder(python);
        linkedList.addByOrder(java);
        linkedList.addByOrder(js);
        linkedList.addByOrder(php);
        linkedList.addByOrder(goLang);
        linkedList.update(node);
        linkedList.delete(node);
        linkedList.list();
    }

    public void delete(LanguageNode node) {
        LanguageNode tmp = this.head;
        if (tmp.next == null) {
            System.out.println("链表为空");
            return;
        }
        while (true) {
            if (tmp.next == null) {
                System.out.println("被删除的数据不存在");
                break;
            }
            if (tmp.next.no == node.no) {
                tmp.next = tmp.next.next;
                break;
            }
            tmp = tmp.next;
        }
    }


    public void update(LanguageNode node) {
        LanguageNode tmp = this.head;
        if (tmp.next == null) {
            System.out.println("链表为空");
            return;
        }
        while (true) {
            if (tmp.next == null) {
                System.out.println("被修改的数据不存在");
                break;
            }
            if (tmp.next.no == node.no) {
                node.next = tmp.next.next;
                tmp.next = node;
                break;
            }
            tmp = tmp.next;
        }
    }


    /**
     * 根据顺序添加节点
     *
     * @param node 添加数据
     * @return 当前节点
     */
    public LanguageNode addByOrder(LanguageNode node) {
        //因为头节点不能移动，定义临时变量tmp
        LanguageNode tmp = this.head;
        //定义链表添加标识符
        boolean flag = false;
        while (true) {
            if (tmp.next == null) {
                break;
            }
            if (tmp.next.no > node.no) {
                break;
            } else if (tmp.next.no == node.no) {
                //说明该顺序已经存在
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if (flag) {
            System.out.printf("插入的位置%d已存在，不能插入\n", node.no);
        } else {
            node.next = tmp.next;
            tmp.next = node;
        }
        return node;
    }

    /**
     * 添加节点
     *
     * @param node 添加数据
     * @return
     */
    public LanguageNode add(LanguageNode node) {
        //因为头节点不能移动，定义临时变量tmp
        LanguageNode tmp = this.head;
        //将数据添加到最后，便利链表
        while (tmp.next != null) {
            tmp = tmp.next;
        }
        tmp.next = node;
        return node;
    }

    public void list() {
        LanguageNode tmp = this.head;
        if (tmp.next == null) {
            System.out.println("链表为空");
        }
        while (tmp.next != null) {
            System.out.println(tmp.next);
            tmp = tmp.next;
        }
    }


    /**
     * 单链表节点
     */
    public static class LanguageNode {
        /**
         * 排序
         */
        private int no;
        /**
         * 语言名称
         */
        private String language;
        /**
         * 语言描述
         */
        private String languageDescribe;
        /**
         * 下个节点
         */
        private LanguageNode next;


        public LanguageNode(int no, String language, String languageDescribe) {
            this.no = no;
            this.language = language;
            this.languageDescribe = languageDescribe;
            this.next = null;
        }


        public int getNo() {
            return no;
        }

        public String getLanguage() {
            return language;
        }

        public String getLanguageDescribe() {
            return languageDescribe;
        }

        public LanguageNode getNext() {
            return next;
        }

        @Override
        public String toString() {
            return "LanguageNode{" +
                    "no=" + no +
                    ", language='" + language + '\'' +
                    ", languageDescribe='" + languageDescribe + '\'' +
                    '}';
        }

    }
}

3、关于单链表的经典面试题

3.1 求单链表中有效节点个数

代码实现：

public static int getLength(LanguageNode head) {
        if (head.next == null) {
            return 0;
        }
        LanguageNode tmp = head;
        int length = 0;
        while (tmp.next != null) {
            length++;
            tmp = tmp.next;
        }
        return length;
    }

3.2 查找单链表中的倒数第K个节点

解析思路：

  • 编写一个方法同时接收head节点和index节点
  • index表示倒数第index个节点
  • 先把链表从头遍历一遍，得到链表的总长度为length,这里可以使用上面的getLength函数
  • 得到size后，我们可以从链表的第一个开始遍历（size-index）个，就可以得到
  • 如果找到该节点就返回，否则返回null
    代码实现：
public static LanguageNode findLastIndexNode(LanguageNode head, int index) {
        if (head.next == null) {
            return null;
        }
        int size = getLength(head);
        if (index < 0 || index > size) {
            return null;
        }
        LanguageNode tmp = head.next;
        for (int i = 0; i < size - index; i++) {
            tmp = tmp.next;
        }
        return tmp;
}

3.3 单链表的反转

实现思路：

  • 先定义一个节点reverseHead = new LanguageNode();
  • 从头到尾遍历原来的链表，每个遍历节点，将其取出，并放在新的链表先定义一个节点reverseHead的最前端。
  • 原来的链表的head.next = reverseHead.next

image

代码实现

/**
 * 单链表反转
 *
 * @param head 原始链表
 * @return
 */
static void reverseList(LanguageNode head) {
    //一个节点不需要转换
    if (head.next == null || head.next.next == null) {
        return;
    }
    //定义辅助变量
    LanguageNode reverseNode = new LanguageNode(0, "", "");
    LanguageNode cur = head.next;
    LanguageNode next = null;
    while (cur != null) {
        //保存当前节点的下一个节点
        next = cur.next;
        //将cut的下一个节点，指向新链表的最前端
        cur.next = reverseNode.next;
        //将 cur 连接到新的链表上
        reverseNode.next = cur;
        cur = next;
    }
    head.next = reverseNode.next;
}

public static void main(String[] args) {
    SingleLinkedList linkedList = new SingleLinkedList();
    LanguageNode java = new LanguageNode(1, "java", "超级好用");
    LanguageNode python = new LanguageNode(2, "python", "python");
    LanguageNode goLang = new LanguageNode(3, "goLang", "goLang");
    LanguageNode js = new LanguageNode(4, "js", "js");
    LanguageNode php = new LanguageNode(5, "php", "php是世界上最好的语言");
    LanguageNode node = new LanguageNode(4, "node", "node");
    linkedList.addByOrder(python);
    linkedList.addByOrder(java);
    linkedList.addByOrder(js);
    linkedList.addByOrder(php);
    linkedList.addByOrder(goLang);
    linkedList.update(node);
    System.out.println("反转前链表：");
    linkedList.list();
    reverseList(linkedList.getHead());
    System.out.println("反转后链表：");
    linkedList.list();
}
//结果：
反转前链表：
LanguageNode{no=1, language='java', languageDescribe='超级好用'}
LanguageNode{no=2, language='python', languageDescribe='python'}
LanguageNode{no=3, language='goLang', languageDescribe='goLang'}
LanguageNode{no=4, language='node', languageDescribe='node'}
LanguageNode{no=5, language='php', languageDescribe='php是世界上最好的语言'}
反转后链表：
LanguageNode{no=5, language='php', languageDescribe='php是世界上最好的语言'}
LanguageNode{no=4, language='node', languageDescribe='node'}
LanguageNode{no=3, language='goLang', languageDescribe='goLang'}
LanguageNode{no=2, language='python', languageDescribe='python'}
LanguageNode{no=1, language='java', languageDescribe='超级好用'}

从尾到头打印单链表（方法1、反向遍历，2、Stack栈）

实现思路：

  • 方式一
    • 可以先进行链表反转，在进行便利打印，反转会破坏原始链表结构，不推荐使用
  • 方式二
    • 可以利用栈的数据结构，将各个节点压入打栈中，然后利用栈的先进后出的特点，实现逆序打印。
代码实现
static void reversePrint(LanguageNode head) {
    if (head.next == null) {
        return;
    }
    Stack<LanguageNode> stack = new Stack<>();
    while (head.next != null) {
        stack.push(head.next);
        head = head.next;
    }
    while (stack.size() > 0) {
        System.out.println(stack.pop());
    }
}


public static void main(String[] args) {
    SingleLinkedList linkedList = new SingleLinkedList();
    LanguageNode java = new LanguageNode(1, "java", "超级好用");
    LanguageNode python = new LanguageNode(2, "python", "python");
    LanguageNode goLang = new LanguageNode(3, "goLang", "goLang");
    LanguageNode js = new LanguageNode(4, "js", "js");
    LanguageNode php = new LanguageNode(5, "php", "php是世界上最好的语言");
    LanguageNode node = new LanguageNode(4, "node", "node");
    linkedList.addByOrder(python);
    linkedList.addByOrder(java);
    linkedList.addByOrder(js);
    linkedList.addByOrder(php);
    linkedList.addByOrder(goLang);
    linkedList.update(node);
    System.out.println("正序打印：");
    linkedList.list();
    System.out.println("倒叙序打印：");
    reversePrint(linkedList.getHead());
}
//输出结果
正序打印：
LanguageNode{no=1, language='java', languageDescribe='超级好用'}
LanguageNode{no=2, language='python', languageDescribe='python'}
LanguageNode{no=3, language='goLang', languageDescribe='goLang'}
LanguageNode{no=4, language='node', languageDescribe='node'}
LanguageNode{no=5, language='php', languageDescribe='php是世界上最好的语言'}
倒叙序打印：
LanguageNode{no=5, language='php', languageDescribe='php是世界上最好的语言'}
LanguageNode{no=4, language='node', languageDescribe='node'}
LanguageNode{no=3, language='goLang', languageDescribe='goLang'}
LanguageNode{no=2, language='python', languageDescribe='python'}
LanguageNode{no=1, language='java', languageDescribe='超级好用'}
Julywhj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之单链表超详细
xiangjunyes的博客
06-05 1038
链表是有序的列表，它在内存中存储结构如下： 下图是带头结点的链表 简单的描述一下： 头指针head 指向地址150的data域a1，a1的next域指向110的地址的data域a2,，依次类推。从上图我们可以得到如下信息：单链表(带头结点）逻辑结构示意图如下：使用带 head头的单向链表实现–水浒英雄排行榜管理完成对英雄人物的增删改查操作。 输出结果 目前insert插入没有考虑编号，怎么根据no排序了？添加结点的时候，根据排名将结点插入到指定的位置（如果这个位置有人，则添加失败，并提示。） 输出结果
单链表(结构)
weixin_52827539的博客
04-07 1248
单链表(结构) 题目描述 单链表结点的存储结构SNode包含两部分：数据、下一结点指针。单链表首个结点的地址head为表头指针,定义SNode *head=NULL表示单链表初始为空。 单链表的创建：createList(SNode *&head, int *value, int n)，用value数组中的n个数据生成一个单链表(表头指针为head)。 单链表的输出：printList(SNode *head),从头至尾遍历以head为表头的单链表，输出每个结点的数据值。 单链表数据插入: inse
数据结构链表操作
qq_51649346的博客
03-05 866
线性表3.5 1.顺序存储结构线性表 1.1删除操作 Status ListDelete(SqList *L,int i,ElemType *e) { if(L->length==0)//判断是否为空表 { return error; } if(i>L-length||i<1)//判断删除的位置是否在表内 { return error; } *e=L->data[i-1];//将删除位置的数据给e
C语言-链表增加数据
m0_55823320的博客
05-09 408
【代码】C语言-链表增加数据。
链表：自引用结构
zhoufy的博客
02-13 1055
链表： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作。 例： #include typedef struct student {
数据结构与算法-JavaScript描述
09-30
数据结构与算法是计算机科学的基础，对于任何编程语言来说，理解和掌握它们都是至关重要的，JavaScript也不例外。本资源“数据结构与算法-JavaScript描述”显然是一本专注于将这些概念应用于JavaScript编程的电子书...
Python实现数据结构与算法——反转链表
12-21
链接：https://leetcode-cn.com/problems/reverse-linked-list 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 解题思路： 思路1：迭代 假设有链表1->2->3->4->5->None， 反转后得None<-...
leetcode给单链表加一js实现-what-is-a-linked-list:算法和数据结构
06-30
当我们需要快速插入和删除数据时，我们可以选择使用链表代替其他数据结构。 列表开头的 Node 称为head ，而末尾的 Node 称为tail 。 什么是节点？ Node 是一个具有两个属性的对象： value和next 。 该value存储我们...
Doubly-linked-list.rar_数据结构_Visual_C++_
08-12
在IT领域，数据结构是计算机科学的基础，它们是组织、存储和处理数据的方式。双向链表是一种特殊的数据结构，属于线性数据结构的一种，它在实际编程中有着广泛的应用，尤其是在C++这样的面向对象编程语言中。本项目...
C#数据结构与算法揭秘四 双向链表
12-31
O(1)，那么，需要在结点中设两个引用域，一个保存直接前驱结点的地址，叫 prev，一个直接后继结点的地址，叫 next，这样的链表就是双向链表(Doubly Linked List)。双向链表的结点结构示意图如图所示。 双向链表结点...
（Python3）数据结构–单链表之计算两数之和
12-22
前言 有Python基础 有数据结构单链表基础，不清楚的参考前面的博客 链接： https://blog.csdn.net/sf9898/article/details/104946291 问题描述 这是某大厂的面试题，现场写代码的那种。 给出两个非空的链表，用来表示两个非负的整数，他们的位数是按逆序存储的， 并且每一个节点都只能存储一个数字。如果将这两个数相加，则会返回一个新的链表 来表示他们的和。可以假设除了数字0之外，这两个数都不会以0开头。 输入输出这一块划重点，这里的输入输出是比较抽象的，大致意思对了就行，不是牛客网那种格式化输入。 输入（1 -> 6 -> 4）+ (3 -> 1
用c语言链表排列数据，可以随便输入几个数并进行排序
05-28
这个程序对链表不太熟练的学者有很好的帮助，使读者能够很快的理解链表的精髓。
Python中有关链表的操作（经典面试内容）
热门推荐
su_bao的博客
07-16 1万+
1、创建一个链接node1 = Node("c",node3) 或者 node1 = Node("c",None) node1.next = node3 2、用循环创建一个链表结构，并且访问其中的每一个节点class Node(object): def __init__(self, data, next=None): self.data = data sel...
Python成为专业人士笔记–自定义链表
创帆云的博客
05-07 135
“专业人士笔记”系列目录： 创帆云：Python成为专业人士笔记--强烈建议收藏！每日持续更新！ 概述 链表是节点的集合，每个节点由一个索引和一个值组成，索引将所有节点串成了一个序列。自定义链表可用于实现更为复杂的数据结构，如列表、堆栈、队列和关联数组等。 自定义链表建立 本例使用与内置list对象相同的许多方法实现了一个链表 ...
python单链表操作_单链表的创建、增删改查等操作（Python实现）
weixin_39612677的博客
01-29 252
单链表的创建、增删改查等操作(Python实现)# 单链表class Node:def __init__(self, elem):self.elem = elemself.next = Noneclass SingleLinkedList:def __init__(self, length):self.head = Node(length)self.end = self.headdef lengt...
python：添加链表头节点、尾结点、遍历链表、反转链表
FANJUNCHENG155的博客
08-12 602
今天做到了反转链表，就想着运用前几天学的东西，重新复盘一下，最后发现还是有些模棱两可的地方，说明以往的学习都是在自我安慰，没有将逻辑内化为自身的知识。
python实现链表增删改查
Slytherin_Cat的博客
10-22 1071
-- coding: utf-8 -- “”&quot; Created on Mon Oct 22 14:57:59 2018 @author: dell “”&quot; class LNode: def init(self,elem,next_=None): self.elem=elem self.next=next_ #存放元素下一个结点 def length(self): '''返回链表长度...
LeetCode—Python版链表简单题（一）
dzysunshine的博客
06-28 1773
1. 合并两个有序链表（21） 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 解法 很简单的链表拼接题，但是要注意两个地方 1、返回值要返回head.next 2、无需判断循环后哪个不为空，or返回第一个为真的...
数据结构与算法c语言单链表
最新发布
09-19
单链表是一种经典的链式存储结构，它由一个包含数据和指向下一个节点的指针的节点构成。单链表的创建有头插法和尾插法两种方法。头插法将新创建的节点插入到头节点之后，而尾插法将新创建的节点插入到尾节点之后。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Julywhj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值