链表

最新推荐文章于 2024-06-14 09:15:00 发布
最新推荐文章于 2024-06-14 09:15:00 发布
阅读量246 收藏
点赞数
分类专栏： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenlyq/article/details/97786966
版权

一、快慢指针

与环有关、倒数第k个节点

链表中环的入口地址

思路1：慢指针p1,快指针p2，当p2!=null or p2.next!=null, p1每次走一步，p2每次走两步，当p1=p2,到达相遇点
然后p2从链表头开始，p1继续从相遇点走，以相同速度走，下次相遇时就是链表的入口
思路2：创建set，如果节点不为空，则循环，节点不在set中，则加入；在set中，说明已经循环了，为入口点，返回该节点

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        if pHead is None:
            return None
        p1=pHead
        p2=pHead
        while(p2!=None and p2.next!=None):
            p1=p1.next
            p2=p2.next.next
            if p1==p2:
                p2=pHead
                while(p1!=p2):
                    p1=p1.next
                    p2=p2.next
                if p1==p2:
                    return p1
        return None

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if(pHead==null || pHead.next==null) return null;
        ListNode p1=pHead;
        ListNode p2=pHead;
        while(p2!=null && p2.next!=null){
            p1=p1.next;
            p2=p2.next.next;
            if(p1==p2) {
                p1=pHead;
                while(p1!=p2){
                    p1=p1.next;
                    p2=p2.next;
                }
            if(p1==p2) 
                return p1;
            }
        }
        return null;
    }
}

链表中倒数第k个结点

思路一：
*两个指针fast和slow，让两个指针都指向头结点;

*让fast走(k-1)步(1~k-1)，到达第k个节点;

*两个指针同时往后移动，当fast到达末尾的时候，slow所在位置就是倒数第k个结点
注意 head为空，k<=0;以及节点.next 为空的判断

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(head==null || k<=0) return null;
        ListNode fast=head;
        ListNode slow=head;
        for(int i=1;i<=k-1;i++){
            if(fast.next!=null){//判断
                fast=fast.next;
            }
            else return null;
        }
        while(fast.next!=null){
            fast=fast.next;
            slow=slow.next;
        }
        return slow;

    }
}

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        if head==None or k<=0:
            return None
        slow=head
        fast=head
        for i in range(1,k):
            if fast.next!=None:
                fast=fast.next
            else:
                return None
        while(fast.next!=None):
            fast=fast.next
            slow=slow.next
        return slow

求链表的中间节点。

如果链表中结点总数为奇数，返回中间结点；如果结点总数是偶数，返回中间两个结点的任意一个。

 解法： 定义两个指针，同时从链表的头结点出发，一个指针一次走一步，另一个指针一次走两步。

             当走得快的指针走到链表的末尾时，走得慢的指针正好在链表的中间。

二、利用列表/HashMap/stack等存储转换

两个链表的第一个公共节点

思路1：利用列表或者hashmap
step1：遍历存入pHead1的节点，python list存值，Java hashmap存节点，
step2：然后遍历pHead2看是否在pHead1的列表（值），hashmap（节点）中

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def FindFirstCommonNode(self, pHead1, pHead2):
        # write code here
        list1=[]
        node1=pHead1
        node2=pHead2
        while node1:
            list1.append(node1.val)
            node1=node1.next
        while node2:
            if node2.val in list1:
                return node2
            else:
                node2=node2.next

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
import java.util.HashMap;
import java.util.Map;
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if (pHead1 == null || pHead2 == null) return null;
        Map<ListNode, Integer> map = new HashMap<>();
        while (pHead1 != null)
        {
            map.put(pHead1, null);
            pHead1 = pHead1.next;
        }
        while (pHead2 != null)
        {
            if (map.containsKey(pHead2)) return pHead2;
            else pHead2 = pHead2.next;
        }
        return pHead2;
    }
}

思路二：p1和p2向后移动，短的p1移到末尾，p1从长链表list2头部继续，当p2到达尾部，p2从短链表list1开始，如果能p1==p2则为第一个公共节点，没有则退出
假定：List1长度： a+n，List2长度：b+n， 且 a<b

那么，p1会先到链表尾部，这时p2走到a+n位置，将p1换成List2头部。

接着，p2 再走b+n-(n+a) =b-a步到链表尾部，这时p1也走到List2的b-a位置，还差a步就到可能的第一个公共节点。

将p2换成 List1头部，p2走a步也到可能的第一个公共节点。

如果恰好p1==p2，那么p1就是第一个公共节点。

或者p1和p2一起走n步到达列表尾部，二者没有公共节点，退出循环。

同理a>=b。

时间复杂度O(n+a+b)

public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead1==null || pHead2==null)
            return null;
        ListNode p1=pHead1;
        ListNode p2=pHead2;
        while(p1!=p2){
            p1=(p1==null)?pHead2:p1.next;
            p2=(p2==null)?pHead1:p2.next;
        }
        return p1;
    }
}

从尾到头打印链表

栈，列表反转

思路一：创建一个list，将链表值加入；然后反转输出

python
# -*- coding:utf-8 -*-
class ListNode:
     def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        resultlist=[]
        while listNode:
            resultlist.append(listNode.val)
            listNode=listNode.next
        resultlist.reverse()
        return resultlist

JAVA三种方式
思路一：利用Collections的reverse方法，类似python

import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> res = new ArrayList<>();//创建res
        while (listNode != null)//！=null
        {
            res.add(listNode.val);
            listNode = listNode.next;
        }
        Collections.reverse(res);//利用Collections对res反转
        return res;
    }
}

思路二：借助堆栈的“后进先出”实现
先将元素存入堆栈；再取出堆栈中元素存入数组列表

import java.util.ArrayList;
import java.util.Stack;
public class Solution {
        public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> nums = new Stack<>();
        while (listNode != null)
        {
            nums.push(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> res = new ArrayList<>();
        while (!nums.isEmpty())
            res.add(nums.pop());
        return res;
    }    
}

思路三：借助递归实现（递归的本质还是使用了堆栈结构）

import java.util.ArrayList;
public class Solution {

ArrayList<Integer> res = new ArrayList<>();

public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    ListNode pNode = listNode;
    if (pNode != null)
    {
        if (pNode.next != null)
            this.printListFromTailToHead(pNode.next);
        res.add(pNode.val);
    }
    return res;
}

三、链表结构更改

反转链表

思路一：非递归
*head为空时，直接返回null；

*head为当前结点，pre为当前结点的前一结点，next为当前结点的下一结点。

*pre结点可以反转指向，但反转之后如果不用next结点保存next结点的话，链表就断开了

*循环：

先用next保存下一个结点的信息，保证单链表不会因为失去head结点的原next结点而就此断裂；

保存完next，可以让head从指向next变成指向pre

head指向pre后，就继续依次反转下一个结点

让pre、head、next依次向后移动一个结点，继续下一次的指针反转。

*如果head为null的时候，pre就为最后一个结点，但是链表已经反转完毕，pre就是反转后链表的第一个结点。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if (head==null) return null;
        ListNode pre=null;//初始化对象
        ListNode next=null;
        while(head!=null){
            next=head.next;//保存head.next
            head.next=pre;//改变.next指向，反转
            pre=head;//后移
            head=next;
        }
        return pre;
    }
}

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        if pHead==None:
            return None
        pre=None//直接定义；nextnode使用时再定义；
        while(pHead):
            nextnode=pHead.next
            pHead.next=pre
            pre=pHead
            pHead=nextnode
        return pre

合并两个排序的链表

递归：注意链表为空的情况；

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        if pHead1==None:
            return pHead2
        if pHead2==None:
            return pHead1
        if pHead1.val<pHead2.val:
            res=pHead1
            res.next=self.Merge(pHead1.next,pHead2)
        else:
            res=pHead2
            res.next=self.Merge(pHead1,pHead2.next)
        return res

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null) return list2;
        if(list2==null) return list1;
        ListNode res=null;//先初始化一个res
        if(list1.val<list2.val){
            res=list1;
            res.next=Merge(list1.next,list2);
        }
        else{
            res=list2;
            res.next=Merge(list1,list2.next);
        }
        return res;
    }
}

删除链表中重复的结点

不包含重复的点
包含重复的点

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteDuplication(self, pHead):
        # write code here
        first=ListNode(-1) #创建头节点
        first.next=pHead
        pre=first #前一个节点指向头节点
        current=pHead
        while current!=None:
            duplicate=False
            while current.next!=None and current.val==current.next.val:
                current=current.next
                duplicate=True
            if duplicate==True:
                pre.next=current.next
            else:
                pre=current
            current=current.next
        return first.next #相当于新的head

public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        ListNode first=new ListNode(-1);
        first.next=pHead;
        ListNode pre=first;//指向当前确定不重复的节点
        ListNode cur=pHead;//当前节点，遍历
        while(cur!=null){
            boolean duplicate=false;
            while(cur.next!=null && cur.val==cur.next.val){
                cur=cur.next;
                duplicate=true;
            }
            if (duplicate==true) pre.next=cur.next;
            else pre=cur;
            cur=cur.next;
        }
        return first.next;

题型2：删除重复节点，留一个
pre 和current，
循环条件：current不为空 pre=current,current=current.next
当current.next!=None pre.val==current.val:
删除current ：pre.next=current.next，current后移

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteDuplication(self, pHead):
   	 	current=pHead
		pre=None
		while current!=None:
    		while current.next!=None and pre.val==current.val:#当前值与前一个相等，删除当前
        		pre.next=current.next
        		current=current.next
        	pre=current
    		current=current.next
    	return pHead
wenlyq
关注
专栏目录
静态链表
Minix的博客
03-27 2311
静态链表 静态链表（static linked list）是用数组来表示单链表，用数组元素的下标来模拟单链表的指针。这种描述方法称为游标（cursor）实现法。 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。 在链表的指针实现中有两个重要的特点： 数据存储在一组结构体中，每一个结构体包含有数据以及指向下一个结构体的指针； 一个新的结构体可以通过调用 malloc() 函数从系统全局内存得到，并可通过调用 free() 函数而被释放。 游标法必须能够模
环形链表判断
m0_46390964的博客
03-05 138
给定一个链表，判断链表中是否有环。 思路 可以将遍历过的每一个节点地址存于哈希表中，然后每一步检查该地址是否已经存在于表中。 利用快慢指针，若存在环，快指针最终会和慢指针相遇。 代码 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; ...
链表基础知识详解（非常详细简单易懂）
qq_61672347的博客
07-10 18万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C语言—链表
weixin_73588765的博客
01-01 2万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
Python链表
sikh_0529的博客
09-12 1万+
链表是一系列数据元素，通过链接连接在一起。 每个数据元素都以指针的形式包含到另一个数据元素的连接。 Python在其标准库中没有链接列表。 我们使用前一章讨论的节点概念来实现链表的概念。 我们已经知道如何创建节点类以及如何遍历节点的元素。 在本章中，将学习链表的类型:单链表。 在这种类型的数据结构中，任何两个数据元素之间只有一个链接。 创建一个链表并使用一些方法来插入，更新和从列表中移除元素。通过使用在上一章中学习的节点类来创建链表。创建一个对象并创建另一个类来使用这个节点对象。 通过节点对象传递适当的值来
反转链表详解
最新发布
Weirdo的博客
06-14 1793
这些数据项通常以链表的形式组织起来，其中最近使用的数据项位于链表的头部，最久未使用的数据项位于链表的尾部。反转链表指的是将链表的头尾节点对调，使得原本链表的第一个节点变为最后一个节点，原本链表的最后一个节点变为第一个节点，其他节点的相对位置也进行相应调整。通过对反转链表算法的深入理解和实践应用，我们可以更好地掌握链表的基本操作和指针的使用，并提高编程能力和解决问题的能力。然而，锁的使用会降低程序的性能。在实际应用中，我们可能需要在反转链表的同时进行其他操作，例如计算链表长度、检查链表中的重复元素等。
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
PTA 两个有序链表序列的合并
10-07
在编程领域，有序链表序列的合并是一个常见的问题，尤其在数据结构和算法的学习中占有重要地位。这个题目“PTA 两个有序链表序列的合并”主要涉及到链表的操作和合并策略，这对于理解和掌握链表操作有极大的帮助。...
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
【链表】是一种重要的数据结构，它不像数组那样在内存中连续存储，而是通过节点间的指针连接起来。链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也...
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
Python单向链表和双向链表原理与用法实例详解
09-20
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点之间的引用关系连接。在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只...
python线性表
wenlyq的博客
03-25 4026
顺序表 顺序表，将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示。 数据元素本身连续存储，每个元素所占的存储单元大小固定相同，元素的下标是其逻辑地址，而元素存储的物理地址（实际内存地址）可以通过存储区的起始地址Loc (e0)加上逻辑地址（第i个元素）与存储单元大小（c）的乘积计算而得，即：Loc(ei) = Loc(e0) + c*i，时间复杂度为O(1)。 如果...
51 输出单向链表中倒数第k个结点
wenlyq的博客
01-16 250
题目描述 输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。 链表结点定义如下： struct ListNode { int m_nKey; ListNode* m_pNext; }; 详细描述： 接口说明 原型： ListNode* FindKthToTail(ListNode* pListHead, unsignedint k); 输入参数： Lis...
删除链表中重复的结点
wenlyq的博客
03-29 135
题型1 删除重复的节点，重复的节点不保留 题目描述 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 需要考虑第一个节点重复的情况，所以创建一个头节点，保证头节点不会重复，头节点指向head， 两个指针，pre 和current...
链表中环的入口结点
wenlyq的博客
03-29 110
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 1：判断链表是否带环： 判断有环的方法就是用两个快慢指针p1、p2，p1的速度为P2的两倍，两个指针同时从链表的头结点开始出发，当两个结点再一次相遇且相遇点不是最后一个结点时，说明此链表有环。 2：、若有环，找环的入口： ① 当P1和P2在PM相遇时： P1走过的路程（结点数）：S快=L+X+n*R； P2走过...
链表基础与单向链表解析
"链表是一种动态数据结构，与数组相比，它允许在程序运行时根据需要增加或减少元素，克服了数组预设长度和插入删除效率低的问题。链表主要由节点组成，每个节点包含数据域和指针域，指针域指向下一个节点。单向链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值