链表笔记

最新推荐文章于 2023-03-21 15:53:25 发布
最新推荐文章于 2023-03-21 15:53:25 发布
阅读量309 收藏
点赞数
分类专栏： OJ分门别类笔记汇总
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M__D_Luffy/article/details/76427629
版权

链表相关的笔记

206. Reverse Linked List

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pPre = NULL;
        ListNode* pCur = head;
        ListNode* pNext = NULL;
        while(pCur){
            pNext = pCur->next;
            pCur->next = pPre;
            pPre = pCur;
            pCur = pNext;
        }
        return pPre;
    }
};

92. Reverse Linked List II

/* 整体思路：
 * 在反转链表的基础上，记录好左侧部分和右侧部分结点，然后和局部反转后的链表拼接起来即可
 */

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if (head == NULL || m < 1 || n < m)
            return NULL;
        ListNode* dummyHead = new ListNode(-1);
        dummyHead->next = head;
        ListNode* pCur = dummyHead;
        ListNode* pPre = NULL;
        ListNode* pNext = NULL;

        // 让pCur指向m结点的前一个结点，存储为left
        for (int i = 1; i <= m - 1; ++i)
            pCur = pCur->next;

        ListNode* left = pCur;

        // pCur指向m结点
        pCur = pCur->next;
        // 反转部分的尾结点存储为right
        ListNode* right = pCur;

        // 对m到n位置的数进行反转
        // 反转后这部分头结点为pPre
        // 尾结点需要事先存储为right
        // pNext为n右侧部分的头结点
        // right -> pNext
        // pPre接上m左侧部分 left->pPre
        // pNext接上n右侧部分
        for (int i = m; i <= n; ++i){
            pNext = pCur->next;
            pCur->next = pPre;
            pPre = pCur;
            pCur = pNext;
        }

        // left -> reverse part head: pPre -> ... -> reverse part tail:right ->pNext
        left->next = pPre;
        right->next = pNext;

        return dummyHead->next;
    }
};

通过vector创建链表、打印链表、删除链表释放空间

ListNode* createLinkedList(vector<int> v){
    if (v.empty())
        return NULL;
    ListNode* head = new ListNode(v[0]);
    ListNode* pCur = head;
    for (int i = 1; i < v.size(); ++i){
        pCur->next = new ListNode(v[i]);
        pCur = pCur->next;
    }
    return head;
}

void printLinkedList(ListNode* head){
    while (head != NULL){
        cout << head->val << " -> ";
        head = head->next;
    }
    cout << "NULL" << endl;
}

void deleteLinkedList(ListNode* head){
    ListNode* pCur = head;
    while (pCur){
        ListNode* delNode = pCur;
        pCur = pCur->next;
        delete delNode;
    }
    return;
}

83. Remove Duplicates from Sorted List

/* 整体思路：
 * 当前结点和下一个结点比较，相同则删除下一个结点，否则直接滑动一个结点
 */
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL)
            return NULL;
        ListNode* pCur = head;
        while(pCur && pCur->next){
            if(pCur->val == pCur->next->val){
                ListNode* delNode = pCur->next;
                pCur->next = pCur->next->next;
                delete delNode;
            }else
                pCur = pCur->next;                
        }
        return head;
    }
};

86. Partition List

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if (head == NULL)
            return NULL;
        ListNode* pCur = head;
        ListNode* left = new ListNode(-1);
        ListNode* right = new ListNode(-1);
        ListNode* l = left;
        ListNode* r = right;
        while (pCur){
            if (pCur->val < x){
                l->next = pCur;
                l = l->next;
                //pCur_left = NULL;
            }
            else{
                r->next = pCur;
                r = r->next;
            }
            pCur = pCur->next;
        }
        // r的next指针必须置为0，因为它是right的最后一个结点
        r->next = NULL;
        l->next = right->next;
        return left->next;
    }
};

328. Odd Even Linked List

// 看看代码，画画图就懂了
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL)
            return NULL;
        ListNode* first = head;
        ListNode* second = head->next;
        ListNode* temp = second;
        while(second && second->next){
            first->next = second->next;
            first = first->next;
            second->next = first->next;
            second = second->next;
        }
        first->next = temp;
        return head;
    }
};

2. Add Two Numbers

// 处理好进位即可，尤其是最后一位为1时，不要忘记单独处理
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int jw = 0;
        int sum = 0;
        ListNode* head = new ListNode(0);
        ListNode* pCur = head;
        while(l1 || l2){
            sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + jw;
            jw = sum / 10;
            pCur->next = new ListNode(sum % 10);
            pCur = pCur->next;
            l1 = (l1 ? l1->next : l1);
            l2 = (l2 ? l2->next : l2);
        }
        if(jw)
            pCur->next = new ListNode(1);
        return head->next;
    }
};

445. Add Two Numbers II

// 整体思路：用栈即可
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<ListNode*> s1;
        stack<ListNode*> s2;
        stack<ListNode*> result;
        while(l1){
            s1.push(l1);
            l1 = l1->next;
        }
        while(l2){
            s2.push(l2);
            l2 = l2->next;
        }
        int jw = 0;
        while(!s1.empty() || !s2.empty()){
            if(!s1.empty()){
                l1 = s1.top();
                s1.pop();
            }else
                l1 = NULL;
            if(!s2.empty()){
                l2 = s2.top();
                s2.pop();
            }else
                l2 = NULL;

            int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + jw;
            jw = sum / 10;
            result.push(new ListNode(sum % 10));
        }
        // 注意最后的进位
        if(jw)
            result.push(new ListNode(1));

        // 将结果依次出栈
        ListNode* newHead = result.top();
        result.pop();
        ListNode* pCur = newHead;

        while(!result.empty()){
            pCur->next = result.top();
            result.pop();
            pCur = pCur->next;
        }
        return newHead;
    }
};

设立链表的虚拟头结点dummyHead

203. Remove Linked List Elements

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head == NULL)
            return NULL;
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* pCur = dummyHead;
        while(pCur && pCur->next){
            if(pCur->next->val == val){
                ListNode* delNode = pCur->next;
                pCur->next = pCur->next->next;
                delete delNode;
            }else
                pCur = pCur->next;
        }

        return dummyHead->next;
    }
};

82. Remove Duplicates from Sorted List II

// 用两个指针一前一后遍历
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL)
            return NULL;
        ListNode* newHead = new ListNode(0);
        newHead->next = head;
        ListNode* pCur = newHead;
        ListNode* pre = head->next;
        ListNode* behind = head;

        while(pre != NULL){
            if(pre->val != behind->val){
                pCur->next = behind;
                pCur = pCur->next;
                pre = pre->next;
                behind = behind->next;
            }else{
                while(pre && pre->val == behind->val){
                    // 直到pre为空 或者 不等于behind
                    pre = pre->next;
                }
                while(behind != pre){
                    ListNode* delNode = behind;
                    behind = behind->next;
                    delete delNode;
                }
                pCur->next = behind;
                if(pre == NULL)
                    return newHead->next;
                pre = pre->next;
            }
        }
        return newHead->next;
    }
};

21. Merge Two Sorted Lists

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* newHead = new ListNode(0);
        ListNode* pCur = newHead;
        while(l1 || l2){
            if(l1 == NULL){
                pCur->next = l2;
                break;
            }
            if(l2 == NULL){
                pCur->next = l1;
                break;
            }
            if(l1->val < l2->val){
                pCur->next = l1;
                l1 = l1->next;
                pCur = pCur->next;
            }else{
                pCur->next = l2;
                l2 = l2->next;
                pCur = pCur->next;
            }
        }
        return newHead->next;
    }
};

24. Swap Nodes in Pairs

// 实现分析好需要几个临时指针变量
// 画图分析一下指针变换顺序即可
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);
        // 指向dummyHead的指针
        ListNode* d_pCur = dummyHead;
        dummyHead->next = head;
        ListNode* pCur = head;
        // 至少两个非空结点才swap
        while (pCur && pCur->next) {
            ListNode* temp = pCur->next;
            ListNode* pNext = pCur->next;

            pCur->next = pCur->next->next;
            pNext->next = pCur;

            d_pCur->next = temp;

            d_pCur = d_pCur->next->next;
            pCur = pCur->next;

        }
        return dummyHead->next;
    }
};

25. Reverse Nodes in k-Group

147. Insertion Sort List

// 链表排序，这段代码多体会一下
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *insertionSortList(ListNode *head) {
        ListNode *sortedHead = new ListNode(-1);
        while(head != NULL){
            //保存head的下一个结点
            ListNode *temp = head->next;
            ListNode *cur = sortedHead;
            while(cur->next != NULL && cur->next->val < head->val)
                cur = cur->next;

            //插入
            head->next = cur->next;
            cur->next = head;
            //恢复head为head的下一个结点
            head = temp;
        }
        return sortedHead->next;
    }
};

148. Sort List

237. Delete Node in a Linked List

// 将后一个结点的值赋值给当前结点
// 然后删除后一个结点即可
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        if(node == NULL)
            return;
        // 题目已经强调不是尾结点, 不需要考虑
        // if(node->next == NULL)
            // do something
        node->val = node->next->val;
        ListNode* delNode = node->next;
        node->next = delNode->next;
        delete delNode;
        return;   
    }
};

双指针技术

19. Remove Nth Node From End of List

// 两个指针一前一后扫描一遍即可，其中一个指针先行
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* pre = dummyHead;
        ListNode* behind = dummyHead;

        while(n--)
            pre = pre->next;
        while(pre->next){
            pre = pre->next;
            behind = behind->next;
        }
        // behind达到待删除结点的前驱
        ListNode* delNode = behind->next;
        behind->next = delNode->next;
        delete delNode;
        return dummyHead->next;
    }
};

61. Rotate List

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (head == NULL)
            return NULL;

        // k 的大小可能大于链表的长度: 先计算链表长度，k = k % length
        ListNode* pCur = head;
        int length = 0;
        while (pCur){
            ++length;
            pCur = pCur->next;
        }
        k = k % length;

        // k如果等于0，不需要旋转
        if (k == 0)
            return head;

        // 原始链表：left_start ,..., left_end, right_start, ..., right_end
        // 旋转结果：right_start, ..., right_end, left_start, ..., left_end

        // 找到右半部分的前驱,也就是左半部分的最后一个结点left_end
        // left_start就是head，不需要寻找了
        ListNode* left_end = head;
        for (int i = 1; i < length - k; ++i){
            left_end = left_end->next;
        }
        // right_start是left_end的下一个结点
        ListNode* right_start = left_end->next;
        ListNode* right_end = right_start;
        // right_end是尾结点
        while (right_end->next != NULL)
            right_end = right_end->next;

        right_end->next = head;
        left_end->next = NULL;
        return right_start;
    }
};

143. Reorder List

// 分三步：
// 1.找到中间结点
// 2.将右半侧反转
// 3.合并两个链表
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return;

        // 找到中间结点
        ListNode* p1 = head;
        ListNode* p2 = head->next;
        while(p2 && p2->next){
            p1 = p1->next;
            p2 = p2->next->next;
        }
        ListNode* middleHead = p1->next;
        p1->next = NULL;

        // 反转middleHead开始的部分
        ListNode* pPre = NULL;
        ListNode* pCur = middleHead;
        ListNode* pNext = NULL;
        while(pCur){
            pNext = pCur->next;
            pCur->next = pPre;
            pPre = pCur;
            pCur = pNext;
        }
        middleHead = pPre;

        // 合并
        for (p1 = head, p2 = middleHead; p1; ) {
            ListNode* temp = p1->next;
            p1->next = p2;
            p1 = p2;
            p2 = temp;
        }
    }
};

234. Palindrome Linked List

// 思路：创建一个辅助栈，依次比较即可
// 此题还有空间更高效的算法：O(1)空间复杂度，O(n)时间复杂度
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        stack<ListNode*> s;
        ListNode* pCur = head;
        while(pCur){
            s.push(pCur);
            pCur = pCur->next;
        }
        pCur = head;
        while(!s.empty()){
            ListNode* temp = s.top();
            s.pop();
            if(temp->val != pCur->val)
                return false;
            pCur = pCur->next;
        }
        return true;
    }
};
西二旗的小飞飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表学习笔记
庚午步雲
08-25 1875
链表虚席笔记：从尾到头遍历链表、链表中倒数第 k 个结点、合并两个排序的链表、两个链表的第一个公共结点、链表中环的入口结点、判断链表是否是回文结构、删除单向链表中指定的结点（o(1)时间）、删除链表中相邻的重复结点（保留一个）、删除链表中重复结点（保留一个）、删除链表中相邻重复结点、复杂链表的复制
leetcode-链表笔记
02-06
本笔记将深入探讨 LeetCode 中涉及的链表相关问题，旨在帮助你理解和掌握链表的各种操作。 1. **链表的基本概念** - 链表不同于数组，它不连续存储数据，而是通过节点（Node）之间的指针链接起来。每个节点包含...
707. 设计链表
qq_43287931的博客
02-14 152
思路 考察链表的特性，添加接地点，删除节点，读节点等，重点利用虚拟节点来完成操作。 class MyLinkedList { public: // 定义链表节点结构体 struct LinkedNode { int val; LinkedNode* next; LinkedNode(int val) : val(val), next(nullptr){} }; // 初始化链表 MyLinkedList() { dummyHead = new .
java链表笔记
08-25
### Java链表基础知识详解 #### 一、链表的概念与应用 链表是一种常见的线性数据结构，不同于数组，链表中的元素不是连续存储在内存中的。每个元素（通常称为节点）都包含两部分：数据域（存储实际数据）和指针域...
C指针介绍实战链表代码笔记
最新发布
01-22
"C指针介绍实战链表代码笔记" 本文将通过一个实战的链表代码笔记，来介绍C指针的概念和应用。 一、指针的基本概念 在C语言中，指针是指向内存中某个位置的变量。指针变量的值是某个内存位置的地址。通过指针，...
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
内容概要:本文包含三道LeetCode链表算法题的刷题笔记,分别是203.移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是...
java超强笔记
12-03
随着对基础知识的掌握，笔记会进一步带你探索Java集合框架，包括数组列表、链表、队列、栈、映射等数据结构，以及它们在实际问题中的应用。此外，多线程编程也是Java的一大亮点，笔记会介绍线程的创建与同步机制，如...
链表笔记一
NITjianbagengmu的博客
10-13 252
链表搞了两个星期，说实话让我不用模板我还真写不来 创建链表 结构体 typedef struct library List; typedef struct library Position; struct library { int offical_number; char book_name[100]; int book_num; List *next; }; 链表
关于链表的笔记
qq_62898723的博客
06-28 94
关于链表
链表（学习笔记）
weixin_44109902的博客
01-11 162
一、链表 我觉得还是先把链表捋一下 1、链表的创建 //定义一个链表（结构体） typedef struct node { int num; struct node *next; } ; 创建一个链表 int creat_node(){ struct node *head,*p,*q,*t; int i,n,a; scanf("%d",&n); head =...
【学习笔记】链表学习笔记
NGB1998的博客
03-21 168
链表学习笔记
链表 学习笔记
jiangtaizhe的博客
02-06 213
文章目录板子题 板子题 约瑟夫：luogu P1145 由于约瑟夫仅仅涉及到了链表的删除，所以这里换一题： 插队
LeetCode链表算法刷题笔记：移除元素、设计链表、反转链表
本文是关于LeetCode中三道与链表相关的算法题目的刷题笔记，包括203.移除链表元素、707.设计链表和206.反转链表。主要讨论了解题思路和Java语言的解决方案。 ### 203. 移除链表元素 这道题目要求从链表中删除所有值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值