LeeCode-数据结构-day7-链表-CSDN博客

本文链接：https://blog.csdn.net/qq_41940001/article/details/128248238

day7-链表

1、环形链表

描述

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。 

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：
链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 有效索引 。

进阶：你能用 O(1)（即，常量）内存解决此问题吗？

思路

两个指针，差值遍历

代码

#include <iostream>
using namespace std;
#include <vector>

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

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *p;
        ListNode *pp;
        p = head;
        pp = head;
        printf("   hasCycle   %d  head %d\n",head->val,head);
        while(p) {
            p = p->next;
            if(!pp->next || !pp->next->next)    break;
            pp = pp->next->next;
            printf("p-> val  %d\tpp -> val  %d\tp == pp  %d\tp -> val == pp -> val  %d\n",
                            p->val,pp->val,(p==pp),(p->val == pp->val));
            if(pp == p)     return true;
        }
        return false;
    }
};

int main() {
    ListNode *head = new ListNode(0);
    ListNode *p;
    vector<int> num = {};
    int pos = -1;
    p = head;
    for(int i = 0; i < num.size(); i++) {
        ListNode *tmp = new ListNode(num[i]);
        cout << num[i] << endl;
        p->next = tmp;
        p = p->next;
    }
    ListNode *t;
    t = head;
    for(int i = 0; i < num.size(); i++) {
        if(i == pos)
            p->next = t;
        printf(" val  %d  ",t->val);
        if(!t->next)  break;
        t = t->next;
        printf(" val  %d  ",t->val);
        if(t->next) printf(" val-next  %d \n",t->next->val);
    }
    Solution sol;
    sol.hasCycle(head);
    return 0;
}

2、合并两个有序链表

描述

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。  

示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

思路

遍历比较大小插入

代码

#include <iostream>
using namespace std;
#include <vector>

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* list1, ListNode* list2) {
        ListNode* merge;
        if(!list1)  return list2;
        if(!list2)  return list1;
        if(list1->val > list2->val) {
            printf("      list1  %d   list2  %d\n",list1->val,list2->val);
            ListNode *node = list2;
            list2 = list2->next;
            node->next = list1;
            list1 = node;
        }
        merge = list1;
        while(list2&&list1) {
            if(!list1->next) break;
            printf("list1->next  %d   list2  %d\n",list1->next->val,list2->val);
            if(list1->next->val <= list2->val)
                list1 = list1->next;
            else {
                ListNode *tmp = list2;
                list2 = list2->next;
                tmp->next = list1->next;
                list1->next = tmp;
            }
        }
        if(list2) {
            list1->next = list2;
        }
        return merge;
    }
};

int main() {
    ListNode* l1 = new ListNode;
    ListNode* l2 = new ListNode;
    vector<int> ls1 = {};
    vector<int> ls2 = {1,3,4};
    ListNode* list1;
    ListNode* list2;
    list1 = l1;
    list2 = l2;
    for(int i = 0; i < ls1.size(); i++) {
        ListNode *tmp = new ListNode(ls1[i]);
        l1->next = tmp;
        l1 = l1->next;
        printf(" %d -> ",l1->val);
    }
    list1 = list1->next;
    printf("\n");
    for(int i = 0; i < ls2.size(); i++) {
        ListNode *tmp = new ListNode(ls2[i]);
        l2->next = tmp;
        l2 = l2->next;
        printf(" %d -> ",l2->val);
    }
    list2 = list2->next;
    printf("\n");
    Solution sol;
    l1 = sol.mergeTwoLists(list1,list2);
    printf("res: ");
    while (l1) {
        printf("%d -> ",l1->val);
        l1 = l1->next;
    }
    printf("\n");    
    return 0;
}

3、移除链表元素

描述

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]

提示：
列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

思路

遍历比较

代码

#include <iostream>
using namespace std;
#include <vector>

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* removeElements(ListNode* head, int val) {
        ListNode *ls = new ListNode;
        ListNode *tmp;
        ls->next = head;
        head = ls;
        while(ls->next) {
            if(ls->next->val == val) {
                tmp = ls->next;
                ls->next = ls->next->next;
                tmp->next = nullptr;
                delete tmp;
            }
            else
                ls = ls->next;
        }
        ls = head;
        head = ls->next;
        ls->next = nullptr;
        delete ls;
        return head;
    }
};

int main() {
    vector<int> num ={1,2};
    int val = 1;
    ListNode *head = new ListNode;
    ListNode *p;
    p = head;
    for(int i = 0; i < num.size(); i++) {
        ListNode *tmp = new ListNode(num[i]);
        p->next = tmp;
        p = p->next;
    }
    Solution sol;
    p = sol.removeElements(head->next,val);
    while (p)
    {
        printf("%d -> ",p->val);
        p = p->next;
    }
    printf("\n");
    return 0;
}