数据结构——常见链表算法题

原创 已于 2022-08-19 10:17:56 修改 · 996 阅读 · 9 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#链表 #数据结构 #算法
于 2022-08-18 17:36:22 首次发布
本文详细介绍了8种常见的链表算法题，包括反转链表、移除重复节点、查找中间节点、找到倒数第k个节点、合并升序链表、判断环形链表、寻找两链表交点以及判断回文链表。每个问题都提供了相应的C++实现和思路解析，适合数据结构和算法学习者参考。

数据结构——常见链表算法题（C++运行）

本文介绍常见的有关链表的算法题，值得一提的是，该代码无需在力扣上，可在本地运行成功。
题目八道：
1.反转链表
2.移除链表中的重复节点
3.查找链表中的中间节点
4.找到链表中的倒数第k个节点
5.合并两个升序链表，并同样按照升序排列
6.判断是否为环形链表
7.查找两链表的交点，相交链表
8.判断是否为回文链表（空链表和单节点链表也算）

创建链表类和方法类以及打印链表方法

#include <iostream>
using namespace std;

//定义链表结构
class ListNode{
public:
    int val;
    ListNode* next;
    //结构体构造函数
    ListNode(int x);
    ListNode* listNode_create();

//默认访问权限为private   
};

ListNode::ListNode(int x=0):val(x),next(NULL)
{
}//列表初始化用法

ListNode* ListNode::listNode_create(){
    cout<<"请输入链表长度:";
    int num =0;
    cin>>num;
    int listValue=0;
    ListNode * head ;
    ListNode * tempNode;
    ListNode * node = head;
    head = NULL;
    tempNode = NULL;

    for (int i =0;i<num;i++){
        if(head == NULL){
            head = this;
            node = head;
        }else{
            node = new ListNode;
            cout<<"输入链表节点的值node->val:";
            cin>>node->val;
            tempNode->next = node;
        }
        tempNode = node;
        tempNode->next = NULL;    
    }
    cout<<"链表完成创建"<<endl;
    return head;
} 

class Solution{
    public:
        Solution();
        ListNode* reverseNode(ListNode* head);//反转链表
        ListNode* removeSameNode(ListNode* head);//移除重复链表
        ListNode* findLastKnode(ListNode* head,int k);//找出倒数第K个链表节点
        ListNode* midNode(ListNode* head);//找出链表中间节点,注意偶数时返回第一个节点和第二个节点的循环结束区别
        ListNode* mergeListNode(ListNode* list1,ListNode* list2);//两个升序链表合并成一个升序链表
        ListNode* circleListNode(ListNode* head);//找出环形列表的节点
        ListNode* findcrossingListNode1(ListNode* list1,ListNode* list2);//查找相交节点,方法一
        ListNode* findcrossingListNode2(ListNode* list1,ListNode* list2);//查找相交节点,方法二
        bool findPalindrome(ListNode* head);//判断是否为回文列表
};

Solution::Solution(){}

//打印链表
void printList(ListNode* head){
    cout<<"链表:head";
    ListNode* temp = head;
    while(temp != NULL){
        cout<<"<<"<<temp->val;
        temp = temp->next;
    }
}

//打印链表,k最大打印个数
void printList(ListNode* head,int k){
    cout<<"链表：head";
    ListNode* temp = head;
    while(temp != NULL && k>0){
        cout<<"<<"<<temp->val;
        temp = temp->next;
        k--;

    }

}

1.反转链表

思路：定义三个链表:former:存储完成反转的前一个链表，mid:正在处理的节点，latter:下一个待处理的节点。

方法：

ListNode* Solution::reverseNode(ListNode* head){
    if(head==NULL || head->next == NULL){
        return head;
    }

    ListNode* former = NULL;//保存前一个链表节点
    ListNode* mid = head;//正在处理的中间节点
    ListNode* latter = NULL;//保存下一个需要处理的节点
    while(mid != NULL){
        latter = mid->next;//保存下一个节点地址
        mid->next = former;//反转当前节点，next指向上一个链表节点
        former = mid;//former储存节点
        mid = latter;//处理下一个节点
    }
    return former;//返回节点
}

main函数：

int main(){
    
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(1);
    ListNode* node3 = new ListNode(5);
    ListNode* node4 = new ListNode(3);
    ListNode* node5 = new ListNode(1);
    ListNode* node6 = new ListNode(1);
   
    head->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node6;
	
    Solution* s = new Solution();
    //反转链表
    cout<<"原链表:";
    printList(head);
    cout<<endl<<"反转后列表:";
    head = s->reverseNode(head);
    printList(head);
    return 0;
}

在这里插入图片描述

2.移除链表中的重复节点

使用数组，第一次出现的对应数组值置，随后再遇到数组值为1的节点将其移除。“空间换时间”

方法：

ListNode* Solution::removeSameNode(ListNode* head){
    if(head == NULL||head->next == NULL){
        return head;
    }
    ListNode* cur = head;//正在识别的listnode
    ListNode* pre = head;//已经处理好的listNode
    int numIndex[10001] = {0};
    //numIndex[pre->val] = 1;
    while(cur != NULL){
        if(numIndex[cur->val] == 0){
            numIndex[cur->val] = 1;
            pre = cur;
            cur = cur->next;
            
        }else{
            pre->next = cur->next;
            cur = cur->next;
        }
    }
    return head; 
}

main函数：

int main(){
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(1);
    ListNode* node3 = new ListNode(5);
    ListNode* node4 = new ListNode(3);
    ListNode* node5 = new ListNode(1);
    ListNode* node6 = new ListNode(1);
  
    head->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node6;
    Solution* s = new Solution();
    cout<<"原链表:";
    printList(head);
    cout<<endl<<"移除重复节点后:";
    s->removeSameNode(head);
    printList(head);
    return 0;
}

在这里插入图片描述

3.查找链表中的中间节点

快慢指针，快指针走两步，慢指针走一步，最终快指针结束循环，慢指针到达中点。
注意：此处规定：为偶数，返回第二个节点，则判断条件为fast !=NULL && fast->next !=NULL;
若想要返回第一个节点则:fast->next != NULL && fast->next->next != NULL.

方法：

//找出链表中间节点,注意偶数时返回第一个节点和第二个节点的循环结束区别
//返回第二个节点:while(fast != NULL && fast->next !=NULL)
//返回第一个节点:while(fast->next != NULL && fast->next->next !=NULL)
ListNode* Solution::midNode(ListNode* head){
    ListNode* slow = head;
    ListNode* fast = head;
    if(head == NULL && head->next == NULL){
        return head;
    }
    while(fast != NULL && fast->next !=NULL){
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

main函数：

int main(){
    
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(1);
    ListNode* node3 = new ListNode(5);
    ListNode* node4 = new ListNode(3);
    ListNode* node5 = new ListNode(1);
    ListNode* node6 = new ListNode(1);
   
    head->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node6;
   
    Solution* s = new Solution();
    cout<<"原链表:";
    printList(head);

	cout<<endl<<"返回链表的中间节点:";
    ListNode* mid = s->midNode(head);
    printList(mid);
	return 0;

在这里插入图片描述

4.找到链表中的倒数第k个节点

双指针，一个指针比另一个指针快走k个节点，速度相同，最终快走的节点到头后，另一个指针所在节点为倒数第k个节点。

方法：

ListNode* Solution::findLastKnode(ListNode* head,int k){//快慢指针
    ListNode* slow = head;
    ListNode* fast = head;
    int i =0;
    for(i=0;i<k;i++){
        fast=fast->next;
    }

    while(fast!=NULL){
        fast=fast->next;
        slow=slow->next;
    }
    return slow;
}

main函数：

int main(){
    
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(1);
    ListNode* node3 = new ListNode(5);
    ListNode* node4 = new ListNode(3);
    ListNode* node5 = new ListNode(1);
    ListNode* node6 = new ListNode(1);
    
    
    head->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node6;
    //node6->next = node3;

    Solution* s = new Solution();
    cout<<"原链表:";
    printList(head);
    cout<<endl<<"返回倒数第k个链表节点:";
    ListNode* temp = s->findLastKnode(head,3);
    printList(temp);
    return 0;
}

在这里插入图片描述

5.合并两个升序链表，并同样按照升序排列

重新定义一个链表，两个链表依次比较，较小值拼接到新建链表上，若有一链表全部拼接完，直接将另一个链表（已升序排列）的剩余依次拼接到新建链表上。

方法：

ListNode* Solution::mergeListNode(ListNode* list1,ListNode* list2){
    if(list1 == NULL){
        return list2;
    }
    if(list2 == NULL){
        return list1;
    }
    ListNode* head = new ListNode();
    ListNode* cur = head;
    while(list1 != NULL && list2 != NULL){
        if(list1->val < list2->val){
            cur->next = list1;
            list1=list1->next;
        }else{
            cur->next = list2;
            list2=list2->next;
        }
        cur = cur->next;
    }
    if(list1 ==NULL){
        cur->next = list2;
    }else{
        cur->next = list1;
    }
    return head->next;//返回head的后一个链表节点
}

main函数：

int main(){ 
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(2);
    ListNode* node3 = new ListNode(3);
    ListNode* node4 = new ListNode(4);
    ListNode* node5 = new ListNode(5);
    ListNode* node6 = new ListNode(6); 
    head->next = node2;
    node2->next = node3;
    node3->next = node4;            
    Solution* s = new Solution();
    ListNode* head2 = new ListNode(0);
    head2->next = node5;
    node5->next = node6;
    
    cout<<"原链表list1:";
    printList(head);
    cout<<"原链表list2:";
    printList(head2);

	cout<<endl<<"返回合并后的链表:";
    ListNode* mergeNode = s->mergeListNode(head,head2);
    printList(mergeNode);
	return 0；
}

6.判断是否为环形链表

在这里插入图片描述
快慢指针思路

方法：

//找出环形链表的节点,快慢指针，有环则返回环节点，无环则返回NULL
ListNode* Solution::circleListNode(ListNode* head){
    ListNode* fast = head;
    ListNode* slow = head;
    while(fast !=NULL && fast->next != NULL){
        fast=fast->next->next;
        slow=slow->next;
        if(slow == fast){
            fast = head;
            while(fast != slow){
                fast = fast->next;
                slow = slow->next;
            }
            return slow;
        }
    }
    return NULL;
}

main函数：

int main(){
    
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(2);
    ListNode* node3 = new ListNode(3);
    ListNode* node4 = new ListNode(4);
    ListNode* node5 = new ListNode(5);
    ListNode* node6 = new ListNode(6);
   
    head->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node6;
    node6->next = node3;
	Solution* s = new Solution();
    cout<<"原链表list1:";
    printList(head,10);
	cout<<endl<<"返回环形后的链表:";
    ListNode* circlehead = s->circleListNode(head);
    printList(circlehead,10);
    return 0;
}

7.查找两链表的交点，相交链表

//查找相交节点,方法一，a+c+b=d+c+b;最后相较于交点
 ListNode* Solution::findcrossingListNode1(ListNode* list1,ListNode* list2){
    ListNode* p=list1;
    ListNode* q=list2;
    while(p !=q){
        if(p==NULL){
            p = list2;
        }else{
            p = p->next;
        }
        if(q == NULL){
            q = list1;
        }else{
            q = q->next;
        }
    }
    return q;
}

//查找相交节点，方法二，迭代法
ListNode* Solution::findcrossingListNode2(ListNode* list1,ListNode* list2){
    ListNode* p=list1;
    ListNode* q=list2;
    while(p !=NULL){
        q=list2;
        while(q !=NULL){
            if(p == q){
                return p;
            }
            q=q->next;
        }
        p = p->next;
    }
    return p;
}

main函数：

int main(){
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(2);
    ListNode* node3 = new ListNode(3);
    ListNode* node4 = new ListNode(4);
    ListNode* node5 = new ListNode(5);
    ListNode* node6 = new ListNode(6);
    
    head->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node6;
    Solution* s = new Solution();
    ListNode* head2 = new ListNode(0);
    head2->next = node3;
    cout<<"原链表list1:";
    printList(head);
    cout<<"原链表list2:";
    printList(head2);

	cout<<endl<<"返回交点节点:";
    ListNode* crossingNode = s->findcrossingListNode1(head,head2);//方法一
    //ListNode* crossingNode = s->findcrossingListNode2(head,head2);//方法二
    printList(crossingNode);
    return 0;
}

在这里插入图片描述

8.判断是否为回文链表（空链表和单节点链表也算）

提取中间节点，反转链表，再比较是否相等

//判断是否为回文列表：先取中间节点（如为偶数取第二个），然后链表反转，最后判断前面链表是否与后面链表相同
bool Solution::findPalindrome(ListNode* head){
    ListNode* list1 = head;
    ListNode* list2 = head;
    //if判断语句可有可无，不影响结果输出
    if(head==NULL || head->next == NULL){
        return true;
    }
    
    //去链表中间节点
    while(list1 != NULL && list1->next != NULL){
        list1 = list1->next->next;
        list2 = list2->next;
    }

    //反转链表
    ListNode* former = NULL;
    ListNode* mid = list2;
    ListNode* latter = NULL;

    while(mid !=NULL){
        latter = mid->next;
        mid->next = former;
        former = mid;
        mid = latter;
    }

    list1 = head;

    while((former !=NULL) &&(list1 !=NULL)){
        if(former->val != list1->val){
            return false;
        }
        former = former->next;
        list1 = list1->next;
    }
    return true;
}

main函数：

int main(){
    ListNode* head = new ListNode(1);
    ListNode* node2 = new ListNode(2);
    ListNode* node3 = new ListNode(3);
    ListNode* node4 = new ListNode(3);
    ListNode* node5 = new ListNode(2);
    ListNode* node6 = new ListNode(1);
    head->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node6;
	Solution* s = new Solution();
    cout<<"原链表:";
    printList(head);
    //判断是否为回文链表
    bool palindromeFlag = s-> findPalindrome(head);//空链表和只有一个节点的链表也为回文链表
    if(palindromeFlag == true){
        cout<<"该链表为回文链表";
    }else{
        cout<<"该链表不为回文链表";
    } 
    return 0;
}

在这里插入图片描述

链表的经典算法题详细解析
m0_74234485的博客
02-24 2212
线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
【数据结构】链表经典算法题集锦
热门推荐
林慢慢的博客
09-12 1万+
前言：本章将分享十一道来自LeetCode/牛客网中的经典链表算法题来介绍数据结构中链表在算法题中的应用。 文章目录1.删除链表元素思路分析：题解：2.反转链表思路分析：题解：3.链表中间结点思路分析（快慢指针法）：题解：4.链表中倒数第K个结点思路分析（快慢指针法）：题解：5.合并两个有序链表思路分析：题解：6.链表分割思路分析：题解：7.链表的回文结构(第2题和第3题的综合)思路分析：题解：8.相交链表思路分析：题解：9.环形链表I思路分析：题解：10.环形链表II思路分析：题解：11.复制带随机指针
算法题目---链表
最新发布
2403_89229523的博客
04-21 222
对于做链表的题目，具体有以下技巧1.画图。可以更直观和形象2.引入“虚拟头节点”。这要回可以少判断很多条件，并且头插的时候更方便3.不要吝啬空间，直接去定义4.使用快慢双指针的思想来解决链表问题5.链表中的常用操作①.创建新的节点我们直接new就可以了②.尾插③.头插这时候就体现出创建虚拟头节点的作用来了适合用于“逆序链表”
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 7130
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
“手撕“9道经典链表算法题
ha2042894194的博客
07-01 1944
在学完单链表（单向不带头不循环）和双向链表(双向带头循环)后我们会发现双向链表虽然结构略微复杂，但实现相同功能时相较于单链表方便了不止一星半点。
链表经典算法题
Frank的博客
10-03 1974
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
数据结构 - 链表 - 面试中常见的链表算法题
从零开始
01-17 4389
数据结构 - 链表 - 面试中常见的链表算法题 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍线性表中的常见的链表数据结构。包括 概念简介 链表节点的数据结构（Java） 常见的链表算法题（Java）。 概念简介 如果对链表概念已经基本掌握，可以跳过该部
【Java数据结构-链表】常见链表OJ算法题
2202_75560428的博客
03-29 1123
链表的经典OJ面试题
数据结构常见算法题总结1-链表
shangjg3的博客
07-27 450
node1 节点先跑，node1 节点 跑到第 n+1 个节点的时候,node2 节点开始跑.当 node1 节点跑到最后一个节点时，node2 节点所在的位置就是第 （L - n ） 个节点（L 代表总链表长度，也就是倒数第 n + 1 个节点）首先两个节点/指针，一个节点 node1 先开始跑，指针 node1 跑到 k-1 个节点后，另一个节点 node2 开始跑，当 node1 跑到最后时，node2 所指的节点就是倒数第 k 个节点也就是正数第(L-K+1)个节点。将两数相加返回一个新的链表。
一文搞懂链表
FIRE-Lee的博客
09-11 282
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。本文详细介绍链表的基本原理、实现及经典算法题题解。（Swift实现）
算法理解（三）链表
qq_51292909的博客
09-01 1412
ListNodeLinkedList在Java中，链表的实现和算法题考察与其他语言类似，都是通过节点类和链表类的组合来实现各种操作。在编程面试中，链表题目主要考察指针操作、链表结构的理解和掌握。熟悉基本的链表操作和算法，可以帮助应对各种链表相关的算法题。
链表一（基本概念和应用场景）+ 链表常见算法题
qq_20770569的博客
07-10 1368
链表是一种常用的数据结构，它在内存中是非连续存储的，每个元素（称为节点）包含数据和一个指针，这个指针指向链表中的下一个节点。链表的主要优点是插入和删除操作不需要移动大量元素，这与数组形成对比，数组在进行插入或删除时可能需要移动多个元素来保持连续性。
C++ 链表、栈、队列
weixin_40535588的博客
12-05 5014
一、C++ 链表 链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的， 且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 1.1 几种链表的介绍 1.1.1 单向链表 单向链表很容易理解，就说把指针当成一条链一样连接每一个节点，每个节点包含了一个或者多个数据。链表的存储单元不一定是连续的，长度不固定，主要用于方便实现节点的插入和删除操作。官方的话这里就不说了，作为数据结构里最基本的，感兴趣的童鞋自.
数组模拟常见数据结构
m0_73096566的博客
03-01 1111
数组模拟常见数据结构(C/C++)
常见面试算法题
y_chengbo的博客
09-16 440
常见面试算法题 1. 判断链表是否有环 快慢指针法 import jianzhiOffer.ListNode; //判断链表是否有环 public class HasCycle { public boolean hasCycle(ListNode head){ /快慢指针法/ if (head == null){ return false; } ListNode slowPoint = head; ListNode fastPoint = head.next;
数据结构：双向链表（1~2）
2401_86982201的博客
11-19 2166
本文深入讲解了双向链表的概念与实现，对比分析了顺序表与链表的优缺点，并提供了链表相关算法题的解题思路。 文章首先介绍了双向链表的结构特点：每个节点包含前驱和后继指针，支持双向遍历和高效的插入删除操作。详细讲解了带头双向循环链表的实现方法，包括初始化、尾插、头插、尾删、头删、销毁等核心操作的代码实现和逻辑分析。 在顺序表与链表的对比部分，文章指出顺序表适合频繁随机访问的场景，而链表更适合数据动态变化的场景。最后通过"移除链表元素"和"反转链表"两个经典算法题，展示了链表
【C语言—数据结构—算法题】
zhangzhiqi1100的博客
10-27 600
判断是否为回文结构，我们可以找到中间节点，将中间节点即以后的节点进行倒置，然后将原链表的头节点与倒置后的头节点进行逐一比较，如果链表总个数为奇数，则循环结束条件是原链表走到空，如果链表总个数是偶数，则循环结束条件是两个链表一起走到空。我们可以用快慢指针，慢指针一次走一步，快指针一次走两步，如果是环形链表的话快指针先进入循环，然后一直在环形链表中走，直到快指针遇到慢指针证明链表是环形链表。首先我们可以判断两个链表是否相交：遍历两个链表，如果最后一个节点一样就说明两者相交，反之则不相交。
数据结构 | 深入理解顺序表与链表
TTKunn的博客
09-10 1887
本文主要讲解深入理解顺序表与链表相关内容
写出一段代码将链表中的两个节点位置互换位置_动画学数据结构：轻松掌握链表
weixin_39820185的博客
12-04 537
在上篇文章中我们主要介绍了数组和字符串，详情点击查看力扣（LeetCode）：动画学数据结构：轻松掌握数组和字符串​zhuanlan.zhihu.com本篇文章主要介绍链表。链表是一种特殊的线性结构，由于不能像数组一样进行随机的访问，所以和链表相关的问题有他自身的特点；在面试中也是非常容易考到的题目，一般代码比较短，而且能够考查面试者的思维全面性和写无 bug 代码的能力。在写链表的题目时，建议画...
【数据结构c++】（学习笔记分享）链表（单向链表、双向链表、循环链表、链表相关算法题）
SlashYe的博客
10-31 593
学习笔记，部分内容参考网络教学视频，题目来源Leetcode，侵删。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值