牛客网算法学习笔记-链表

最新推荐文章于 2022-08-23 11:02:47 发布
最新推荐文章于 2022-08-23 11:02:47 发布
阅读量3.8k 收藏 2
点赞数
分类专栏： 牛客网算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012656267/article/details/51496431
版权

对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。

给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。

测试样例： 
{1,4,2,5},3
{1,2,4,5}

单独建立两个头结点，并且建立两个尾结点，保证有头指针指向两个分块的头结点，尾结点进行元素的拓展，然后在最后进行拼接，注意返回只得是头结点的下一个结点

/*

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Divide {
public:
    ListNode* listDivide(ListNode* head, int val) {
        // write code here
        ListNode* le=new ListNode(0);
        ListNode* gr=new ListNode(0);
        ListNode *cur_le=le,*cur_gr=gr;
        for(;head!=NULL;head=head->next){
            if(head->val<=val){
                cur_le->next=head;
                cur_le=cur_le->next;
            }
            else{
                cur_gr->next=head;
                cur_gr=cur_gr->next;               
            }
        }
        cur_le->next=gr->next;
        cur_gr->next=NULL;
        return le->next;
    }

};


现有两个升序链表，且链表中均无重复元素。请设计一个高效的算法，打印两个链表的公共值部分。

给定两个链表的头指针headA和headB，请返回一个vector，元素为两个链表的公共部分。请保证返回数组的升序。两个链表的元素个数均小于等于500。保证一定有公共值

测试样例： 
{1,2,3,4,5,6,7},{2,4,6,8,10}
返回：[2.4.6]

两个头指针，小的先后移，一样的话则同时后移并且存储结点值，直到一个链为NULL；

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Common {
public:
    vector<int> findCommonParts(ListNode* headA, ListNode* headB) {
        // write code here
        vector<int> result;
        if(headA == NULL ||headB == NULL){
            return result;
        }
        while(headA != NULL&&headB!=NULL){
            
            if(headA->val<headB->val){
                headA = headA ->next;
            }
            else if (headA ->val == headB ->val){
                result.push_back(headA->val);
                headA = headA ->next;
                headB = headB ->next;
            }
            else{
                headB = headB ->next;
            }
            
        }
        return result;
    }

};


5.7

有一个单链表，请设计一个算法，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null，K=3这个例子。调整后为，3->2->1->6->5->4->7->8->null。因为K==3，所以每三个节点之间逆序，但其中的7，8不调整，因为只有两个节点不够一组。

给定一个单链表的头指针head,同时给定K值，返回逆序后的链表的头指针

我的代码(说运行超时，没找到原因).

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class KInverse {
public:
    ListNode* inverse(ListNode* head, int k) {
        // write code here
        if(head == NULL || k ==1 ){
            return head;
        }
        ListNode *resultHead = new ListNode(0) ;
        ListNode * tempHead = resultHead;
        stack<ListNode*> kStack;
        bool first = false;
        int count = 0;
        while(head!=NULL){
            kStack.push(head);
            
            count++;
            if(count>=k){
                while(count>0){ //倒序
                    ListNode* t = kStack.top();
                    kStack.pop();
                    tempHead->next = t;
                    tempHead = tempHead->next ; 
                    count--;
                }
            }
            head = head ->next;
        }
        tempHead ->next = NULL;
        if(count>0&&count<k){
           while(count>0){
               ListNode* t = kStack.top();
               kStack.pop();
               t ->next = tempHead ->next; //头插法。对不满K的 保持原续
               tempHead->next = t; 
  count--;
           }
        }
        return resultHead->next ;
    }
};


别人家的代码：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class KInverse {
public:
    ListNode* inverse(ListNode* head, int k) {
        stack<ListNode *> mystack;
        ListNode *Pre=NULL;
        ListNode *Behind=head;
        while(Behind!=NULL){
            int count=0;
            while(Behind!=NULL&&count<k){ //入栈，倒序
                mystack.push(Behind);
                Behind=Behind->next;
                count++;
            }
            if(count<k)
                break;
            while(!mystack.empty()){
                ListNode *temp=mystack.top();
                if(Pre==NULL){
                    Pre=temp;
                    head=Pre;
                }           
                else{
                    Pre->next=temp;
                    Pre=Pre->next;
                }
                mystack.pop();
            }   
            Pre->next=Behind;  //pre拼接剩余的原链表的内容
        }
        return head;
    }
};

现在有一个单链表。链表中每个节点保存一个整数，再给定一个值val，把所有等于val的节点删掉。

给定一个单链表的头结点head，同时给定一个值val，请返回清除后的链表的头结点，保证链表中有不等于该值的其它值。请保证其他元素的相对顺序。

测试样例： 
{1,2,3,4,3,2,1},2
{1,3,4,3,1}

传递的NODE是没有头结点的，head直接指向第一个结点。所以可以增加头结点使得所有结点的操作方式相同

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class ClearValue {
public:
    ListNode* clear(ListNode* head, int val) {
        // write code here
        ListNode* listHead = (ListNode*)malloc(sizeof(ListNode));
        listHead->next = head;
        ListNode *pre = listHead;
        while(head!=NULL){
            if(head->val==val){
                ListNode *t = head;
                head = head ->next;
                pre ->next = head;
                free(t);
            }
            else{
                head = head->next;
                pre = pre ->next;
            }
        }
        return listHead->next;
    }
};


请编写一个函数，检查链表是否为回文。

给定一个链表ListNode* pHead，请返回一个bool，代表链表是否为回文。

测试样例： 
{1,2,3,2,1}
返回：true
{1,2,3,2,3}
返回：false
将链表存入一个栈中，然后从栈头开始一个一个弹出和原来的链表进行比较，如果比较过程中有不想同的则返回false
否则返回true

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Palindrome {
public:
    bool isPalindrome(ListNode* pHead) {
        // write code here
        stack<ListNode*> reStack;
        ListNode* temp = pHead;
        while(temp!=NULL){
            reStack.push(temp);
            temp = temp->next;
        }
        while(pHead!=NULL){
            ListNode *t = reStack.top();
            reStack.pop();
            if(t->val != pHead->val){
                return false;
            }
            pHead = pHead ->next;
        }
        return true;
    }
};


5.11

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(pHead==NULL)
            return pHead;
        RandomListNode * tmp=pHead;
        while(tmp)
            {
            RandomListNode* pNode=new RandomListNode(tmp->label);
            pNode->next=tmp->next;
            tmp->next=pNode;
            tmp=pNode->next;
        }
        tmp=pHead;
        RandomListNode * newtmp=NULL;
        while(tmp)
            {
            newtmp=tmp->next;
            if(tmp->random==NULL)//要区分random是否为NULL，因为random并不是像next一样
                newtmp->random=NULL;
            else
                newtmp->random=tmp->random->next;
            tmp=newtmp->next;
        }
       
         RandomListNode*next=NULL;
         RandomListNode*curCopy=NULL;
         RandomListNode*cur = pHead;
         RandomListNode* res = pHead->next;
         while (cur!=NULL) {
             next = cur->next->next;
             curCopy = cur->next;
             cur->next = next;
             curCopy->next = next!=NULL ? next->next : NULL;
             cur = next;
         }
         return res;
     }
};

进击的yeah
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客网算法学习记录-链表2
u012656267的博客
05-25 259
如何判断一个单链表是否有环？有环的话返回进入环的第一个节点的值，无环的话返回-1。如果链表的长度为N，请做到时间复杂度O(N)，额外空间复杂度O(1)。 给定一个单链表的头结点head（注意另一个参数adjust为加密后的数据调整参数，方便数据设置，与本题求解无关)，请返回所求值。 方法：设置一个快步指针和一个慢步指针，快步指针和慢步指针同时向前，如果不存在环，那么快步指针必定会变为N
链表（一）
Bonjour2017的博客
08-22 439
目录 19.给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 237.删除链表中的结点 83.删除排序链表中的重复元素 61.旋转链表 24. 两两交换链表中的节点 206. 反转链表 92. 反转链表 II(反转m-n之间的链表) 160. 相交链表 142. 环形链表 II 19.给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 找出倒...
【刷题笔记】之牛客面试必刷TOP101（1）
m0_58761900的博客
08-23 1781
1. 反转链表（双链表头插法 / 栈） 2.链表内指定区间反转 3. 链表中的节点每k个一组翻转 4. 合并两个排序的链表 5. 合并k个已排序的链表
leetcode2
m0_62000951的博客
01-17 1411
1.new创造一个新的节点 2.一个链表含有首节点，尾节点，头节点指向首节点 new listnode(-1)相当于创造一个链表给他赋值 1.定义一个虚拟头节点，就不用特判当前点是不是第一个点了，可以随便赋值，反正也不会用 2.再创造一个尾节点，指向当前的尾节点 3.然后while循环遍历每一个链表，和进位t若不为0，则一直循环。 4.每次更新尾节点指向下一个节点。 class Solution { public: ListNode* addTwoNumbers(ListNode.
（哨兵节点) ListNode prehead = new ListNode(-1)；ListNode prev = prehead； 的用法
dauiwsbd的博客
08-18 7778
@[TOC](ListNode prehead = new ListNode(-1);ListNode prev = prehead;（哨兵节点)的用法) 哨兵节点简介 哨兵节点是做链表题目时经常用到的写法，由于在对链表进行重新排列、打断、合并等等操作时，链表的头节点往往会发生移动变得“破朔迷离”，故在一开始我们设定一个哨兵节点，这可以在最后让我们比较容易地返回合并后的链表。 常见写法 ListNode a = new ListNode(0); ListNode b = a; 这两句代码的意义 因为
算法--合并链表
weixin_43596542的博客
11-25 719
1、合并两个有序链表 给你链表的头结点head，请将其按升序排列并返回排序后的链表。 class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { //定义一个头结点 ListNode prehead = new ListNode(-1); //当前节点 ListNode prev = prehead; ...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
算法设计-实验五-链表.docx
09-06
本资源提供了Python中设计和实现链表的详细指南。该文档涵盖了链表的基本概念，包括节点结构、列表遍历以及插入和删除操作。此外，该文档还包括了一个逐步指南，介绍如何在Python中创建链表类，包括代码示例和实现...
Java算法练习-链表的分化练习题
10-07
java
Java算法设计-链表的回文结构练习题
10-08
java
Java算法练习-链表指定值清除练习题
10-08
java
Leetcode 题解 - 链表
Cybenko
06-30 258
链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。 找出两个链表的交点 160. Intersection of Two Linked Lists (Easy) A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 要求：时间复杂度为 O(N)，空间复杂度为 O(1) 设 A 的长度为 a
算法学习随笔 1_数据结构和算法
P_in_k的博客
03-03 399
算法学习随笔系列文章旨在记录和梳理本人学习算法过程当中遇到的问题和知识点，同时希望可以和大家交流，共同学习。作为一名学习者，文中难免有错误的地方，希望大家指正。
【leetcode】链表 && 双指针
myaijarvis notebook
01-13 178
简单 203. 移除链表元素 参考：203. 移除链表元素 - 力扣（LeetCode） 设置虚拟头节点，方便把删除头节点和非头节点的操作统一化 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * L
ListNode* res = new ListNode(-1)；初始化一个节点值为-1的空节点
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
07-20 465
ListNodelist=newListNode(0)初始化一个节点值为0的空节点，最常用最正规写法。ListNodelist=newListNode()初始化一个空节点，无值,不提倡此种写法。ListNodelist=null为空，什么都没有，一般不这么写。
牛客网：关于链表的环和入口问题
weixin_46266058的博客
05-19 146
C++ 链表
牛客网刷题记录1（链表）
weixin_38375196的博客
02-22 194
这里写自定义目录标题JZ6 从尾到头打印链表JZ24 反转链表 JZ6 从尾到头打印链表 go 语言实现的时候发现了一些有意思的问题 package main import . "nc_tools" /* * type ListNode struct{ * Val int * Next *ListNode * } */ /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * @param head ListNode类 * @return
leetcode/牛客 链表面试题
TPON的博客
05-26 238
leetcode/牛客 链表面试题
Leetcode算法系列二（链表）
weixin_44337475的博客
10-16 343
1.8道经典链表常考题目 例1-a：反转链表 例1-b：反转链表2 例2：链表求交点 例3：链表求环 例4：链表划分 例5：复杂链表的复制 例6-a：2个排序链表归并 例6-b：K个排序链表归并 206.反转链表 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ public class Solution {
C语言-链表-添加到链表尾部
最新发布
11-27
以下是C语言中将新节点添加到链表尾部的示例代码： ```c #include <stdio.h> #include <stdlib.h> // 定义链表结构体 struct Node { int data; struct Node* next; }; // 在链表尾部添加新节点 void append(struct Node** head_ref, int new_data) { // 为新节点分配内存 struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); struct Node* last = *head_ref; // 用于遍历链表 // 设置新节点的值和下一个节点为NULL new_node->data = new_data; new_node->next = NULL; // 如果链表为空，则将新节点设置为头节点 if (*head_ref == NULL) { *head_ref = new_node; return; } // 遍历链表，找到最后一个节点 while (last->next != NULL) { last = last->next; } // 将新节点添加到链表尾部 last->next = new_node; return; } // 测试代码 int main() { struct Node* head = NULL; // 初始化链表为空 // 添加节点 append(&head, 1); append(&head, 2); append(&head, 3); // 遍历链表并输出每个节点的值 struct Node* current = head; while (current != NULL) { printf("%d ", current->data); current = current->next; } return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值