链表问题

最新推荐文章于 2023-09-10 21:27:47 发布
最新推荐文章于 2023-09-10 21:27:47 发布
阅读量179 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44233369/article/details/99470965
版权

单链表与双链表

单链表的节点结构
Class Node{

V value;

Node next;

}
由以上结构的节点依次连接起来所形成的链叫单链表结构。
双链表的节点结构
Class Node{

V value;

Node next;

Node last;

}
由以上结构的节点依次连接起来所形成的链叫双链表结构。
单链表和双链表结构只需要给定一个头部节点head，就可以找到剩下的所有的节点。

解答链表相关问题时的技巧：

使用额外数据结构记录（哈希表等）；

使用快慢指针。

反转单向和双向链表

【题目】 分别实现反转单向链表和反转双向链表的函数

【要求】 如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度要求为 O(1)

  //问题1：反转输出链表
    //使用栈，时间复杂度为O(N),空间复杂度为O(N)
    static void reverseList(Node* head){
        Node*p = head;
        stack<Node> myStack;
        for( ; p != NULL; p = p->next){
            myStack.push(*p);
        }
        while(!myStack.empty()){
            cout << myStack.top().data<< " ";
            myStack.pop();
        }
 
    }
 
    //改变链表的结构，让第i个节点的next指向第i - 1个节点。时间复杂度为O(N),空间复杂度为O(1)
    static Node* reverseList_1(Node* head){
        Node* pre = NULL;
        Node* next = NULL;
        while(head != NULL){
            next = head->next;
            head->next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }

打印两个有序链表的公共部分

【题目】 给定两个有序链表的头指针head1和head2，打印两个链表的公共部分。

【要求】 如果两个链表的长度之和为N，时间复杂度要求为O(N)，额外空间复 杂度要求为O(1)

  static void printfCommentPart(Node* head_1,Node* head_2){
        while(head_1 != NULL && head_2 != NULL){
            if(head_1->data == head_2->data){
                cout << head_1->data << " ";
                head_1 = head_1->next;
                head_2 = head_2->next;
            }else{
                head_1->data > head_2->data ? head_2 = head_2->next : head_1 = head_1->next;
            }
        }
    }

判断一个链表是否为回文结构

【题目】给定一个单链表的头节点head，请判断该链表是否为回文结构。

【例子】1->2->1，返回true； 1->2->2->1，返回true；15->6->15，返回true； 1->2->3，返回false。

【要求】如果链表长度为N，时间复杂度达到O(N)，额外空间复杂度达到O(1)。

 //将链表全部压入栈中，依次弹出与链表元素比对
    //时间复杂度为O(N),空间复杂度为O(N)
    static bool isPalindromeList(Node* head){
        Node* p = head;
        stack<Node> myStack;
        while(p != NULL){
            myStack.push(*p);
            p = p->next;
        }
        for(p = head; p != NULL&&p->data == myStack.top().data; p = p->next,myStack.pop());
        if(p == NULL)
            return true;
        return false;
    }
    //将链表的后半部分压入栈中（快慢指针：快指针一次经过2个节点，慢指针一次经过1个节点）
    //时间复杂度为O(N),空间复杂度为O(N/2)
    static bool isPalindromeList_1(Node* head){
        if(head == NULL || head->next == NULL)
            return true;
        Node* f = head;
        Node* s = head;
        while(f->next != NULL && f->next->next != NULL){
            s = s->next;
            f = f->next->next;
 
        }
        stack<Node> myStack;
        if(f->next != NULL){
            s = s->next;
        }
        for(f = s ; f != NULL; f = f->next){
            myStack.push(*f);
        }
        for( ;!myStack.empty() && head->data == myStack.top().data;head = head->next,myStack.pop());
        if(head == s->next)
            return true;
        return false;
    }
    //将链表一分为二，倒转后一个链表
    //时间复杂度为O(N),空间复杂度为O(1)
    //head:链表首节点；head_1:分离后前一个链表的首节点；Head_2:分离后右边链表的首节点；temp_1:前一个链表的尾节点；temp_2:到转后右边链表的首节点
    static bool isPalindromeList_2(Node* head){
        if(head == NULL || head->next == NULL)
            return true;
        Node* f = head;
        Node* s = head;
        bool res = false;
        //分离
        while(f->next != NULL && f->next->next != NULL){
            s = s->next;
            f = f->next->next;
        }
        Node* head_1 = head;
        Node* head_2 = s->next;//第二个链表
        Node* temp_1 = s;//第一个链表的最后一个节点
        s->next = NULL;
 
        //倒转右边的链表
        s = NULL;
        while( head_2!= NULL){
            f = head_2->next;
            head_2->next = s;
            s = head_2;
            head_2 = f;
        }
        Node* temp_2 = s;
        for(head_2 = s;head_1 != NULL && head_2 != NULL && head_1->data == head_2->data;head_1 = head_1->next,head_2 = head_2->next);//{
        if(head_2 == NULL)
            res = true;
        s == NULL;
        head_2 = temp_2;
        while(head_2 != NULL){
 
 
            f = head_2->next;
            head_2->next = s;
            s = head_2;
            head_2 = f;
        }
       temp_1->next = s;
        return res;
    }

将单向链表按某值划分成左边小、中间相等、右边大的形式

【题目】给定一个单链表的头节点head，节点的值类型是整型，再给定一个整 数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于pivot的 节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点。
【进阶】在实现原问题功能的基础上增加如下的要求

【要求】调整后所有小于pivot的节点之间的相对顺序和调整前一样

【要求】调整后所有等于pivot的节点之间的相对顺序和调整前一样

【要求】调整后所有大于pivot的节点之间的相对顺序和调整前一样

【要求】时间复杂度请达到O(N)，额外空间复杂度请达到O(1)。

 //用额外空间存储链表中的数据，然后使用快速排序中的partition方法对额外空间排序
    //按照额外空间中的存储顺序修改链表中的值
    static void partition (vector<int>& v,int l,int r){
        if(l >= r)
            return;
        int num = v[rand() % (r - l + 1)];
        int less = l - 1;
        int more = r + 1;
        for(int i = l; i < r; ){
            if(v[i] < num){
                swap(v[i++],v[++less]);
            }else if(v[i] > num){
                swap(v[i],v[--more]);
            }else{
                i++;
            }
        }
        partition(v,l,less);
        partition(v,more,r);
    }
 
    static Node* smallEqualBigger(Node* head){
        vector<int> v;
        Node* p = head;
        for( ; p != NULL; p = p->next){
            v.push_back(p->data);
        }
        partition(v,0,v.size());
        int i = 0;
//        for( ; i < v.size();i++){
//            cout << v[i] << " ";
//        }
//        cout << endl;
        for(p = head; p != NULL && i < v.size(); p = p->next,i++){
 
            p->data = v[i];
        }
        return head;
    }
 
 
  
//直接在链表上进行划分
    static Node* smallEqualBigger_1(Node* head,int pivot){
        Node* sH = NULL;
        Node* sT = NULL;
        Node* lH = NULL;
        Node* lT = NULL;
        Node* eH = NULL;
        Node* eT = NULL;
        for(; head != NULL; head = head->next){
            if(head->data < pivot){
                if(sH == NULL){
                    sH = head;
                    sT = head;
                }else{
                    sT->next = head;
                    sT = head;
                }
            }else if(head->data > pivot){
                if(lH == NULL){
                    lH = head;
                    lT = head;
                }else{
                    lT->next = head;
                    lT = head;
                }
            }
            else{
                if(eH == NULL){
                    eH = head;
                    eT = head;
                }else{
                    eT->next = head;
                    eT = head;
                }
            }
          //  cout << head->data << endl;
        }
        if(sT != NULL)
            sT->next = eH;
        if(eT != NULL)
            eT->next = lH;
        return sH != NULL ? sH : eH != NULL ? eH : lH;
    }

复制含有随机指针节点的链表

【题目】一种特殊的单链表节点类描述如下
class Node {

int value;

Node next;

Node rand;

Node(int val){ value = val; }

}

rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节 点，也可能指向null。给定一个由Node节点类型组成的无环单链表的头节点 head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。
【要求】时间复杂度O(N)，额外空间复杂度O(1)

   //不考虑空间复杂度，使用map来存储新的链表节点
    static NodeWithRand* copyListWithRand(NodeWithRand* head){
        if(head == NULL){
            return NULL;
        }
        map<NodeWithRand*,NodeWithRand*> m;
        map<NodeWithRand*,NodeWithRand*>::iterator iter;
        NodeWithRand* p = head;
        for( ; p != NULL; p = p->next){
            m.insert(pair<NodeWithRand*,NodeWithRand*>(p,new NodeWithRand(p->data)));
        }
        for(p = head; p!= NULL; p = p->next){
            iter = m.find(p);
            iter->second->next = p->next == NULL ? NULL :m.find(p->next)->second;
            iter->second->rand = p->rand == NULL ? NULL : m.find(p->rand)->second;
        }
 
//        for(p = m[head]; p != NULL; p = p->next){
//            cout << p->data << " ";
//            cout << p->rand << " ";
//            if(p->rand != NULL)
//                cout << " randData:" << p->rand->data << endl;
//        }
        return m[head];
    }
 
    //空间复杂度为O(1)，创建新节点时将新节点加到老节点的后面，其余不变
    static NodeWithRand* copyListWithRand_1(NodeWithRand* head){
        if(head == NULL)
            return NULL;
        NodeWithRand* p = head;
        NodeWithRand* copyHead = NULL;
        for( p = head; p != NULL; p = p->next->next){
            NodeWithRand* temp = new NodeWithRand(p->data);
            temp->next = p->next;
            p->next = temp;
        }
        for(p = head; p != NULL && p->next != NULL; p = p->next->next){
            NodeWithRand* temp = p->next;
            temp->rand = p->rand == NULL ? NULL :p->rand->next;
        }
        copyHead = head->next;
        for(p = head; p != NULL && p->next != NULL; p = p->next){
            NodeWithRand* temp = p->next;
            p->next = p->next->next != NULL ? p->next->next : NULL;
            temp->next = temp->next != NULL ? temp->next->next : NULL;
 
        }
        return copyHead;
    }

两个单链表相交的一系列问题

【题目】给定两个可能有环也可能无环的单链表，头节点head1和head2。请实 现一个函数，如果两个链表相交，请返回相交的 第一个节点。如果不相交，返 回null

【要求】如果两个链表长度之和为N，时间复杂度请达到O(N)，额外空间复杂度 请达到O(1)。

//问题6：两个单链表相交的问题
    //判断链表是否有环，有则返回环节点，否则返回NULL
    static Node* getLoopNode(Node* head){
        if(head == NULL || head->next == NULL)
            return NULL;
        Node* f = head->next->next;
        Node* s = head->next;
        //cout << f->data << endl;
        int i = 0;
        //cout << f->data << " " << s->data << " " << i <<endl;
        for( ;f->next != NULL && f->next->next != NULL && s != f;f = f->next->next,s = s->next,i++);
        if(s == NULL || f == NULL){
            return NULL;
        }
        f = head;
        for( ; f != s;f = f->next,s = s->next);
        //cout << s->data << endl;
        return s;
    }
    //判断两个链表都没有环的情况
    static Node* getNoLoop(Node* head1,Node* head2){
        if(head1 == NULL ||  head2 == NULL)
            return NULL;
        int n = 0;
        for( ; head1 != NULL; head1 = head1->next)
            n++;
        for( ; head2 != NULL; head2 = head2->next)
            n--;
        Node* longList = n >= 0 ? head1 : head2;
        Node* shortList = n >= 0 ? head2 : head1;
        for( ; n >= 0; n--,longList = longList->next);
        for( ; longList != shortList && longList != NULL && shortList != NULL;longList = longList->next,shortList = shortList->next);
        if(longList == shortList)
            return longList;
        return NULL;
 
    }
    //判断两个链表各自有自己的环的情况
    static Node* getBothLoop(Node* head1,Node* head2,Node* loop1,Node* loop2){
        if(loop1 == loop2){
            int n = 0;
            for( ; head1 != NULL; head1 = head1->next)
                n++;
            for( ; head2 != NULL; head2 = head2->next)
                n--;
            Node* longList = n >= 0 ? head1 : head2;
            Node* shortList = n >= 0 ? head2 : head1;
            for( ; n >= 0; n--,longList = longList->next);
            for( ; longList != shortList;longList = longList->next,shortList = shortList->next);
            return longList;
        }else{
            Node* p = loop1->next;
            for( ; p != loop1 && p != loop2;p = p->next);
            if(p == loop2)
                return p;
            return NULL;
        }
    }
    //判断两个链表是否相交，相交返回交点，否则返回NULL
    static Node*  getIntersectNode(Node* head1,Node* head2){
        if(head1 == NULL || head2 == NULL)
            return NULL;
        Node* loop1 = getLoopNode(head1);
        Node* loop2 = getLoopNode(head2);
        //cout << loop1->data << " " << loop2->data << endl;
        if(loop1 == NULL && loop2 == NULL){
            return getNoLoop(head1,head2);
        }else if(loop1 != NULL && loop2 != NULL){
            return getBothLoop(head1,head2,loop1,loop2);
        }
        return NULL;
    }
我去前面探探路a
关注
链表
leigh的博客
03-26 243
单链表与双链表 单链表的节点结构 Class Node<V>{ V value; Node next; } 由以上结构的节点依次连接起来所形成的链叫单链表结构。 双链表的节点结构 Class Node<V>{ V value; Node next; Node last; } 由以上结构的节点依次连接起来所形成的链叫双链表结构。 ...
《程序员代码面试指南》第二章链表问题下
weixin_43928720的博客
09-22 301
1. 环形单链表的约舍夫问题 题目描述： 据说著名的犹太历史学家Josephus有过以下故事：在罗马人占领桥塔帕特后，39个犹太人与Josephus 及他的朋友躲到一个洞中，39个犹太人宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第一个人开始报数，报数到3的人就自杀，然后再有下一个人重新报1，报数到3的人再自杀。这样依次下去，直到剩下最后一个人时，那个人可以自由选择自己...
2021-04-09：rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null。给定一个由Node节点类型组成的无环单链表的头节点 head，请实现一个函数完
福大大架构师每日一题
04-09 5063
2021-04-09：rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null。给定一个由Node节点类型组成的无环单链表的头节点 head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。 【要求】时间复杂度O(N)，额外空间复杂度O(1) 。 福大大 答案2021-04-09： 假设链表节点是A1→B1→C1。 1.复制节点，插入原链表，链表变成A1→A2→B1→B2→C1→C2。 2.设置A2、B2、C2的随机指针。 3.拆分链表。变成A1→B1
intval()函数
weixin_30555753的博客
04-30 189
获取变量的整数值 1.转换前转化后 原因： 转载于:https://www.cnblogs.com/xiaobiaomei/p/8973542.html
intval( )函数
最新发布
mr__sheng的博客
09-10 222
【代码】intval( )函数。
简单的关于c++链表问题
11-06
简单的C++链表问题，欢迎大家下载
小孩报数.cpp（基础的链表问题）
05-27
使用链表解决小孩报数问题
实用链表问题总结
07-06
链表总结，c语言版本，巩固基础知识，适用于求职面试，来自互联网，版权归著者
链表问题11——两个单链表相交的系列问题(三):判断两个有环链表是否相交
01-08
在考虑此问题时，根据前面几篇文章的解法，我们已经得到了各自链表的入环节点，分别为loop1和loop2 思路 以下是问题三的具体解决过程： 如果loop1==loop2，我们只需要考虑从链表1的头节点head1到loop1这一段与从链表...
【算法笔记】移除链表元素
weiwai的博客
04-11 332
移除链表元素问题 给你一个链表的头节点head和一个整数val ，请你删除链表中所有满足Node.val == val的节点，并返回新的头节点 。 问题分析 一个很简单的链表删除操作，通过头结点不断向后面的结点移动，比较每一个结点是否等于val，是就执行链表的删除操作。 原链表直接解决问题 我们需要注意的是头结点的删除方式和其他结点的不同 删除头结点：head=head.next 直接让头结等于下一个节点 删除非头结点(A.next)：A.next=A.next.next 该节点的上一个节点的指
移除链表元素
weixin_45798182的博客
04-07 177
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 https://leetcode-cn.com/problems/remove-linked-list-elements/ //方法1：造一个哨兵节点指向头节点，把Node.val == val 的节点删除，返回哨兵节点的next public ListNode removeElements1(ListNode head, int val) {
c语言int val什么意思,c语言中int*是什么意思
weixin_39556702的博客
05-19 1427
匿名用户1级2014-03-07 回答看了你的追问这么多我知道他们回答的不是楼主想要的。先引来这段代码:char* //这是字符指针类型(所谓类型也就是附加char的一种)，只有在定义时才这样写，就像你写int 一样。 问题：什么是指针？有何作用？在C语言在存的价值及意义是什么？答：指针在计算机硬件中是不存在这个名字，而在计算机中只有地址。还是很混，为什么要区分开地址和指针搞的人不明白呢？因为计算...
算法习题之链表问题
sam475259540的博客
01-11 106
常见的链表算法习题
int i ; const int val=i ; 在C++中这种赋值对吗?
tingfengx的专栏
03-25 1973
首先这种定义方式是可以通过编译的。 int i; //定义（注意是定义，意味着分配了内存）一个int型变量i，同时没有初始化。那么i的值就是分配内存位置的值，这个值可能为任意值。 const int val = i; // 定义一个const int对象val，并初始化，那么初始化后val的值就是刚才i内存位置的值。定义后，val即便仍然是左值（意味着可赋值），但任何修改val的尝试都会导致编译错
c语言int val,c语言不定参数与printf函数的实现
weixin_39633452的博客
05-19 650
今天学习了C语言不定参数，C语言中的不定参数主要靠这个头文件实现，这个头文件包含了va_list()、va_start()、va_end()三个宏,其用法为先声明一个va_list类型的变量，它用于访问参数列表未确定的部分。这个变量是由va_start来初始化的。它的第一个参数是va_list的变量名，第二个参数是省略号前最后一个有名字的参数。初始化过程把va_list的变量设置为指向可变参数的第...
链表面试题
qq_45955734的博客
08-30 244
链表面试题
php里 int和intval 区别
weixin_33696106的博客
05-03 783
php 强制数字类型 int和intval 区别intval 只能四位数字，超过了不行了int 没有限制 转载于:https://blog.51cto.com/kangjunfei/1921475
int val=rand() & 0xFF 是什么意思？
wonderful931106的博客
11-12 1002
rand()随机数函数返回一个int型的数，之后用这个数逻辑与上一个0xff，最后将结果赋值给val； 例如： rand()函数返回值为8；8的2进制形式为0000，0000，0000，0000，0000,0000,0000,1000 0xff的2进制形式为0000，0000，0000，0000，1111,1111,1111,1111 两个数作为运算‘&‘ 之后得到0000，0000，0000，0000，0000,0000,0000,1000 然后将这个数赋值给m_session 整个这条语句的作用
java排序链表问题
09-10
排序链表问题是指对一个链表进行排序。其中，可以使用链表自顶向下归并排序的方法进行排序。具体过程如下： 1. 找到链表的中点，以中点为分界，将链表拆分成两个子链表。可以通过快慢指针的方式来找到链表的中点。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值