单链表（Java）

最新推荐文章于 2023-03-27 16:37:20 发布
最新推荐文章于 2023-03-27 16:37:20 发布
阅读量713 收藏 2
点赞数 1
分类专栏： 算法（java） 文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55875421/article/details/128045056
版权

文章目录

1. 单链表结构

每一个节点之间通过next指针指向下一个节点
在这里插入图片描述
节点（Node）代码：

class TreeNode {
    public int val;
    public TreeNode next;

    public TreeNode () {
    }

    public TreeNode (int val) {
        this.val = val;
    }
}

2. 单链表的技巧

2.1 翻转链表

/**
     * 翻转链表
     *
     * @return 放回新链表的头节点
     */
public static TreeNode reverseLinked(TreeNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    // 创建辅助节点 进行移动
    TreeNode curNode = head;
    TreeNode curNextNode = head.next;
    curNode.next = null;
    while (curNextNode != null) {
        TreeNode temp = curNextNode.next;
        curNextNode.next = curNode;
        curNode = curNextNode;
        curNextNode = temp;
    }
    return curNode;
}

2.1 快慢指针

作用1：找到单链表的中间的位置

/**
 * @author zyq
 * @version 1.0
 */
public class LinkedDemo {

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        System.out.println(getMiddenLinked(node1).val);
    }

    public static Node getMiddenLinked(Node head) {
        // base case
        // 使用快慢指针的方式解决问题
        if (head == null) {
            return null;
        }
        // 设置快慢指针
        // 这里设置快指针走两步   慢指针走一步
        Node slow = head;
        Node fast = head;
        while (slow != null && fast.next != null) {
            // 当是偶数的时候 选择中间靠前的一个
            if (fast.next.next  == null) {
                break;
            }
            // 慢指针走一步
            slow = slow.next;
            // 快指针走两步
            fast = fast.next.next;
        }
        return slow;
    }

    public static class Node {
        public int val;
        public Node next;

        public Node(int val) {
            this.val = val;
        }

        public Node() {
        }
    }
}

作用2：判断单链表是否为环，快指针走两步、慢指针走一步，如果快指针走完了快慢指针还没有进行相遇，说明这个单链表不构成环。
在构成环的前提下，将这个快指针回到链表的初始的位置，再快慢指针都以一步的方式进行移动，最后相遇的地方就是交点位置。

/*
     * 1、如果快指针走完了还没有快慢指针相遇，什么这个单链表不是环状的单链表
     *
     * 2、如果快慢指针进行了相遇，说明是单链表，
     * 这个时候将快指针回到开始的地方，慢指针不动，这个时候同时走一步的方式，
     * 当快慢指针再次相遇的时候，这个位置就是第一个相交的位置
     */
public static Node getLoopNode(Node head) {
    // 排除额外的情况
    if (head == null || head.next == null || head.next.next == null) return null;
    // 设置快慢指针 都先动一步
    Node fast = head.next.next;
    Node slow = head.next;
    boolean judgeLoop = false;
    // 找到相遇的位置
    while (fast != null && fast.next != null) {
        // 不想等 进行移动
        if (slow == fast) {
            // 相遇 说明是环
            judgeLoop = true;
            break;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    // 不是环
    if (!judgeLoop) return null;
    // 是环 将快指针回到开始的位置
    fast = head;
    // 一起走一步到相遇的位置
    while (fast != slow) {
        fast = fast.next;
        slow = slow.next;
    }
    return slow;
}

3. 算法题

3.1 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
在这里插入图片描述
思路1：

第一步将链表的长度求出来，找到倒数第n个的数为多少

第二步将这个节点进行删除就可以

package com.sort.S2022_10_12;

/**
 * @author zyq
 * @version 1.0
 */
public class RemoveNthFromEnd {
    /**
     * 第一步将链表的长度求出来，找到倒数第n个的数为多少
     * <p>
     * 第二步将这个节点进行删除就可以
     *
     * @param head 头节点
     * @param n    倒数第几个
     * @return 头节点
     */
    public static ListNode removeNthFromEnd(ListNode head, int n) {
        if (head == null) {
            return null;
        }
        // 1 计算链表的长度
        int num = 0;
        ListNode temp = head;
        while (temp != null) {
            num++;
            temp = temp.next;
        }
        // 总共长度为 num 的长度
        int count = num - n;
        if (count == 0) {
            // 说明是第一个
            head = head.next;
            return head;
        }
        // 计算出链表的长度
        temp = head;
        int tempCount = 1;
        while (temp != null) {
            if (tempCount++ < count) {
                temp = temp.next;
            } else {
                temp.next = temp.next.next;
                break;
            }
        }
        return head;
    }
}

class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

思路二

1、将链表进行反转

2、删除指定位置的节点皆可

//1、将链表进行反转
//2、删除指定位置的节点皆可
public static ListNode removeNthFromEnd(ListNode head, int n) {
    if (head == null) {
        return null;
    }
    head = reserveLinked(head);
    ListNode temp = head;
    if (n == 1) {
        head = head.next;
        return reserveLinked(head);
    }
    // 计数
    int count = 0;
    while (temp != null) {
        count++;
        if (count == n - 1) {
            temp.next = temp.next.next;
        }
        temp = temp.next;
    }
    return reserveLinked(head);
}

// 翻转链表
public static ListNode reserveLinked(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode curNode = head;
    ListNode curNextNode = head.next;
    curNode.next = null;
    while (curNextNode != null) {
        ListNode temp = curNextNode.next;
        curNextNode.next = curNode;
        curNode = curNextNode;
        curNextNode = temp;
    }
    return curNode;
}

思路三

1、使用双指针的方式进行解决，先要一个指针走n步

2、再一起向后走，当快的那一个走到最后的时候，慢的那个就是在倒数n的位置

// 1、使用双指针的方式进行解决，先要一个指针走n步
// 2、再一起向后走，当快的那一个走到最后的时候，慢的那个就是在倒数n的位置
public static ListNode removeNthFromEnd3(ListNode head, int n) {g
    if (head == null) {
        return null;
    }
    ListNode fast = head;
    // 准备一个阈值的方式
    ListNode slow = new ListNode(0, head);
    ListNode temp = slow;
    // 将fast向后走n步
    for (int i = 0; i < n; i++) {
        fast = fast.next;
    }
    // 再将fast和slow一起向后走 一直走到fast不可以走了
    while (fast != null) {
        fast = fast.next;
        temp = temp.next;
    }
    // 将slow后面的那个进行删除
    temp.next = temp.next.next;
    return slow.next;
}

3.2 将一个链表按某值划分成左边小，中间相等，右边大的情况

思路一：

1、将链表转成对应的数组

2、使用快排的方式进行排序好，再将数组转成对应的链表

/**
     * 1、将链表转成对应的数组
     * 2、使用快排的方式进行排序好，再将数组转成对应的链表
     *
     * @return 排序好的链表
     */
public static ListNode linkedSort(ListNode head, int pivot) {
    // 对应的数组的值
    int[] arr = convertArr(head);
    // 进行一个partition
    partition(arr, 0, arr.length - 1, pivot);
    // 转成对应的链表的结构
    return convertLinked(arr);
}

// 将单链表转成对应的数组
public static int[] convertArr(ListNode head) {
    List<Integer> list = new ArrayList<>();
    ListNode temp = head;
    while (temp != null) {
        list.add(temp.val);
        temp = temp.next;
    }
    int[] arr = new int[list.size()];
    for (int i = 0; i < list.size(); i++) {
        arr[i] = list.get(i);
    }
    return arr;
}

// 将数组转成对应的单链表
public static ListNode convertLinked(int[] arr) {
    ListNode head = new ListNode(0);
    ListNode temp = head;
    for (int i : arr) {
        ListNode listNode = new ListNode(i);
        temp.next = listNode;
        temp = listNode;
    }
    return head.next;
}

public static int[] partition(int[] arr, int left, int right, int pivot) {
    // 确定小于的区域
    int minZone = left - 1;
    // 确定大于的区域
    int maxZone = right + 1;
    // 进行移动的指针
    int temp = left;
    while (temp < maxZone) {
        if (arr[temp] < pivot) {
            // 小于 temp向后移动 minZone向后移动 进行交换
            swap(arr, ++minZone, temp++);
        } else if (arr[temp] > pivot) {
            swap(arr, --maxZone, temp);
        } else {
            temp++;
        }
    }
    return arr;
}

public static void swap(int[] arr, int left, int right) {
    int temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
}

思路二

使用空间复杂度为O(1)的级别进行解决

和数组的partition类似，准备6个变量，左边的头，左边的尾，中间的头，中间的尾，右边的头，右边的尾

// 和数组的partition类似，准备6个变量，左边的头，左边的尾，中间的头，中间的尾，右边的头，右边的尾
public static ListNode linkedSort2(ListNode head, int pivot) {
    // 左边的头
    ListNode lH = null;
    // 左边的尾
    ListNode lT = null;
    // 中间的头
    ListNode eH = null;
    // 中间的尾
    ListNode eT = null;
    // 右边的头
    ListNode rH = null;
    // 右边的尾
    ListNode rT = null;
    ListNode next;
    ListNode temp = head;
    while (temp != null) {
        // 记录下一个节点
        next = temp.next;
        temp.next = null;
        if (temp.val < pivot) {
            if (lH == null) {
                lH = temp;
            } else {
                lT.next = temp;
            }
            lT = temp;
        } else if (temp.val == pivot) {
            if (eH == null) {
                eH = temp;
            } else {
                eT.next = temp;
            }
            eT = temp;
        } else {
            if (rH == null) {
                rH = temp;
            } else {
                rT.next = temp;
            }
            rT = temp;
        }
        temp = next;
    }
    // 是否有些情况没有  有小于区域
    if (lT != null) {
        lT.next = eH;
        eT = eT != null ? eT : lT;
    }
    // 等于部分有
    if (eT != null) {
        eT.next = rH;
    }
    // 如果上面都没有
    return lH != null ? lH : (eH != null ? eH : lH);
}

3.3 复制含随机指针节点的链表

在这里插入图片描述
思路1

使用Hash表的方式进行一一对应进行克隆

// 使用Hash表的方式进行一一对应进行克隆
public static Node hashCopyLinked(Node head) {
    Map<Node, Node> map = new HashMap<>();
    Node temp = head;
    // 将所有的节点进行复制 放入到map中
    while (temp != null) {
        map.put(temp, new Node(temp.val));
        temp = temp.next;
    }
    temp = head;
    while (temp != null) {
        map.get(temp).next = map.get(temp.next);
        map.get(temp).rand = map.get(temp.rand);
        temp = temp.next;
    }
    return map.get(head);
}

思路二

不使用额外的空间做这个题目

1、将所有的节点进行复制，放到复制的节点的后面

2、然后两个两个进行处理，最后将这个链表分成两个链表

// 1、将所有的节点进行复制，放到复制的节点的后面
//2、然后两个两个进行处理，最后将这个链表分成两个链表
public static Node copyLinked(Node head) {
    Node temp = head;
    while (temp != null) {
        // 复制一个节点
        Node node = new Node(temp.val);
        // 放到前节点的后面
        Node tempNode = temp.next;
        temp.next = node;
        node.next = tempNode;
        temp = node.next;
    }
    // 然后两个两个进行处理
    temp = head;
    while (temp != null && temp.next != null) {
        if (temp.rand == null) {
            temp.next.rand = null;
        } else {
            temp.next.rand = temp.rand.next;
        }
        temp = temp.next.next;
    }
    // 分离
    temp = head;
    Node res = head.next;
    Node curNode;
    Node next;
    while (temp != null) {
        next = temp.next.next;
        curNode = temp.next;
        temp.next = next;
        curNode.next = next != null ? next.next : null;
        temp = next;
    }
    return res;
}
m0_55875421
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面试题-实现复杂链表的复制代码分享
08-29
主要介绍了Java面试题-实现复杂链表的复制代码分享，小编觉得还是挺不错的，具有参考价值，需要的朋友可以了解下。
Java复杂链表的复制
qq_42900213的博客
07-05 252
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户内存消耗：41 MB, 在所有 Java 提交中击败了45.14%的用户通过测试用例：18 / 18...
java 链表复制_【Java】 剑指offer(35) 复杂链表的复制
weixin_28733933的博客
02-21 209
本文参考自《剑指offer》一书，代码采用Java语言。题目请实现函数ComplexListNode* Clone(ComplexListNode* pHead)，复制一个复杂链表。在复杂链表中，每个结点除了有一个m_pNext指针指向下一个点外，还有一个m_pSibling 指向链表中的任意结点或者nullptr。思路思路1：先复制结点，用next链接，最后根据原始结点的sibling指针确定该...
Java单链表的实现代码
09-02
在Java编程中，单链表是一种基础的数据结构，用于存储一系列有序的数据元素。单链表每个节点包含两部分：数据域（data）和指针域（next）。数据域存储实际的数据，而指针域指向链表中的下一个节点。本篇将详细解释...
java实现单链表
04-04
在这个主题中，我们将深入探讨如何使用Java来实现单链表，特别是关注如何插入元素以及如何构建链表。 单链表由一系列节点组成，每个节点包含两部分：数据元素和指向下一个节点的引用。在Java中，我们可以通过创建一...
java 单链表
09-08
使用java实现单链表，数据结构的基础知识........................................................................................
Java实现带头结点的单链表
08-25
Java实现带头结点的单链表 Java实现带头结点的单链表是一种链式数据结构，链表的特点是以节点方式存储，是链式结构。每个节点包含data域，next域：指向下一个节点。链表的各个节点不一定是连续存储。链表分为带头...
牛客JZ35——复杂链表的复制（JAVA）
weixin_51350949的博客
03-27 238
方法一：使用hash表，首先遍历链表，把节点本身和新建的对应节点都放入map中，然后再一次遍历链表，并从hash表中取出对应的值。把每一个节点复制并且插入原来的链表中，即原来1-2-3变成1-1（拷贝）-2-2（拷贝）-3-3（拷贝）思路：因为不可以用原来链表中的结点，所以链表里面的每一个节点我们都要重新新建一遍。然后再次遍历链表把对应的random指针也进行拷贝。最后再次遍历链表将链表拆成两个链表即可。head作为第二次遍历链表的头结点。pHead作为放入map的数据。res链表为返回的结果。
【Java】复制复杂链表
falime的博客
06-20 166
class Node { int val; Node random; Node next; Node(int val) { this.val = val; } } class Copy{ Node copy(Node head) { if (head == null) { return null; } Node cur = head; while (cur !...
java 复杂链表的复制
diu_brother的博客
03-26 1894
阿里终面在线编程题，写出来与大家分享一下有一个单向链表，每个节点都包含一个random指针，指向本链表中的某个节点或者为空， 写一个深度拷贝函数，拷贝整个链表，包括random指针。尽可能考虑可能的异常情况。算法如下：/* public class RandomListNode { int label; RandomListNode next = null; RandomL
复杂链表的复制(java)
dream_one_day的博客
08-20 187
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空） 看了剑指offer的C代码，看的我可迷了，你复制链表直接复制就好了呀，反正我是没看懂
复杂链表的复制 -- java
滕青山博客
11-16 589
题目描述 请实现函数，用于复制一个复杂链表。在复杂链表中，每个结点除了有一个next指针指向下一个结点外，还有一个sibling指向链表中的任意结点或者NULL。 复杂链表如下图： 复杂节点定义如下： public class ComplexListNode { int value; ComplexListNode next; public ComplexListNode() { } ComplexListNode sibling; public Co
复杂链表的复制（Java）
weixin_57613499的博客
10-28 184
原题链接 1新建链表（时间O（N^2） 空间O（1）） 思路来源：只有构建了完整的新链表后，才能确定每个结点的地址，才能确定next域。 源码： class Solution { public Node copyRandomList(Node head) { //1计算链表的长度 //2先建立一个与其长度相同的ramdom域的链表 //3建立两个指针确认每个结点的random域指向的结点 并把相应的信息同步到新链表中 Node cur = head;//遍历原链表的指针
java 链表复制_Java 算法 - 复制带随机指针的链表
weixin_42342206的博客
02-21 218
前段时间在做一个项目，所以没有时间做面试题，最近才将那个科创项目做的差不多了，于是开始做面试题了。题意：给出一个链表，每个节点包含一个额外增加的随机指针可以指向链表中的任何节点或空的节点。返回一个深拷贝的链表。挑战：可否使用O(1)的空间可能是好久没有做面试题了，所以手有点生疏了，这么简单的一道题，做起来都有一点费劲。1.常规解法(哈希表)(1).概述这个题用哈希表解决是非常简单的，理解起来也非常...
复杂链表的复制（java版）
05-13 2215
【题目描述】输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）【节点定义】/* public class RandomListNode { int label; RandomListNode next = null;
链表-java实现单向链表
pure111的专栏
07-18 150
      以前确实没有仔细看过链表，只知道节点中包含前后节点引用，直到有一天被人问到了，才明白自己对其理解甚少，花了点时间总结了一下，现在把结果拿出来和大家一起分享，希望得到指正。后续会有双向链表分享。   一、单向链表的结构。      (1)、首先节点的结构，其中包含本节点内容，以及需要指向下一个节点。  private static class Entry&lt;E&gt;{ ...
关于单链表的复制
weixin_45711505的博客
09-07 1159
struct LinkList { } LinkList* Tail_Create_LinkList() { LinkList H; H = new LinkList(); if(!H) { cout<<"申请空间失败"； return 0; } H->next = nullptr; cout<<"输入单链表元素（负数结束）：" LinkLIst* p,r; p = r = new LinkList(); cin>>p->da
数据结构单链表Java
最新发布
05-01
在Java中，可以使用类来实现单链表。 在单链表中，每个元素被称为节点（Node），每个节点包含两部分：数据域（存储元素的值）和指针域（指向下一个节点的指针）。最后一个节点的指针域为空。 以下是一个简单的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值