链表的常见操作

最新推荐文章于 2022-12-26 21:17:59 发布
最新推荐文章于 2022-12-26 21:17:59 发布
阅读量213 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luodaxia_ttt/article/details/118709338
版权

文章目录


发现面试链表问的真的多。有时候面试官只让说思路，所以拿笔画一画，要能把思路捋清。

链表数据结构

class ListNode{
	int val;//节点有个值
	ListNode next;//节点有下一个节点
	ListNode(int val){//构造函数
		this.val = val;
	}
}

反转链表

思路：首先定义一个前驱节点为空，然后用一个当前指针cur指向当前节点，循环的调换方向。循环体四小步：（1）临时变量next保存当前节点cur的下一个节点；（2）当前节点cur的下一个节点指向前驱节点pre；（3）当前节点cur赋给前驱节点pre；（4）临时变量next赋给当前节点cur。

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode next = cur.next;//临时变量next保存当前节点cur的下一个节点
            cur.next = pre;//当前节点cur的下一个节点指向前驱节点pre
            pre = cur;//当前节点cur赋给前驱节点pre
            cur = next;//临时变量next赋给当前节点cur
        }
        return pre;
    }
}

LRU实现

NC93 设计LRU缓存结构
146. LRU 缓存机制
有点难！但是最近面试官好像都喜欢考。
思路：这个问题用双向链表辅助哈希表来实现。

  1. 首先自己得能写出来一个双向链表的结构。
  2. 分别定义头尾节点，并互相连接
  3. 遍历提供的操作列表，先判断是什么操作
  4. 若插入，先看看哈希表里有键值冲突：没有的话，用键值新构造一个节点，插入到链表中，并移到链表头，还要size++，再看看有没有越界，越了的话要把尾部节点删除；同时放入哈希表中。有的话，用新值代替旧值，然后移到链表头。
  5. 若读取，判断键对应的节点存不存在，存在的话读值并把节点移到头部，不存在-1.
public class Solution {
    /**
     * lru design
     * @param operators int整型二维数组 the ops
     * @param k int整型 the k
     * @return int整型一维数组
     */
    class DoubleListNode {
        int key;
        int val;
        DoubleListNode pre;
        DoubleListNode next;
        DoubleListNode() {}
        DoubleListNode(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }
    
    DoubleListNode head = new DoubleListNode(-1, -1);
    DoubleListNode tail = new DoubleListNode(-1, -1);
    HashMap<Integer, DoubleListNode> map = new HashMap<>();

    public int[] LRU (int[][] operators, int k) {
        // write code here
        ArrayList<Integer> ans = new ArrayList<>();
        head.next = tail;
        tail.pre = head;
        int size = 0;
        
        for(int i = 0; i < operators.length; i++){
            int tmp_key = operators[i][1];
            DoubleListNode node = map.get(tmp_key);
            if(operators[i][0] == 1){
                if(node == null){
                    DoubleListNode new_node = new DoubleListNode(tmp_key, operators[i][2]);
                    map.put(tmp_key, new_node);
                    add2head(new_node);
                    size++;
                    if(size > k){
                        DoubleListNode weiba = removeTail();
                        map.remove(weiba.key);
                        size--;
                    }
                }else{
                    node.val = operators[i][2];
                    add2head(node);
                }
            }else{
//                 node = map.get(tmp_key);
                if(node == null) ans.add(-1);
                else{
                    ans.add(node.val);
                    move2head(node);
                }
            }
        }
        int[] res = new int[ans.size()];
        for(int i = 0; i < ans.size(); i++){
            res[i] = ans.get(i);
        }
        return res;
    }
    
    void move2head(DoubleListNode node){
        removeNode(node);
        add2head(node);
    }

    void removeNode(DoubleListNode node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    void add2head(DoubleListNode node){
        node.pre = head;
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
    }

    DoubleListNode removeTail(){
        DoubleListNode weiba = tail.pre;
        removeNode(tail.pre);
        return weiba;
    }
}

判断链表有环

141. 判断是否有环
思路：快慢指针，只要快指针和快指针的next均不为空，就循环的让两个指针后移。一旦发现两个指针相等了，说明有环。否则循环结束必然是遇到了空，没环。

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) return true;
        }
        return false;
    }
}

142. 环形链表 II-找到入环节点
思路一：直接用hashset不重复的特点，遍历链表，什么时候add失败了或者contains方法true了，说明遇到了。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        HashSet<ListNode> set = new HashSet<>();
        ListNode cur = head;
        while(cur != null){
            if(set.contains(cur)){// or "!set.add(cur)"
                return cur;
            }
            set.add(cur);
            cur = cur.next;
        }
        return null;
    }
}

思路2：快慢指针，仔细听，首先fast和slow分别从head出发，fast跨两步，slow跨一步，等什么时候相遇了，fast走过了slow两倍的距离。
在这里插入图片描述
也就是图中x = z。那么这个时候fast回到head，slow在原位，他们同时一步一步走，正好在入口相遇。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                fast = head;
                while(fast != slow){
                    fast = fast.next;
                    slow = slow.next;
                }
                return fast;
            }
        }
        return null;
    }
}

找出两个链表的交点

160. 相交链表
思路：两条链表长度不一致，但是如果两个指针，pA先走A链表，再走B链表；pB先走B链表，再走A链表，那么等他们什么时候相遇了，便是链表相交的地方。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pA = headA;
        ListNode pB = headB;
        while(pA != pB){
            if(pA == null) pA = headB;
            else pA = pA.next;
            if(pB == null) pB = headA;
            else pB = pB.next;
        }
        return pA;
    }
}

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

找倒数那道题就pass了。
19. 删除链表的倒数第 N 个结点
思路还是快慢指针了，快指针先往后走n步，然后快慢指针同时往后走，等fast走到头了，slow也就到我们要找的那个节点了。因为要删除，还要另外用个指针指向前驱结点。为了应对删除头节点的情况，前边加个哑结点辅助返回。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode pre = new ListNode(-1);
        ListNode preNode = pre;
        pre.next = head;
        ListNode fast = head;
        ListNode slow = head;
        for(int i = 0; i < n; i++){
            fast = fast.next;
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
            pre = pre.next;
        }
        pre.next = slow.next;
        return preNode.next;
    }
}

K 个一组翻转链表

25. K 个一组翻转链表
思路：这个有点难。

  1. 定一个哑结点指向链表，辅助返回
  2. 循环的找k个节点构成一组，如果凑不足k个了，就返回
  3. 凑足了，定一个临时节点保存下一组的头结点（当前组的尾节点的next）
  4. 翻转当前组，翻转的时候尾巴会成功指向下一组的头
  5. 翻转操作类似反转链表，但要传入头尾节点，返回翻转后的头尾结点
  6. 翻转完了 前驱结点指向当前新的组
  7. 更新pre和head
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode hair = new ListNode(0);
        ListNode pre = hair;
        hair.next = head;

        while(head != null){
            ListNode tail = pre;
            for(int i = 0; i < k; i++){
                tail = tail.next;
                if(tail == null){
                    return hair.next;
                }
            }//此时 head指向第k组的头部节点，tail指向尾部节点
            
            ListNode nex = tail.next;
            ListNode[] reverse = reverseAGroup(head, tail);
            head = reverse[0];
            tail = reverse[1];
            pre.next = head;
            //tail.next = nex;
            pre = tail;
            head = tail.next;
        }
        return hair.next;
    }

    public ListNode[] reverseAGroup(ListNode head, ListNode tail){
        ListNode pre = tail.next;
        ListNode cur = head;
        while(tail != pre){
            ListNode nex = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nex;
        }
        return new ListNode[]{tail, head};
    }
}

排序链表

148.排序链表
对链表进行排序，要求时间复杂度O(nlogn)，空间复杂度O(1)。
使用归并排序。建议对比着数组的归并排序一起看。自顶向下的归并空间复杂度为O(n)，而自底向上的归并可以做到O(n)。不过可以看出链表的归并只分治了一次。

class Solution {//自顶向上
    public ListNode sortList(ListNode head) {
        return sortList(head, null);
    }
    public ListNode sortList(ListNode head, ListNode tail) {
        if (head == null) {//判断链表为空
            return head;
        }
        if (head.next == tail) {//只有一个节点
            head.next = null;
            return head;
        }
        ListNode slow = head, fast = head;//快慢指针寻找中间节点
        while (fast != tail) {
            slow = slow.next;
            fast = fast.next;
            if (fast != tail) {
                fast = fast.next;
            }
        }
        ListNode mid = slow;
        ListNode list1 = sortList(head, mid);
        ListNode list2 = sortList(mid, tail);
        ListNode sorted = merge(list1, list2);
        return sorted;
    }
    //线性合并
    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
        while (temp1 != null && temp2 != null) {
            if (temp1.val <= temp2.val) {
                temp.next = temp1;
                temp1 = temp1.next;
            } else {
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }
        if (temp1 != null) {
            temp.next = temp1;
        } else if (temp2 != null) {
            temp.next = temp2;
        }
        return dummyHead.next;
    }
}

自底向上的递归方法就是从左往右，每次对 len 个节点进行线性合并，下一轮再对 len*2 个节点线性合并。力扣讲解的很到位：
在这里插入图片描述

class Solution {//自底向上
    public ListNode sortList(ListNode head) {
        if (head == null) {
            return head;
        }
        int length = 0;
        ListNode node = head;
        while (node != null) {
            length++;
            node = node.next;
        }
        ListNode dummyHead = new ListNode(0, head);
        for (int subLength = 1; subLength < length; subLength <<= 1) {
            ListNode prev = dummyHead, curr = dummyHead.next;
            while (curr != null) {
                ListNode head1 = curr;
                for (int i = 1; i < subLength && curr.next != null; i++) {
                    curr = curr.next;
                }
                ListNode head2 = curr.next;
                curr.next = null;
                curr = head2;
                for (int i = 1; i < subLength && curr != null && curr.next != null; i++) {
                    curr = curr.next;
                }
                ListNode next = null;
                if (curr != null) {
                    next = curr.next;
                    curr.next = null;
                }
                ListNode merged = merge(head1, head2);
                prev.next = merged;
                while (prev.next != null) {
                    prev = prev.next;
                }
                curr = next;
            }
        }
        return dummyHead.next;
    }

    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
        while (temp1 != null && temp2 != null) {
            if (temp1.val <= temp2.val) {
                temp.next = temp1;
                temp1 = temp1.next;
            } else {
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }
        if (temp1 != null) {
            temp.next = temp1;
        } else if (temp2 != null) {
            temp.next = temp2;
        }
        return dummyHead.next;
    }
}
loovi7
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表1
maid_04的博客
12-05 338
设head指向一个非空单向链表， ①设数据域的值不重复，删除链表中的最大值节点。 ②设数据域的值不重复，将最大值节点移动至链表尾部。 ③设数据域的值重复，删除关键字值为key的节点。 ④设数据域的值重复且升序有序，删除链表中的重复值节点。 ⑤将一个无序链表按降序排列。 第一个的代码片段如下：elemSN * delMaxNode(elemSN *h) { elemSN *p, *q,
链表移动。
weixin_61972874的博客
06-21 855
编写一个函数，将给定的带有头结点的单向链表的前m个节点移到链尾。 结构的定义： struct node { int num; struct node *next; } 函数的原型：struct node *monenode( struct node *head,int m )， 其中：参数head 是单向链表的头指针；参数m 是要移动的节点数。函数的返回值是单向链表的头指针。...
6-1 单链表逆转
m0_55387945的博客
04-21 647
函数接口定义：List Reverse( List L ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表类型 */ 第一种： 将链表L就地旋转，不需要申请新的结点，将链表的第一个元素转为最后一个，以此类推。 ...
反转链表
BetterCbx的博客
10-22 144
给定一个链表进行反转 1->2->3->4->null null->4->3->2->1 双指针法 public ListNode reverseList2(ListNode head){ ListNode pre=null; ListNode cur=head; ListNode temp; while (cur!=null){ temp=cur.next
单链表前m项移动到末尾
weixin_50648824的博客
12-26 132
#include <stdio.h> #include <stdlib.h> typedef struct numLink { int no; struct numLink *next; } NODE; NODE *movenode(NODE *head, int m); NODE *initLink(NODE *head, int n) { NODE *temp = head; //声明一个指针指向头结点，用于遍历链表 static NODE *last = NU
Java实现链表的常见操作算法详解
08-25
主要介绍了Java实现链表的常见操作算法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
深入理解链表的各类操作详解
01-20
链表概述链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为...
C++中链表操作实例分析
01-20
　链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，...
数据结构中链表及常见操作.pdf
04-01
。
数据结构中链表及常见操作.docx
04-01
。
数据结构之单向链表（添加到尾部）
wangshuo2020的博客
01-10 688
package com.ws.链表.单向链表.添加到尾; //注意：在链表遍历时，要从头的下一个开始遍历：Node listNode=head.next; // 判断是否到链表尾时是判断当前对象当前节点是否为空，以为添加了节点，要是当前节点下一个的话，就是另一个节点了 // ，而循环时已经指向下一个节点了，这是和添加节点遍历得到链表尾时是不同的 public class LinkedList { public static void mai
将一个链表进行从尾到头的输出的三种方式
默默的笔记
08-30 2282
首先抛给大家这样一个问题，给你一个指定的ListNode,然后进行从尾到头的放入一个LinkedList并进行输出，你有什么思路吗？ public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = v...
将单链表中的第一个节点的数字复制，然后将复制好的数字添加到最后一个节点，然后返回新的链表的最后两个节点的和
CHNMSCS
10-24 920
关于单链表的知识点，小编就不在这里介绍了，这次主要是用递归的方式来完成这道题目，不用循环方式。对于刚接触的递归的同学们，看这篇文章还是没关系的，主要是理解逻辑就行了。下面是展示list.h里的代码是什么样的：//This is the list.h file#include<iostream> #include<cctype> #include<cstring>using namespace std
将链表最后一个节点移动到第一个节点位置
oy0918的博客
04-15 767
if (head->next != NULL) { Node* q = head->next; Node* p = head;//设置一个跟随节点 while (q->next != NULL) { q = q->next;//找到最后一个节点 p = p->next; } Node* first = new Node(q->id, q->score);//找一个新节点记录最后一个节点数据 p-&gt..
链表的基本操作
ybbgrain的历程
08-31 220
概述 链表是什么： 每个节点通过指针相连。 每个节点有一个前驱节点和一个后继节点（除首尾）。 节点的构造 typedef struct Node //typedef数据类型别名 { int data; //指针域 struct Node *next; //数据域 }Node,*LNode //Node相当于struct node，*LNode相当于 struct node * 创建链表 LNode Create_List(){ int.
rotate-list将单链表从右数第k个节点以及之后的节点移到链表最前头
Blessing_zf的博客
06-11 411
题目描述：Given1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULLand k =2, return4-&gt;5-&gt;1-&gt;2-&gt;3-&gt;NULL. 解题思路：第一步，将链表最后一个节点和头结点相连。 第二步，指针指向从右数第k个节点，用这个指针来确定之后返回的链表。 第三步，断开新的头结点和之前节点之间的联系。 具...
二叉树遍历非递归
a343315623的博客
05-17 443
先序遍历： public void preorderIterative() { Stack stack = new Stack(); Node p = root; if (p != null) { stack.push(p); while (!stack.empty()) { p = stack.pop(); visit(p); i
移动链表中的最大值到尾部，链表各元素位置未发生改变
qq_50798384的博客
10-02 5117
编写函数MoveMaxToTail()，实现查找单链表中值最大的结点，并将其移动到链表尾部，注意其他结点的相对次序不变。要求尽量具有较高的时间效率。 例如输入8 12 46 30 5，输出为8 12 30 5 46 1.定义结构体和宏定义类型名 #include<stdio.h> #include<stdlib.h> typedef int DataType; struct Node { DataType data; struct Node* nex
链表的操作
最新发布
05-25
链表是一种常见的线性数据结构，它由一系列节点组成，每个节点都包含一个数据元素和一个指向下一个节点的指针。链表的基本操作包括插入、删除、查找等。 1. 插入操作：插入节点时，只需要将新节点插入到链表的适当位置即可。具体实现方式如下： ``` Node* Insert(Node* head, int val) { Node* newNode = new Node(val); if (head == nullptr) return newNode; Node* cur = head; while (cur->next != nullptr) { cur = cur->next; } cur->next = newNode; return head; } ``` 2. 删除操作：删除节点时，需要先找到待删除节点的前一个节点，然后将其指针指向待删除节点的下一个节点。具体实现方式如下： ``` Node* Delete(Node* head, int val) { if (head == nullptr) return nullptr; if (head->val == val) return head->next; Node* cur = head; while (cur->next != nullptr && cur->next->val != val) { cur = cur->next; } if (cur->next != nullptr) cur->next = cur->next->next; return head; } ``` 3. 查找操作：查找节点时，只需要遍历链表，直到找到目标节点即可。具体实现方式如下： ``` Node* Search(Node* head, int val) { Node* cur = head; while (cur != nullptr && cur->val != val) { cur = cur->next; } return cur; } ``` 除了基本操作外，还有其他一些常见的操作，例如翻转链表、合并两个有序链表等。需要注意的是，在进行链表操作时，一定要注意指针的变化，以避免出现空指针异常等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值