【数据结构-2】单向链表

已于 2024-03-27 21:25:25 修改
阅读量460 收藏 4
点赞数 10
文章标签： 数据结构 链表
于 2024-03-24 16:23:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lnx97111/article/details/136987149
版权

学习目标：

掌握单向链表

学习内容：

  1. 单向链表
  2. 带哨兵的单向链表
  3. 力扣相关练习

链表

链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

单向链表

1 定义链表

public class SinglyLinkList {
    private Node head = null; //头指针

    private static class Node {
        int value; //值
        Node next; //下一个节点

        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }
}

2 头插元素

    public void addFirst(int value) {
        head = new Node(value, head);
    }

3 尾插元素

	//查找链表最后一个元素
	 private Node findLast() {
	       if (head == null)//空链表
	           return null;
	
	       Node p = head;
	       while (p.next != null) {
	           p = p.next;
	       }
	       return p;
	   }

    public void addLast(int value){
        Node last = findLast();

        if(last == null){ //空链表直接头插
            addFirst(value);
            return;
        }

        last.next = new Node(value,null);
    }

4 循环遍历

4.1 基于while遍历

    //基于while
    public void loop(Consumer<Integer> consumer) {
        Node p = head;
        while (p != null) {
            consumer.accept(p.value);
            p = p.next;
        }
    }

4.2基于for遍历

    //基于for
    public void loop2(Consumer<Integer> consumer) {
        for (Node p = head; p != null; p = p.next) {
            consumer.accept(p.value);
        }
    }

4.3 基于iterator遍历

    //基于iterator
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = head;
            @Override
            public boolean hasNext() {
                return p!=null;
            }

            @Override
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        };
    }

4.4 递归遍历

    public void loop(Node node) {
        recursion(head);
    }

    private void recursion(Node node) {
        if (node == null) return;
        System.out.println(node.value);
        recursion(node.next);
    }

5 根据索引查询元素

    private Node findNode(int index) {
        int i = 0;
        for (Node p = head; p != null; p = p.next, i++) {
            if (i == index) {
                return p;
            }
        }
        return null;
    }
    
    public int get(int index) {
        Node node = findNode(index);
        if (node == null) {
            throw new IllegalArgumentException(String.format("index [%d]", index));
        }
        return node.value;
    }

6 根据索引位置插入元素

    public void insert(int index, int value) {
        if (index == 0) addFirst(value);
        Node prev = findNode(index - 1); //找上一个节点
        if (prev == null) { //找不到上一个节点
            throw new IllegalArgumentException(String.format("index [%d] 不合法", index));
        }
        prev.next = new Node(value, prev.next);
    }

7 删除第一个元素

    public void removeFirst(){
        if(head==null){
            throw new IllegalArgumentException(String.format("index 不合法"));
        }
        head = head.next;
    }

8 按索引删除元素

    public void remove(int index) {
        if (index == 0) removeFirst();
        Node prev = findNode(index - 1); //上一个节点
        if (prev == null) {
            throw new IllegalArgumentException(String.format("index [%d] 不合法", index));
        }
        Node removed = prev.next;
        if (removed == null) {
            throw new IllegalArgumentException(String.format("index [%d] 不合法", index));
        }
        prev.next = removed.next;
    }

优化单向链表-哨兵节点

在基础的实现方法中需要频繁地判断节点是否为空，添加哨兵节点后，链表中至少会有一个哨兵节点，因此可以省去许多判空操作。

1 定义链表

需要添加一个哨兵节点，节点的value无所谓，head要指向哨兵节点。

public class SinglyLinkList {
    private Node head = new Node(666,null); //头指针指向哨兵节点

    private static class Node {
        int value; //值
        Node next; //下一个节点

        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }
}

2 头插元素

    public void addFirst(int value) {
        insert(0,value);
    }

3 尾插元素

	//查找链表最后一个元素
	 private Node findLast() {
	       Node p = head;
	       while (p.next != null) {
	           p = p.next;
	       }
	       return p;
	   }

    public void addLast(int value){
        Node last = findLast();
        last.next = new Node(value,null);
    }

4 循环遍历

添加哨兵节点后，遍历起点要从head变为head.next，即哨兵节点。

4.1 基于while遍历

    //基于while
    public void loop(Consumer<Integer> consumer) {
        Node p = head.next;
        while (p != null) {
            consumer.accept(p.value);
            p = p.next;
        }
    }

4.2 基于for遍历

    //基于for
    public void loop2(Consumer<Integer> consumer) {
        for (Node p = head.next; p != null; p = p.next) {
            consumer.accept(p.value);
        }
    }

4.3 基于iterator遍历

    //基于iterator
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = head.next;
            @Override
            public boolean hasNext() {
                return p!=null;
            }

            @Override
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        };
    }

5 根据索引查询元素

    private Node findNode(int index) {
        int i = -1;
        for (Node p = head; p != null; p = p.next, i++) {
            if (i == index) {
                return p;
            }
        }
        return null;
    }
    
    public int get(int index) {
        Node node = findNode(index);
        if (node == null) {
            throw new IllegalArgumentException(String.format("index [%d]", index));
        }
        return node.value;
    }

6 根据索引位置插入元素

    public void insert(int index, int value) {
        Node prev = findNode(index - 1); //找上一个节点
        if (prev == null) { //找不到上一个节点
            throw new IllegalArgumentException(String.format("index [%d] 不合法", index));
        }
        prev.next = new Node(value, prev.next);
    }

7 删除第一个元素

    public void removeFirst(){
        remove(0);
    }

8 按索引删除元素

    public void remove(int index) {
        Node prev = findNode(index - 1); //上一个节点
        if (prev == null) {
            throw new IllegalArgumentException(String.format("index [%d] 不合法", index));
        }
        Node removed = prev.next;
        if (removed == null) {
            throw new IllegalArgumentException(String.format("index [%d] 不合法", index));
        }
        prev.next = removed.next;
    }

力扣链表相关练习

1.反转单向链表

解法一：新建链表逐个存取

    public static ListNode reverseList1(ListNode o1) {
        ListNode n1 = null;
        ListNode p = o1;
        while (p != null) {
            n1 = new ListNode(p.val, n1);
            p = p.next;
        }
        return n1;
    }

解法二：递归改节点的next

思路：首先找到最后一个节点，接着在退出递归的过程中依次完成相邻节点逆序

 public static ListNode reverseList2(ListNode p) {
        if (p == null) {
            return null;
        }
        
        //找到最后一个节点
        if (p.next == null) {
            return p;
        }
        ListNode last = reverseList2(p.next);

        //和其下一个节点相邻节点逆序
        p.next.next = p;
        p.next = null;
        return last;
    }

解法三：

思路：逐渐将旧链表的第二个元素头插

    public static ListNode reverseList3(ListNode o1) {
        if (o1 == null || o1.next == null) return o1;
        ListNode n1 = o1;
        while (o1.next != null) {
            ListNode p = o1.next;
            o1.next = p.next;
            p.next = n1;
            n1 = p;
        }
        return n1;
    }

解法四：

思路：不断将旧链表头部头插到新链表

    public static ListNode reverseList4(ListNode o1){
        ListNode n1 = null;
        while(o1!=null){
            ListNode o2 = o1.next;
            o1.next = n1;
            n1 = o1;
            o1 = o2;
        }
        return n1;
    }

2.根据值删除链表节点

解法一：遍历

    public static ListNode removeElements(ListNode head, int val) {
        //哨兵节点
        ListNode s = new ListNode(-1, head);
        ListNode p1 = s;
        ListNode p2 = s.next;
        while (p2 != null) {
            if (p2.val == val) {
                p1.next = p2.next;
                p2 = p2.next;
            } else {
                p1 = p1.next;
                p2 = p2.next;
            }
        }
        return s.next;
    }

解法二：递归

思路：

  • 如果p == val ，返回p.next递归的结果
  • 如果p != val ，返回p拼接上p.next递归的结果
    public static ListNode removeElements2(ListNode p,int val){
        if(p==null){
            return null;
        }
        if(p.val==val){
            return removeElements2(p.next,val);
        }else {
            p.next = removeElements2(p.next,val);
            return p;
        }

    }

3.删除倒数第n个节点

解法一：遍历

思路：快慢指针

    public static ListNode removeNthFromEnd(ListNode p, int n) {
        ListNode s = new ListNode(-1,p);//哨兵
        ListNode p1 = s;
        ListNode p2 = s;
        int t = n + 1; //p1,p2指针的距离
        while(t>0){
            p2 = p2.next;
            t--;
        }
        while(p2!=null){
            p2 = p2.next;
            p1 = p1.next;
        }
        p1.next = p1.next.next;

        return s.next;
    }

解法二：递归

    public static ListNode removeNthFromEnd(ListNode p, int n) {
        //哨兵用来处理删除首结点的情况
        ListNode s =new ListNode(-1,p);
        recursion(s,n);
        return s.next;
    }

    private static int recursion(ListNode p, int n) {
        if (p == null) return 0;
        int nth = recursion(p.next, n);
        if (nth == n) {
            p.next = p.next.next;
        }
        return nth + 1;
    }

4.删除有序链表的重复节点（保留重复的第一个节点）

方法1：遍历

    public static ListNode deleteDuplicates(ListNode p){
        ListNode p1 = p;
        ListNode p2 = p.next;
        while(p2!=null){
            if(p1.val==p2.val) {
                p1.next = p2.next;
                p2 = p2.next;
            }else{
                p1 = p1.next;
                p2 = p2.next;
            }
        }
        return p;
    }

方法2：递归

    public static ListNode deleteDuplicates2(ListNode p){
        ListNode s = new ListNode(-1,p);
        recursion(s);
        return s.next;
    }

    public static int recursion(ListNode p){
        if(p==null){
            return 0;
        }
        int nextValue = recursion(p.next);
        if(p.val == nextValue){
            p.next = p.next.next;
        }
        return p.val;
    }

5.有序链表去重（重复元素都不留）

方法一：遍历

    public static ListNode deleteDuplicates2(ListNode p) {
        if (p == null || p.next == null) {
            return p;
        }
        ListNode s = new ListNode(-1, p);
        ListNode p1 = s;
        ListNode p2;
        ListNode p3;
        while ((p2 = p1.next)!= null && (p3 = p2.next) != null) {
            if (p2.val == p3.val) {
                while ((p3 = p3.next) != null && p3.val == p2.val) {

                }
                p1.next = p3;
            } else {
                p1 = p1.next;
            }
        }
        return s.next;
    }

方法二：递归

    public static ListNode deleteDuplicates(ListNode p) {
        if (p == null || p.next == null) {
            return p;
        }
        if (p.val == p.next.val) {
            ListNode x = p.next.next;
            while (x != null && x.val == p.val) {//x定位到第一个不等于p.val的节点
                x = x.next;
            }
            return deleteDuplicates(x);
        } else {
            p.next = deleteDuplicates(p.next);//去重后拼接
            return p;
        }
    }

6.合并两个有序链表

解法一：遍历

    public static ListNode mergeTwoLists(ListNode p1, ListNode p2) {
        ListNode s = new ListNode(-1, null);
        ListNode q = s;
        while (p1 != null || p2 != null) {
            if (p1 == null) {
                q.next = p2;
                return s.next;
            }
            if (p2 == null) {
                q.next = p1;
                return s.next;
            }
            if (p1.val <= p2.val) {
                q.next = p1;
                p1 = p1.next;
            } else {
                q.next = p2;
                p2 = p2.next;
            }
            q = q.next;
        }
        return null;
    }

解法二：递归

    public static ListNode mergeTwoLists2(ListNode p1, ListNode p2) {
        if (p1 == null)
            return p2;
        if (p2 == null)
            return p1;
        if (p1.val < p2.val) {
            p1.next = mergeTwoLists2(p1.next, p2);
            return p1;
        } else {
            p2.next = mergeTwoLists2(p1, p2.next);
            return p2;
        }
    }

7.合并多个有序链表

利用分治法

    public static ListNode mergeTwoLists(ListNode p1, ListNode p2) {
        ListNode s = new ListNode(-1, null);
        ListNode q = s;
        while (p1 != null || p2 != null) {
            if (p1 == null) {
                q.next = p2;
                return s.next;
            }
            if (p2 == null) {
                q.next = p1;
                return s.next;
            }
            if (p1.val <= p2.val) {
                q.next = p1;
                p1 = p1.next;
            } else {
                q.next = p2;
                p2 = p2.next;
            }
            q = q.next;
        }
        return null;
    }

    public static ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        return split(lists, 0, lists.length - 1);
    }

    //返回合并后的链表，i和j分别代表左右边界
    private static ListNode split(ListNode[] lists, int i, int j) {
        if(i==j){ //数组内只有一个链表
            return lists[i];
        }
            
        int m = (i + j) >>> 1;
        ListNode left = split(lists, i, m);
        ListNode right = split(lists, m + 1, j);
        return mergeTwoLists(left, right);
    }

8.查找链表的中间节点

    public ListNode middleNode(ListNode head) {
        ListNode p1 = head;
        ListNode p2 = head;
        while (p2 != null && p2.next != null) {
            p1 = p1.next;
            p2 = p2.next;
            p2 = p2.next;
        }
        return p1;
    }

9.判断是否是回文列表

    //判断回文链表
    /*
     * 1.找到中间节点
     * 2.中间点后半个链表反转
     * 3.反转后链表和元链表比较*/
    public static boolean isPalindrome(ListNode head) {
        ListNode middle = middleNode(head);
        ListNode newHead = reverse(middle);

        while (newHead!=null){
            if(newHead.val!=head.val){
                return false;
            }
            head = head.next;
            newHead = newHead.next;
        }
        return true;
    }

    private static ListNode reverse(ListNode o1){
        ListNode n1 = null;
        while(o1!=null){
            ListNode o2 = o1.next;
            o1.next = n1;
            n1 = o1;
            o1 = o2;
        }
        return n1;
    }

    private static ListNode middleNode(ListNode head) {
        ListNode p1 = head;
        ListNode p2 = head;
        while (p2 != null && p2.next != null) {
            p1 = p1.next;
            p2 = p2.next;
            p2 = p2.next;
        }
        return p1;
    }

找中间点和反转可以优化为同一步内完成，进一步提升效率

10. 判断链表是否有环

佛洛依德的龟与兔

第一阶段：

  • 龟走一步，兔走两步
  • 兔子走到终点则不存在环
  • 兔子追上龟则判断存在环

第二阶段：

  • 从一次相遇开始，龟回到起点，兔位置保持不变
  • 兔和龟一次都走一步
  • 再次相遇时，地点就是环的入口

第一阶段：判断是否有环

    public static boolean hasCycle(ListNode head) {
        ListNode h = head; //兔
        ListNode t = head; //龟
        while (h != null && h.next != null) {
            h = h.next.next;
            t = t.next;
            if (h == t) {
                return true;
            }
        }
        return false;
    }

第二阶段：判断环入口

    public static ListNode detectCycle(ListNode head) {
        ListNode h = head; //兔
        ListNode t = head; //龟
        while (h != null && h.next != null) {
            h = h.next.next;
            t = t.next;
            if (h == t) {
                //进入第二阶段
                t = head;
                while (true) {
                    if (t == h) {
                        return t;
                    }
                    h = h.next;
                    t = t.next;
                }
            }
        }
        return null;
    }
BancroftLee
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言初阶-(单向链表)
03-08
包含单向链表的插入，删除，遍历 含有前插法，尾插法等链表操作 适用于数据结构初学者使用 线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个结点 (第一个数据元素的存储映像，...
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
数据结构-单向循环链表
没出过地球
06-11 1993
定义：单向环形链表是指在单链表的基础上，最后一个节点的指针域指向链表的第一个节点，从而构成一个闭合的环。结构：每个节点包含一个数据域和一个指针域。数据域用于存储数据，指针域用于指向下一个节点。在单向环形链表中，最后一个节点的指针域指向第一个节点，形成环状结构。
数据结构--单向链表
不吃熊的草莓
12-24 559
链表是区分于数组的一种地址不连续，没有顺序的数据接口，链表中的节点包含数据元素值和指针，指针指向链表的下一个节点。 使用链表无需像数组一样，需预先定义数据大小，也无需同集合需要扩容。但链表的缺点也很明显，链表读取数据需从头依次获取。不支持随机读取。 定义单向链表节点 定义单向链表类，其中有链表使用方法 如何获取链表中间节点 如何判断链表有环以及环的长度 import java.util.HashMap; import java.util.Map; import org.apache.log
【数据结构】超详细--单向链表
joes_ju的博客
11-14 788
保姆级，超详细的C语言来实现数据结构的单向非循环链表功能
C语言：数据结构--单向链表详解
weixin_44498318的博客
05-02 2650
单向链表 （1）单向链表的基本了解 先是定义一个单向链表的节点结构体： typedef struct Node{ int data; struct Node *pNext; }NODE, *PNODE; 那么整个结构体可以抽象成下图： 其中，一个空链表就只有一个头节点（在本篇文章中头节点用于数据的存储，只用于作为索引，当然，你也可以将它和普通节点一样存放数据等）： 而n个节点的链表如下（这里n=3）： （2）增删改查 ① 增——在尾部增加节点 ② 增——在中间插入一个节点 ③
数据结构之链表---单向链表
weixin_55530858的博客
07-15 1444
单向链表，数据结构
数据结构与算法---单向链表
weixin_73602725的博客
03-01 1325
单向链表的详细讲解（附完整版）
数据结构--单向链表篇（python实现）
weixin_74068942的博客
07-10 949
优点不需要预先知道数据大小，实现灵活的内存动态管理插入、删除指定数据速度快缺点读取指定位置数据速度慢空间开销比较大需要初始化node类(需要一个节点) 创建链表 插入节点 插入头节点 插入尾节点 获取数据 删除数据 遍历链表 写在最后
数据结构 -- 链表详解
hu_143的博客
04-27 2292
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
基本数据结构-单向链表
leaf_lucky的博客
11-03 627
数据结构基础--单向链表
数据结构--单向链表2
chuanluwang的博客
11-14 620
数据结构--单向链表2
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
西南交通大学数据结构实验之单向链表算法练习
02-01
本资源总结了西南交通大学数据结构实验报告的单向链表算法练习，涵盖了链表的基本操作、算法设计、输入/输出设计、编程语言说明等方面的知识点。 一、链表的基本操作 * 单向链表的插入操作：在链表的第 i 个元素...
高阶数据结构——LRU Cache
weixin_74310945的博客
08-09 647
LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。
常见8种数据结构
qq_43575301的博客
08-08 1948
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
基础算法模板
2301_79235379的博客
08-08 509
欢迎订阅专栏，数据结构实验，期末大作业，前端后端，算法都有哦，想我发哪个方面的资源或文章可以私信我，免费的哦。
数据结构--第六天
xujiashuo1的博客
08-08 1255
树是由。
数据结构——顺序表
最新发布
2401_82924480的博客
08-12 172
今天我们来进入数据结构的下一节——顺序表，在正式开始说顺序表之前，我们首先需要知道线性表的概念！
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值