数据结构2：链表

最新推荐文章于 2024-07-12 23:24:36 发布
最新推荐文章于 2024-07-12 23:24:36 发布
阅读量249 收藏
点赞数
分类专栏： 数据结构 找一份好工作 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wbzhang233/article/details/104902150
版权

1.链表

1.1 链表节点定义

链表形式如下，其中int可换成其余数据类型；包含当前节点值和下一节点的指针。

struct ListNode {
	int val;
	ListNode *next;
	ListNode() : val(0), next(nullptr) {}
	ListNode(int x) : val(x), next(nullptr) {}
	ListNode(int x, ListNode *next) : val(x), next(next) {}
};

1.2 思想与技巧总结

核心思想：
递归，分治

必会技巧：

  • 快慢指针（可用于寻找中点，判断相交、环形链表）
  • 一指针先走K步（用于解决倒数第k个节点）
  • 链表截断
  • 双指针：同数组中的操作（如：用于解决去重复问题）
  • 局部反转链表（pre,cur,tmp保存next）
  • 递归：寻找当前状态和子问题
  • 分治：归并排序链表

2.基础题目

2.1 二进制链表转整数 easy

int getDecimalValue(ListNode* head) {
    ListNode *cur=head;
    int res = 0;
    while(cur!=nullptr){
        res = 2*res+cur->val;
        cur= cur->next;
    }
    return res;
}

解法2
re表示结果，初始化为0
取出节点数据，与re左移一位的结果按位或(左移后补０，不会出现同为１的情况，所以是可行的)
移动到下一个节点。
重点：位运算，result<<1就相当于result*2,result|=1（result|=0）相当于result++（不变）
得总结一下位运算！！

int getDecimalValue(ListNode* head) {
    ListNode *tmp = head;
    int res = 0;
    while (tmp != nullptr) {
        res = (res << 1) | (tmp->val); 
        // 以上为装13的写法，但位操作速度确实更快...等同于
        // res = 2*res + tmp->val; 
        tmp = tmp->next;
    }
    return res;
}

2.2 合并两个有序链表 easy

递归
比较当前待合并的两个链表l1和l2的头结点的值，使得较小的指向除了该节点外的两个链表合并之后的链表，重复以上过程，直到某个链表走到尽头，此时返回另一链表

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == NULL) {
            return l2;
        }
        if (l2 == NULL) {
            return l1;
        }
        if (l1->val <= l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        l2->next = mergeTwoLists(l1, l2->next);
        return l2;
    }

2.3 回文链表

在这里插入图片描述

基础技巧2：快慢指针寻找链表的中间节点。
注意：快慢指针初始化时，slow=head并且fast=head->next

class Solution {
public:
    // 常规解法：用栈进行反转
    bool isPalindrome(ListNode* head) {
        // 特判
        if(!head || !head->next) return true;

        // 寻找链表的中间节点
        ListNode *slow = head,*fast = head->next;
        while(fast!=NULL && fast->next!=NULL)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        // 截断
        ListNode *rhead= slow->next;
        slow->next = nullptr;
        cout<<"rhead: "<<rhead->val<<endl;

        // 后半部分入栈
        stack<int> st;
        while( rhead!=NULL){
            st.push(rhead->val);
            rhead = rhead->next;
        }

        // 判断
        while(head!=nullptr && !st.empty() ){
            if(head->val != st.top() ) return false;
            head = head->next;
            st.pop();
        }
        return true;
    }
    // 进阶解法：反转链表进行比对
    
};

2.4 链表的倒数第K个节点 easy

基础技巧3：让一个指针先走k步

略。

2.5 环形链表 easy

1）哈希集法
简单粗暴，以节点指针为哈希集类型。遍历链表，当前节点未在哈希集中出现时，插入该节点，直到当前节点走到链表尾端，表明无环，否则必然指向哈希集中的节点，表明有环。
2）快慢指针法：采用low和fast双指针，fast步进为2，low步进为1
当链表无环时，fast应该率先到达终点，此时fast指向空指针，表明无环则退出；
链表存在环时：fast比low率先入环，设low入环后两者之间距离为k，则k步后fast必然追上low，此时判定有环
因此采用while循环，当fast==low时退出表明有环，否则在fast指向空指针时返回false表明无环

代码先不给了，当做课后复习作业，有空再自己补上。

// 1-哈希集法

// 2-双指针法

2.6 移除链表元素 easy

实在是对链表的基本操作不太熟悉，记录一下一些基本操作。
这题看似很简答，但确实主要难度在于链表头部存在待删除串时，问题将变得很棘手

官方解答：

  • 初始化哨兵节点作为伪头，即定义一个哨兵节点指向head
  • 双指针：取连续两个节点的指针prev和curr，分别指向哨兵节点和head，
  • 当curr节点不为nullptr时
    • 如果curr节点的值待删除时，将prev指向其下一节点。
  • 删除该删除的节点，返回哨兵节点的下一节点
  ListNode* removeElements(ListNode* head, int val) {
    ListNode* sentinel = new ListNode(0);
    sentinel->next = head;

    ListNode *prev = sentinel, *curr = head, *toDelete = nullptr;
    while (curr != nullptr) {
      if (curr->val == val) {
        prev->next = curr->next;
        toDelete = curr;
      } else prev = curr;

      curr = curr->next;

      if (toDelete != nullptr) {
        delete toDelete;
        toDelete = nullptr;
      }
    }

    ListNode *ret = sentinel->next;
    delete sentinel;
    return ret;
  }

2.7 反转链表 easy

三指针法：
定义两个指针： pre 和 cur ；pre 在前 cur 在后。

  • 每次让 pre 的 next 指向 cur ，实现一次局部反转
  • 局部反转完成之后， pre 和 cur 同时往前移动一个位置
  • 循环上述过程，直至 pre 到达链表尾部
ListNode* reverseList(ListNode* head) {
    ListNode* cur = NULL, *pre = head;
	
	// 实际上当前节点为pre，cur为辅助的'前一节点'；初始值为空
    while (pre != NULL) {
        ListNode* t = pre->next;//用于保存前节点的下一节点指针
        pre->next = cur; //pre指向指向cur，第一次为指向空节点
        
        cur = pre; //cur移动到pre
        pre = t; //pre位置移动到上一次pre的下一节点
    }
    return cur;
}

递归：让当前节点的下一个节点指向当前节点；并且当前节点指向空节点；

ListNode* reverseList(ListNode* head) {
    if(head==NULL || head->next==NULL)  return head;
    ListNode* ptr=reverseList(head->next);
    head->next->next=head;
    head->next=NULL;
    
    return ptr;
}

2.8 相交链表 easy

刷过leetcode的人应该都知道两个正确的人走上对方的路终究会长长久久的在一起。（酸了）
但是，如果给的是两条不相交的链表，犹如两条平行铁轨，永远不会相交。此时，仅仅需要在某个指针第2次走到链表端点时进行判断即可。
理由是：如果两条链表相交，那么在指针A第一次走到链表1尽头时，从链表2开头继续走，当走到了链表2的尽头时，此时，另一个指针B应当走到了链表1的尽头。消除了长度差之后，之后会一直相等。

在这里插入图片描述

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    if(headA==NULL || headB==NULL) return NULL;

    ListNode* pA = headA;
    ListNode* pB = headB;
    int count = 0;
    while(pA!=pB){
        pA = pA->next==NULL?headB:pA->next;
        pB = pB->next==NULL?headA:pB->next;
        count = pA->next==NULL?count+1:count;
        if(count==2) break;
    }

    if(count==2 && pA!=pB){
        return NULL;
    }

    return pA;        
}

2.10 排序链表 middle

在这里插入图片描述
基础技巧：归并排序，递归分治

class Solution {
public:

    ListNode* mergeTwoLists(ListNode* la,ListNode* lb){
        if(la==NULL) return lb;
        if(lb==NULL) return la;
        if(la->val < lb->val){
            la->next = mergeTwoLists(la->next,lb);
            return la;
        }
        lb->next = mergeTwoLists(la,lb->next);
        return lb;
    }

    // 归并排序
    // 寻找链表中间节点，分治分别排序，归并
    ListNode* sortList(ListNode* head) {
        // 特判
        if(!head || !head->next) return head;

        // 快慢指针做分割
        ListNode *slow = head,*fast = head->next;
        while(fast!=NULL && fast->next!=NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        // 截断
        ListNode *rhead = slow->next;
        cout<<"rhead: "<<rhead->val<<endl;
        slow->next = nullptr;
         
        // 递归分治
        return mergeTwoLists(sortList(head),sortList(rhead) );
    }


};

2.11 对链表进行插入排序

3.痛定思痛0928

写在此处：该帖子最早写于3月份，半年前那时候刚开始看数据结构和算法。
0928惨遭美团后台面试滑铁卢，被一道并不难的链表题整蒙了，痛定思痛，提笔再刷一些链表题。

3.1 合并K个升序链表 hard

原题来自leetcode No.23

思路：参考2.2 合并两个有序链表，采用分治思想合并一组有序链表即可。

代码如下：

//
// Created by wbzhang on 2020/9/29.
// 合并K个有序链表 leetcode No.23

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */

class Solution {
public:
	// 合并两个有序链表
	ListNode* mergeTwolists(ListNode* la,ListNode* lb){
		if(la==nullptr) return lb;
		if(lb==nullptr) return la;

		if(la->val < lb->val){
			la->next = mergeTwolists(la->next,lb);
			return la;
		}
		lb->next = mergeTwolists(la,lb->next);
		return lb;
	}

	// 分治合并(闭区间)
	ListNode* merge(vector<ListNode*>& lists ,int low,int high)
	{
		if(low == high) return lists[low];
		if(low >high) return NULL;

		int mid = low + (high-low)/2;
		ListNode* left =  merge(lists,low,mid); // 分治合并
		ListNode* right =  merge(lists,mid+1,high); // 分治合并

		return mergeTwolists(left,right);
	}

	// 合并K个有序链表
	ListNode* mergeKLists(vector<ListNode*>& lists) {
		return merge(lists,0,lists.size()-1 );
	}

};

3.2 旋转链表 middle

原题：leetcode No.61

直接看我题解：题解No.61
差分成两道简单题：

  1. 递归确定链表长度
  2. 寻找链表的倒数第K个节点

代码如下：

class Solution {
public:

    // 递归：求链表的长度
    int getListLength(ListNode* head)
    {
        if(!head) return 0;
        return getListLength(head->next)+1;
    }

    ListNode* rotateRight(ListNode* head, int k) {
        // 特判，考虑k的范围；k有可能大于链表长度
        if(!head || !head->next) return head;

        int len = getListLength(head);
        k = k%len; // 旋转 k%len步
        if(k==0) return head;

        // 寻找倒数第K个节点
        ListNode *slow = head, *fast = head;
        while(fast!=NULL && k>0){
            fast= fast->next;
            --k;
        }
        while(fast->next!=NULL){
            slow = slow->next;
            fast = fast->next;
        }

        // 在slow出切断
        ListNode* res_head = slow->next;
        fast->next = head;
        slow->next = NULL;
        return res_head;
    }
};

3.3 K个一组反转链表 hard

原题来自leetcode No.25

截断链表，反转链表，递归

//
// Created by wbzhang on 2020/9/29.
// leetcode No.25 K个一组反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
	// 获取链表长度
	int getListLength(ListNode* head)
	{
		if(!head) return 0;
		return getListLength(head->next)+1;
	}

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

	// 局部反转该链表
	ListNode* reverseList(ListNode* head)
	{
		ListNode *pre = NULL,*curr = head;
		while(curr!=NULL){
			ListNode* tmp = curr->next;
			curr->next = pre;
			pre = curr;
			curr = tmp;
		}
		return pre;
	}

	ListNode* reverseKGroup(ListNode* head, int k) {
		// 特判
		int len = getListLength(head);
		if(k>len) return head; //k>len则不旋转
		if(k==len) return reverseList(head);

		// 找到第k个节点，并且切断，将后续翻转...（直到个数不足以反转位置）
		ListNode* kthNode = head;
		// k==1，则为本身，k=2，则往后移动一次
		while(k>1){
			kthNode = kthNode->next;
			--k;
		}
		cout<<"kth: "<<kthNode->val<<endl;
		// 切断
		ListNode* kNext = kthNode->next;
		cout<<"kNext: "<<kNext->val<<endl;
		kthNode->next = NULL;

		// 打印前k个节点
		cout<<"print..."<<endl;
		printList(head);
		cout<<endl;
		printList(kNext);

		ListNode* resHead = reverseList(head); // 反转前k个节点
		cout<<"print after..."<<endl;
		printList(resHead);

		cout<<"digui..."<<endl;
		kNext = reverseKGroup(kNext,k); //递归反转后半部分
		printList(kNext);

		head->next = kNext; // 反转前k个之后head为末尾
		return resHead;
	}
};

3.4 反转链表2 middle

原题leetcode No.92
在这里插入图片描述

此题需要用的指针稍微多一些…
注意特判！
思路：切成三段（n不在末尾）l1,l2,l3 ，得到l1尾部，l2头部(即第m个)，l2尾部(即第n-1个)，l3头部(即第n个)…
采用双指针pre,cur
先找到第m个节点，然后对m-n之间进行局部反转（同反转链表），然后处理连接问题。

3.5 重排链表 middle

原题leetcode No.143

我的题解：
1）快慢指针寻找链表中间节点，从中间节点截断
2）使用栈存储后半段（其实亦可以用反转链表）
3）随后进行拼接…

class Solution {
public:
    void reorderList(ListNode* head) {
        // 特判
        if(!head) return;

        // 寻找链表中点，进行切断
        ListNode *slow = head,*fast = head;
        while(fast!=NULL && fast->next!=NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode *rightHead = slow->next;
        slow->next = NULL;

        // 使用栈存储后半部分
        stack<ListNode*> st;
        while(rightHead!=NULL){
            st.push(rightHead);
            rightHead = rightHead->next;
        } 
        cout<<"st_size: "<<st.size()<<endl;

        // 前后合并两部分
        // ListNode* dummyNode = new ListNode(-1);
        // dummyNode->next = head;
        ListNode *cur = head;
        // ListNode *resCur = dummyNode ;

        while(cur!=NULL && !st.empty() ){
            ListNode* tmp = cur->next;
            cur->next = st.top();
            st.pop();
            cur->next->next = tmp;
            cur = tmp;
        }

    }
};
wbzhang233
关注
专栏目录
【数据结构0】数据结构概述
Wu_Being 的CSDN 博客
12-27 1376
数据结构：相互之间存在一种或多种特定关系的数据元素的集合。包括三方面：逻辑结构、存储结构和数据运算。
链表各类操作详解
计科菜鸟的天地.
06-23 574
看了这个才发现自己和别人的差距......但是自己慢慢努力吧 链表概述 　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又
链表的平行指针
August-us的博客
02-20 1万+
链表的平行指针
数据结构之链表（单链表，双链表）知识汇总（包含面试题）
wujianrenn的博客
12-06 2101
一.链表总体介绍： 1.单链表：（single linked list） 每个链表有一个next指针指向下一个节点，还有一个成员用来存储数值 2.双链表：（Douuble Linked List） 在单链表基础之上，还有一个prev指针指向前一个节点。 3.小结： （1）链表是以节点的方式来存储 （2）每个节点包含data域，next域：指向下一个节点 （3）链表的每个节点都不是连续存储的 （4）链表分有头节点的和不带头节点的，根据实际需求来定 第一个节点的data域为nul..
c++数据结构：链表
qq_45303986的博客
10-13 5935
用一组任意的存储单元存储线性表的数据元素（这些存储单元可以是连续的，也可以是不连续的）
JS 数据结构：链表
weixin_46015333的博客
11-24 4254
本文介绍了什么是链表以及他的优缺点，并分别介绍了单链表、双向链表和循环链表之间的细微差别和各自的特点，一些有明显差异的操作都分别给出了图和代码，更易于理解和实践。
数据结构：链表及其C++实现
热门推荐
forGemini的博客
05-26 1万+
前言 链表是一种非常非常基础的数据结构，本文首先讲解链表的基础知识，然后使用C++的模板实现了一个链表类，并简单实现了常见的插入、删除、查找等算法。 阅读本文需要对C/C++的指针具有一定的了解。 基础知识 链表是一种逻辑上连续，内存上分散的线性表数据结构，其基本单位为结点，每个结点分数据区和指针区，数据区用于存放数据，指针区则用于指向其他结点，通过指针每个结点就被串接成了一条“链子”。
数据结构：链表详解 (c++实现)
weixin_73162565的博客
07-12 2062
本文用通俗的语言加上图片展现的形式详细讲解链表，并且附上 C++ 实现代码。
数据结构：链表的基本用法（逆置）
study_jiang_up的博客
11-17 3051
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
C++(数据结构)：链表
最新发布
08-03
C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 ...
数据结构：链表.ppt
09-17
链表数据结构 链表是一种基本的数据结构，它是一种线性表的链接存储表示。链表的每个元素（结点）由结点（Node）构成，每个结点包含数据域和链域，链域指向下一个结点。链表的特点是每个元素可以连续或不连续存储，...
数据结构：链表的合并与直接插入排序
04-03
本人数据结构课设题目：《链表的合并与直接插入排序》
数据结构课设一：链表实现大数相加
04-24
在这个课设“数据结构课设一：链表实现大数相加”中，我们主要关注的是链表这一基本数据结构以及如何利用它来解决实际问题，即进行大数的相加运算。 链表是一种线性数据结构，与数组不同，它不连续存储元素，而是...
swift代码-Swift数据结构: 链表(Linked List)
07-14
链表是一种重要的数据结构，它的实现方式与数组不同，它不连续存储元素，而是通过节点之间的引用链接来存储。本篇文章将深入探讨Swift中的链表（Linked List）及其相关知识点。 ### 链表的基本概念 链表由一系列...
数据结构之——链表
xqx_999的博客
10-06 4891
链表的介绍，单链表和双向链表的接口实现。
20200417字节跳动后端视频面经
wbzhang233的博客
04-19 1628
1.概况 20200417下午两点，牛客网视频面试 emmm，面试官是个比较年轻的小火鸡，此人一看便是个技术宅。 1）首先，做自我介绍 然后我说到一个项目时，他会深入的问具体做了哪些工作… 我说到视觉导航和传统的图像处理时，他会问我具体的内容，以及是否是自己设计…不过此人更偏向于计算机科班出身，对图像和自动化这一块不太了解，就没深挖。 我介绍IARC比赛时，里面的细节同样会细问，不过这些都能答上...
20200403阿里算法岗暑期实习
wbzhang233的博客
04-03 1056
铩羽而归。写点儿血泪教训。 1.总结 阿里巴巴暑期实习 算法岗笔试一共就两道题，每道50分。具体的题目我没截屏，网上应该能找到。第一题是比较简单的数组，第二题应该要用算法来做，我接触的少，此题一看遍蒙圈了。 题目如下： 1）求特定数的个数 符合以下条件的数为题目定义的特定数： 1）该数左边存在比其大的数，并且左边比该数大的数中的最小数为f 2）该数右边存在比其小的数，并且右边比该数小的数中的...
猿辅导真题刷题备战
wbzhang233的博客
07-25 877
2020猿辅导真题刷题备战 1.常见题目 2.编程题 2.1 击鼓传花 他人题解 2.2 小猿的迷宫之旅 解题思路：DFS算法 他人的题解如下：https://blog.csdn.net/qq_34847754/article/details/98387599 2.3 解压字符串 题解 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值