链表相关OJ及方法总结

最新推荐文章于 2022-11-17 17:29:37 发布
最新推荐文章于 2022-11-17 17:29:37 发布
阅读量388 收藏 5
点赞数 12
文章标签： 链表 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62918577/article/details/127696447
版权

目录​​​​​​​

第一类：改变链接关系 

第二类：快慢指针 

第一类：改变链接关系 

1. 删除链表中等于给定值 val 的所有结点。

(1)原地删除

struct ListNode* removeElements(struct ListNode* head, int val){
    if(head==NULL)
    {
        return head;
    }
    struct ListNode* cur=head,* pre=NULL,* ret;
    while(cur)
    {
        //需要删除cur
        if(cur->val==val)
        {    
            //cur是首节点，需要改变头结点
            if(pre==NULL)
            {
                ret=cur;
                head=cur->next;
                cur=cur->next;
            }
            //直接删除即可
            else
            {
                 ret=cur;
                 pre->next=cur->next;
                 cur=cur->next;
            }
             free(ret);
        }
        //不用删除，
        else
        {
            pre=cur;
            cur=cur->next;
            
        } 
    }
    return head;
}

(2)建立一个新链表，将不用删除的节点依次尾插

if(head==NULL)
    {
        return head;
    }
    struct ListNode* cur=head,* pre=NULL,*newhead=NULL,*newtail=NULL;
    while(cur)
    {
        
        //需要尾插cur
        if(cur->val!=val)
        {   
            
            //cur是首节点，需要改变newhead
            if(!newhead)
            {
                newhead=newtail=cur;
                
            }
            //直接尾插即可
            else
            {
                newtail->next=cur;
                newtail=newtail->next;
            }
        }
        pre=cur;
        cur=cur->next;
    }
    if(newtail)
        newtail->next=NULL;
    return newhead;

(3)在2的基础上使用带头节点链表

struct ListNode* removeElements(struct ListNode* head, int val){
    if(head==NULL)
    {
        return head;
    }
    struct ListNode* cur=head,* pre=NULL;
    struct ListNode* newhead=(struct ListNode* )malloc(sizeof(struct ListNode)),*newtail=newhead;
    while(cur)
    {
        
        //需要尾插cur
        if(cur->val!=val)
        {   
            newtail->next=cur;
            newtail=newtail->next;
        }
        pre=cur;
        cur=cur->next;
    }
    
    newtail->next=NULL;
    return newhead->next;
}

(4)递归

struct ListNode* removeElements(struct ListNode* head, int val){
    if(head==NULL)
    {
        return head;
    }
    if(head->val==val)
    {
        return  removeElements(head->next, val);
    }
    else
    {
        head->next=removeElements(head->next, val);
        return head;
    }
    
}

2. 反转一个单链表。

 (1)原地逆转


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* ret=NULL,*cur=head,*pre=NULL;
    while(cur)
    {
        ret=cur->next;
        cur->next=pre;
        pre=cur;
        cur=ret;
    }
    return pre;
}

(2)建立一个新链表，将节点依次头插（带头结点链表）

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* newhead=(struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode*cur=head,*ret;
    newhead->next=NULL;
    while(cur)
    {  
        ret=cur->next;
        cur->next=newhead->next;
        newhead->next=cur;
        cur=ret;
    }
    
    return newhead->next;
}

(3)递归


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

第二类：快慢指针 

 3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点。

(1)快慢指针

struct ListNode* middleNode(struct ListNode* head){
     struct ListNode* slow = head;
     struct  ListNode* fast = head;
        while (fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;

}

(2).求出size再遍历

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* cur = head;
    int size=0;
    while (cur) {
        size++;
        cur=cur->next;
    }
    cur = head;
    size/=2;
    while(size--)
    {
        cur=cur->next;
    }
    return cur;
}

(3)先遍历一遍将数据存入数组再处理


struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* cur = head;
    struct ListNode* a[180];
    int i=0;
    while (cur) {
        a[i++]=cur;
        cur=cur->next;
    }
    return a[i/2];
}

4. 输入一个链表，输出该链表中倒数第k个结点。

(1)快慢指针

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    if(pListHead==NULL||k==0)
        return NULL;
    struct ListNode* fast,*slow;
    fast=slow=pListHead;
    while(k&&fast)
    {
        fast=fast->next;
        k--;
    }
    if(k)
    {
        return NULL;
    }
    while(fast)
    {
        fast=fast->next;
        slow=slow->next;
    }
    return slow;
}

(2).求出size再遍历size-k次

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* cur = pListHead;
    int size=0;
    while (cur) {
        size++;
        cur=cur->next;
    }
    cur = pListHead;
    if(k>size)
        return NULL;
    size-=k;
    while(size--)
    {
        cur=cur->next;
    }
    return cur;
}

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

 (1)直接迭代改变链接关系（使用带头链表）

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode* newhead=(struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* tail;
    if(newhead!=NULL)
    {
        tail=newhead;
       
    }
    struct ListNode* p1=list1,*p2=list2;
    tail->next=NULL;
    while(p1&&p2)
    {
        
        if(p1->val<p2->val)
        {
            tail->next=p1;
            tail=tail->next;
            p1=p1->next;
        }
        else
        {
            tail->next=p2;
            tail=tail->next;
            p2=p2->next;
        }
    }

    if(p1)
    {
        tail->next=p1;
    }

    if(p2)
    {
        tail->next=p2;
    }

    return newhead->next;
}

(2)递归

​
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    if(list1==NULL)
    {
        return list2;
    }
    if(list2==NULL)
    {
        return list1;
    }
    if(list1->val<list2->val)
    {
        list1->next=mergeTwoLists(list1->next,list2);
        return list1;
    }
    else
    {
        list2->next=mergeTwoLists(list2->next,list1);
        return list2;
    }
    
    return NULL;

}

​

6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结 点之前 。

创建两个链表，分别链接小于x的节点和大于x的节点： 

ListNode* partition(ListNode* pHead, int x) {
        ListNode* newhead1=(ListNode*)malloc(sizeof(ListNode));
        ListNode* newhead2=(ListNode*)malloc(sizeof(ListNode));
        newhead1->next=NULL;
        newhead2->next=NULL;
        ListNode* tail1=newhead1;
        ListNode* tail2=newhead2;
        ListNode* cur=pHead;
        while(cur)
        {
            if(cur->val < x)
            {
                tail1->next=cur;
                tail1=tail1->next;
            }
            else
            {
                tail2->next=cur;
                tail2=tail2->next;
            }
            cur=cur->next;        
         }
       
        tail1->next=newhead2->next;
        tail2->next=NULL;
        return newhead1->next;
    }

7. 链表的回文结构。

 快慢指针加逆序链表

 struct ListNode* reverseList(struct ListNode* head){
        struct ListNode* ret=NULL,*cur=head,*pre=NULL;
        while(cur)
        {
            ret=cur->next;
            cur->next=pre;
            pre=cur;
            cur=ret;
        }
        return pre;
    }

    bool chkPalindrome(ListNode* A) {
        ListNode* slow=A,*fast=A;
        while(fast&&fast->next)
        {
            fast=fast->next->next;
            slow=slow->next;
        }
       
        slow=reverseList(slow);
        
        while(slow&&A!=slow)
        {
            if(slow->val!=A->val)
            {
                return false;
            }
            slow=slow->next;
            A=A->next;

        }
        
        return true;
    }

8. 输入两个链表，找出它们的第一个公共结点。

(1)先遍历两个链表，得出长度差，使得长链表先走长度差的步数，然后一起比较。 

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    int difsize=0;
    struct ListNode *p1=headA,*p2=headB;
    struct ListNode*longL=headA,*shortL=headB;
    while(p1||p2)
    {
        if(p1)
        {
            difsize++;
            p1=p1->next;
        }
        if(p2)
        {
             difsize--;
            p2=p2->next;
        }    
    }
    if(difsize<0)
    {
        longL=headB,shortL=headA;
    }
    difsize=abs(difsize);
    while(difsize--)
    {
        longL=longL->next;
    }
    while(longL)
    {
        if(longL==shortL)
            return longL;
        else
        {
            longL=longL->next;
            shortL=shortL->next;
        }
    }

    return NULL;
}

(2)不记录长度一直遍历达到两个指针指向长度一样的目的。

创建两个指针 初始时分别指向两个链表的头节点 ，然后将两个指针依次遍历两个链表的每个节点。

如果指针 pA不为空，则将指针 pA 移到下一个节点；pB同理。

如果指针 pA为空，则将指针 pA 移到链表 headB的头节点；pB同理。

当指针 pA，pB 指向同一个节点退出。

    if(headA==NULL||headB==NULL)
    {
        return NULL;
    }
    struct ListNode * pA = headA, *pB = headB;
    while (pA != pB) {
        if(!pA)
            pA =headB;
        if(!pB)
            pB =headA;
        if(pA == pB)
            break;
        pA=pA->next,pB=pB->next;
    }
    return pA;
}

(3)哈希表查找

​
struct HashTable {
    struct ListNode *key;
    UT_hash_handle hh;
};

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct HashTable *hashTable = NULL;
    struct ListNode *temp = headA;
    while (temp != NULL) {
        struct HashTable *tmp;
        HASH_FIND(hh, hashTable, &temp, sizeof(struct HashTable *), tmp);
        if (tmp == NULL) {
            tmp = malloc(sizeof(struct HashTable));
            tmp->key = temp;
            HASH_ADD(hh, hashTable, key, sizeof(struct HashTable *), tmp);
        }
        temp = temp->next;
    }
    temp = headB;
    while (temp != NULL) {
        struct HashTable *tmp;
        HASH_FIND(hh, hashTable, &temp, sizeof(struct HashTable *), tmp);
        if (tmp != NULL) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}
​

9. 给定一个链表，判断链表中是否有环。

 (1)快慢指针

bool hasCycle(struct ListNode *head) {
    if(head==NULL)
        return false;
    struct ListNode *fast=head,*slow=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)
            return true;
    }
    
    return false;
    
}

 (2)哈希表

struct hashTable {
    struct ListNode* key;
    UT_hash_handle hh;
};

struct hashTable* hashtable;

struct hashTable* find(struct ListNode* ikey) {
    struct hashTable* tmp;
    HASH_FIND_PTR(hashtable, &ikey, tmp);
    return tmp;
}

void insert(struct ListNode* ikey) {
    struct hashTable* tmp = malloc(sizeof(struct hashTable));
    tmp->key = ikey;
    HASH_ADD_PTR(hashtable, key, tmp);
}

bool hasCycle(struct ListNode* head) {
    hashtable = NULL;
    while (head != NULL) {
        if (find(head) != NULL) {
            return true;
        }
        insert(head);
        head = head->next;
    }
    return false;
}

10. 给定一个链表，返回链表开始入环的第一个结点。 如果链表无环，则返回 NULL 

利用前一题的快慢指针。一指针从相遇点开始走，一指针从头开始，两者一定会在入环点相遇。 

struct ListNode *detectCycle(struct ListNode *head) {
     if(head==NULL)
        return NULL;
    struct ListNode *fast=head,*slow=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)
        {
            slow=head;
            while(slow!=fast)
            {
                fast=fast->next,slow=slow->next;
            }
            return fast;
        }
    }
    return NULL;
}

 11. 给定一个链表，每个结点包含一个额外增加的随机指针，该指针可以指向链表中的任何结点 或空结点。 要求返回这个链表的深度拷贝。

方法一：遍历两遍，第一遍创建新节点将next链接好，同时记录源节点与新节点对应关系，第二遍完成random的链接。

 


struct Node* copyRandomList(struct Node* head) 
{
    if(head==NULL)
        return NULL;
    struct Node* arr1[1001];
    struct Node* arr2[1001];
    struct Node*cur=head;
    struct Node* newguard=(struct Node*)malloc(sizeof(struct Node));
    struct Node*ptail=newguard;
    assert(newguard);
    int index=0;
    while(cur)
    {
        struct Node* ret=(struct Node*)malloc(sizeof(struct Node));
        ret->val=cur->val;
        ptail->next=ret;
        ptail=ret;
        arr1[index]=cur;
        arr2[index]=ret;
        cur=cur->next;
        index++;
    }
    cur=head;
    struct Node*newcur=newguard->next;
    while(cur)
    {
        struct Node* obj=cur->random;
        if(obj!=NULL)
        {
            for(int i=0;i<index;i++)
            {
                if(obj==arr1[i])
                {
                    newcur->random=arr2[i];
                    break;
                }
            }
        }
        else
        {
            newcur->random=NULL;
        }
        cur=cur->next,newcur=newcur->next;
    }
    ptail->next=NULL;
    return newguard->next;
}

方法二：新节点先链接进入原链表然后将新节点的random链接好，此时原来节点random指向的源节点后面就可以直接找到新节点应该指向的位置。

分为三步：

    //创建新节点

    //改变random指向

    //将新节点剥离

 


struct Node* copyRandomList(struct Node* head) 
{
    if(head==NULL)
        return NULL;
    struct Node*cur=head;
    //创建新节点
   
    
    while(cur)
    {
        struct Node* ret=(struct Node*)malloc(sizeof(struct Node));
        ret->val=cur->val;
        ret->next=cur->next;
        cur->next=ret;
        cur=ret->next;
    }
    cur=head; 
    //改变random指向
    while(cur)
    {
        struct Node* obj=cur->next;
        if(cur->random==NULL)
        {
            obj->random=NULL;
        }
        else
        {
            obj->random=cur->random->next;
        }
        
        cur=obj->next;
        
    }
    cur=head->next;
    //将新节点剥离
    while(cur->next)
    {
        cur->next=cur->next->next;
        cur=cur->next;
    }
    return head->next;
}

(3)

(4)

写完这行就睡觉
关注
  • 12
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
链表oj题（5道）
Mmmmmmmrr的博客
04-23 524
1.删除链表中等于给定值 val 的所有节点 链接: link. 例：删除x=3的结点节点 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* removeElement...
玩链表 oj
七九河开的博客
01-27 650
玩链表 Time Limit: 1000MS Memory Limit: 65536KB Problem Description bLue 获得了一个含有 n 个数的初始链表，现在他要把另外的一些数插入到链表的开头。你能帮他完成吗？ Input 输入数据有多组（数据组数不超过 20），到 EOF 结束。 对于每组数据： 第 1 行输入 2 个整数 n (1 第
链表OJ
qq1024734546的博客
06-28 210
删除单向链表所有的val struct ListNode* removeElements(struct ListNode* head, int val){ if (head == NULL) return NULL; struct ListNode* prev = head;//prev用来保存找到的val，方便完成链表的重组 struct ListNode* cur = head-&g...
链表oj题
weixin_45726063的博客
08-13 192
删除链表中等于给定值 val 的所有节点。 struct ListNode* removeElements(struct ListNode* head, int val){ struct ListNode*cur=head; struct ListNode*prev=NULL; while(cur) { if(cur->val==val) { if(cur==head) { head=cur->n.
OJ 单链表
River_Lethe的博客
01-13 584
PAT中有关链表的题一般都是用顺序结构来表示，即将链表的节点储存在一个很大的数组中，数组下标就是节点的地址，节点结构中有一个next成员，储存着逻辑上下个节点的下标，用-1来表示空值。 //基本的节点结构 struct Node { //数据 int data; //下个节点的坐标 int next; }; 考察范围无非增查删改反转这些，有一个方法可以在不破坏
cpp代码-双向循环链表-oj
07-14
cpp代码-双向循环链表-oj
OJ.zip_循环链表
09-21
循环链表解决热土豆（约瑟夫）问题，简单易懂，可以直接修改
西南科技大学SWUST OJ 线性结构，链表题解答案 线性结构.zip
12-31
SWUST OJ：941、942、943、952、953、954、955、956、957、960、1035、1037、1038、1039、1040、1045、1101、1102、1103题答案
链表oj题（第一弹）
m0_64334842的博客
11-17 470
链表oj
反转单链表，环形链表，运用快慢指针思想的单链表OJ题
Darling_sheeps的博客
12-04 265
删除链表中等于给定值 val 的所有节点。 #include &lt;stdio.h&gt; ListNode* removeElements(ListNode* head, int val) { ListNode *prev =NULL; ListNode *cur =head; ListNode *tail =NULL; while (cur) { if (cur-&gt;dat...
常见的链表OJ题(简单篇)
faerfwedw的博客
06-11 543
五道简单常见的链表oj题
【算法】链表经典OJ
m0_64224788的博客
08-26 647
题目链接203. 移除链表元素 - 力扣（LeetCode）题目描述给你一个链表的头节点 和一个整数 ，请你删除链表中所有满足 的节点，并返回 新的头节点 。思路遍历链表，对比每一个节点的数据与val是否相等，如果相等，就free该节点。时间复杂度：O(N) 空间复杂度：O(1) 易错点1、当链表的头结点的数据等于val时，我们free掉该节点后需要挪动head指针，让其指向新的头结点2、我们在遍历链表的时候需要记录前一个节点的地址，因为当我们free掉当前节点之后，我们要让前一个节点的next
常见链表OJ题
gangaue的博客
04-02 558
文章目录1.移除链表元素2.反转链表3.链表的中间节点4.链表中倒数第k个节点5.合并二个有序链表6.链表分割7.回文链表8.相交链表9.复制带随机指针的链表 1.移除链表元素 删除链表中等于给定值 val 的所有节点。(OJ链接) 思想：双指针 首先我们维护一个prev和cur指针，prev先指向NULL,cur用于遍历链表 prev用于保存cur的前一个节点，当cur->data等于val，然后自己定义一个next指针保存cur->next，这样就可以先free/delete节点，
【OJ】 单链表OJ刷题
yangke369的博客
05-15 620
1、移除链表元素   删除链表中等于给定值 val 的所有节点。OJ链接   示例：   输入: 1->2->6->3->4->5->6, val = 6   输出: 1->2->3->4->5 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct L
常见的链表OJ题(中等篇)
faerfwedw的博客
06-18 417
三道中等难度的链表oj题
九度OJ 题目1181：遍历链表
落日小屋
02-20 2223
题目1181：遍历链表 时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：1071 解决：437 题目描述： 建立一个升序链表并遍历输出。 输入： 输入的每个案例中第一行包括1个整数：n(1 输出： 可能有多组测试数据，对于每组数据， 将n个整数建立升序链表，之后遍历链表并输出。 样例输入
链表OJ_删除节点、翻转链表
java_Maxhui
08-14 153
删除链表中等于给定值 val 的所有节点。 示例: 输入: 1->2->6->3->4->5->6, val = 6 输出: 1->2->3->4->5 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-linked-list-elements。 class Soluti...
ACM-杭电 HDOJ-1216 模拟，链表
程序圆圆圆
09-24 3182
用下面的方法模拟，最开始开50000的链表跑了187ms，真是相当的惭愧呀。后改用35000的链表跑了109ms。最后改用c的输入输出(也就是下面放出的代码）跑了78ms，其实自己写链表会跑的更快。不过个人比较懒，加上已经0点了，78ms就78ms吧 = =~~~ 顺道一提，我这个代码加上空行什么的共737B，不过statistic第一页大多都是10000+B的代码，这神马...
频率最高的手写代码面试题--链表类型(上)
身在边城 心在编程
03-08 277
1、奇偶链表 2、删除链表中的节点 3、移除链表元素 4、相交链表 5、复制链表 6、环形链表 7、重排链表 8、对链表进行插入排序 9、删除排序链表中的重复元素 10、删除排序链表中的重复元素 II
旋转链表 东华大学oj
最新发布
06-03
旋转链表是一种操作链表的方法，它可以将链表中的元素向右旋转 k 个位置。具体来说，如果将链表中的每个节点向右移动 k 个位置，则从链表尾部开始计算，移动后的最后一个节点应该移动到链表头部，而倒数第二个节点移动到倒数第 k+1 个节点的位置，依此类推。旋转链表的主要应用场景是在某些需要处理循环数组的问题中，将链表视为循环数组来处理。 关于东华大学oj的问题，我不是很清楚，可以请您提供更多的信息吗？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值