Linked List 总结

最新推荐文章于 2024-09-13 14:00:00 发布
原创 最新推荐文章于 2024-09-13 14:00:00 发布 · 245 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了链表的各种操作，包括查找交点、删除重复项、移除倒数第N个节点等，并提供了详细的实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >




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

void list_print(ListNode * head);

class Solution 
{
public:

    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        int sizeA(0), sizeB(0);
        ListNode *p1(headA), *p2(headB);
        while(p1 != NULL)
        {
            sizeA ++;
            p1 = p1->next;
        }

        while(p2 != NULL)
        {
            sizeB ++;
            p2 = p2->next;
        }

        int size_diff(0);
        size_diff = abs(sizeA - sizeB);
        p1 = headA;
        p2 = headB;

        if(sizeA > sizeB)
        {
            for(int i=0; i<size_diff; i++)
            {
                p1 = p1->next;
            }
        }
        else
        {
            for(int i=0; i<size_diff; i++)
            {
                p2 = p2->next;
            }
        }

        while(p1 != NULL)
        {
            if(p1 == p2)
            {
                return p1;
            }
            p1 = p1->next;
            p2 = p2->next;
        }
        return NULL;
    }

    bool hasCycle(ListNode *head)
    {
        ListNode *p1(head), *p2(head);
        while(p2 != NULL && p2->next != NULL)
        {
            p1 = p1->next;
            p2 = p2->next->next;
            if(p1 == p2) return true;
        }
        return false;
    }

    ListNode* deleteDuplicates(ListNode* head) 
    {
        if(head == NULL) return head;
        bool action(false);
        int cmp(0);
        while(head->next != NULL && head->next->val == head->val)
        {
            action = true;
            cmp = head->val;
            while(head != NULL && head->val == cmp && action == true)
            {
                head = head->next;
            }   
            action = false;

            if(head == NULL) return head;
        }   

        ListNode *p(head);
        while(p->next != NULL && p->next->next != NULL)
        {
            if(p->next->val == p->next->next->val)
            {
                action = true;
                cmp = p->next->val;
                //p->next = p->next->next;
                while(p->next != NULL && p->next->val == cmp && action == true)
                {
                    p->next = p->next->next;
                }
                action = false;
            }
            else
            {
                p = p->next;
            }
        }
        return head;    
    }
    /*  
    ListNode* deleteDuplicates(ListNode* head) 
    {
        if(head == NULL) return head;
        while(head->next != NULL && head->next->val == head->val)
        {
            head = head->next;
        }       
        ListNode *p(head);
        while(p->next != NULL && p->next->next != NULL)
        {
            if(p->next->val == p->next->next->val)
            {
                p->next = p->next->next;
            }
            else
            {
                p = p->next;
            }
        }
        return head;            
    }
    */

    ListNode* removeNthFromEnd(ListNode* head, int n) 
    //assume this n is always valid
    {
        if(head == NULL) return head;
        if(n == 0) return head;
        ListNode *p1(head), *p2(head);
        for(int i=0; i<n; i++)
        {
            p2 = p2->next;
        }
        //cout << "ok1\n";
        if(p2 == NULL)
        {
            head = head->next;
            return head;
        }
        //cout << "ok2\n";
        while(p2->next != NULL)
        {
            p1 = p1->next;
            p2 = p2->next;
        }
        p1->next = p1->next->next;
        return head;
    }

    ListNode* rotateRight(ListNode* head, int k) 
    {
        if(head == NULL || head->next == NULL) return head;
        int size(0);
        ListNode *t(head);
        while(t->next != NULL)
        {
            size ++;
            t = t->next;
        }
        size ++;

        k = k % size;
        if(k == 0) return head;

        ListNode *p(head);
        for(int i=0; i<size-k-1; i++)
        {
            p = p->next;
        }
        t->next = head;
        head = p->next;
        p->next = NULL; 
        return head;    
    }

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) 
    {
        ListNode *l3(NULL);

        if(l1 == NULL) 
        {
            return l2;
        }
        if(l2 == NULL) 
        {
            return l1;
        }
        //after this point, l1 and l2 both have a size of 1 or more


        ListNode *p1(l1), *p2(l2), *p3(l3);
        int carry(0);


        ListNode *new_node_p(NULL);

        new_node_p = new ListNode(0);
        l3 = new_node_p;
        p3 = l3;
        new_node_p = NULL;

        while(p1 != NULL && p2 != NULL)
        {
            int sum(0); 
            sum = p1->val + p2->val + carry;
            carry = 0;
            if(sum >= 10)
            {
                p3->val = sum - 10;
                carry = 1;
            }
            else
            {
                p3->val = sum;
            }
            p1 = p1->next;
            p2 = p2->next;

            if( p1 != NULL && p2 != NULL )
            {
                new_node_p = new ListNode(0);
                p3->next = new_node_p;
                p3 = p3->next;
                new_node_p = NULL;
            }
        }
        //after this point, p1 == NULL || p2 == NULL
        if( (p1 == NULL && p2 == NULL) && (carry == 1) )
        {
            new_node_p = new ListNode(1);
            p3->next = new_node_p;
            p3 = p3->next;
            carry = 0;
            new_node_p = NULL;
        }

        //cout << "p1 != NULL\n";
        //list_print(l3);
        //cin.get();    
        if(p1 != NULL)
        {       
            while(p1 != NULL)
            {
                new_node_p = new ListNode(0);
                p3->next = new_node_p;
                p3 = p3->next;
                new_node_p = NULL;

                int sum(0);
                sum = p1->val + carry;
                carry = 0;
                if(sum == 10)
                {
                    p3->val = 0;
                    carry = 1;
                }
                else
                {
                    p3->val = sum;
                }
                p1 = p1->next;
            }

            if(carry == 1)
            {
                new_node_p = new ListNode(1);
                p3->next = new_node_p;
                p3 = p3->next;
                carry = 0;
                new_node_p = NULL;
            }
        }

        //cout << "p2 != NULL\n";
        //list_print(l3);
        //cin.get();
        if(p2 != NULL)
        {
            while(p2 != NULL)
            {
                new_node_p = new ListNode(0);
                p3->next = new_node_p;
                p3 = p3->next;
                new_node_p = NULL;

                int sum(0);
                sum = p2->val + carry;
                carry = 0;
                if(sum == 10)
                {
                    p3->val = 0;
                    carry = 1;
                }
                else
                {
                    p3->val = sum;
                }
                p2 = p2->next;          
            }

            //cout << "Inside of p2 != NULL\n";
            //list_print(l3);
            //cin.get();

            if(carry == 1)
            {
                new_node_p = new ListNode(1);
                p3->next = new_node_p;
                p3 = p3->next;
                carry = 0;
                new_node_p = NULL;
            }
        }
        //cout << "return l3\n";
        //cin.get();
        return l3;      
    }

    ListNode* swapPairs(ListNode* head) 
    {
        if(head == NULL || head->next == NULL) return head;
        //after this point, all in coming linked lists have a size of 2 or more

        ListNode *tmp;
        tmp = head;
        head = head->next;
        tmp->next = head->next;
        head->next = tmp;
        //finish the swap of first pair


        ListNode *p;
        p = head->next;

        while(p->next != NULL && p->next->next != NULL)
        //make sure that there is at least one more pair to swap
        //if none or just one, just skip as nothing is to swap
        {
            tmp = p->next->next->next;
            p->next->next->next = p->next;
            p->next = p->next->next;
            p->next->next->next = tmp;

            p = p->next->next;
        }
        return head;
    }

    ListNode* removeElements(ListNode* head, int val)
    {
        if(head == NULL) return head;

        while(head != NULL && head->val == val)
        {
            head = head->next;
        }
        if(head == NULL) return head;

        ListNode *p;
        p = head;
        while(p->next != NULL)
        {
            if(p->next->val == val)
            {
                p->next = p->next->next;
            }
            else
            {
                p = p->next;
            }
        }
        return head;
    }

    ListNode* insertionSortList(ListNode* head) 
    //"insertion sort"
    {
        if(head == NULL || head->next == NULL) return head;
        //after this point, all in coming linked lists have a size of 2 or more

        ListNode *p, *next_p, *n;
        //ListNode *end,
        //end = head;
        p = head->next;
        next_p = p->next;

        head->next = NULL;
        //end->next = NULL;

        while(p != NULL)
        {
            cout << "L0 ";
            p->next = NULL;

            if(head->val > p->val)
            {
                p->next = head;
                head = p;
            }
            else
            {
                n = head;
                while(n->next != NULL)
                {
                    //cout << "L1 ";
                    if(n->next->val > p->val)
                    {
                        p->next = n->next;
                        n->next = p;
                        break;
                    }
                    n = n->next;
                }
                n->next = p;
            }
            //insertion finished
            //prepare for next item

            p = next_p;
            if(next_p != NULL)
            {
                next_p = next_p->next;
            }

            list_print(head);
        }

        return head;        
    }


    ListNode* sortList(ListNode* head) 
    //decided to use "marge sort", recurrence as the way to solve this problem
    {
        if(head == NULL) return head;
        if(head->next == NULL) return head;
        //merge(left_par, right_par);
        ListNode *fast, *slow;
        fast = head;
        slow = head;
        while(fast->next != NULL && fast->next->next != NULL)
        {
            fast = fast->next->next;
            slow = slow->next;
        }
        fast = slow->next;
        slow->next = NULL;
        slow = head;
        return merge(sortList(fast), sortList(slow));
        //step 1. using fast-slow pointers to find the middle point of this sortlist
        //and to define two parts
        //setp 2. using sortlist recursively
        //step 3. merge
    }

    ListNode* merge(ListNode* l1, ListNode* l2)
    {
        ListNode *new_head(NULL), *p(NULL);

        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;

        if(l1->val < l2->val)
        {
            new_head = l1;

            l1 = l1->next;                  
        }   
        else
        {
            new_head = l2;

            l2 = l2->next;
        }

        p = new_head;
        p->next = NULL; 

        while(l1 != NULL && l2 != NULL)
        {
            if(l1->val < l2->val)
            {
                p->next = l1;
                l1 = l1->next;
            }   
            else
            {
                p->next = l2;
                l2 = l2->next;
            }

            p = p->next;
            p->next = NULL; 
        }

        if(l1 != NULL)
        {
            p->next = l1;
        }
        else
        {
            p->next = l2;
        }
        return new_head;
    }
};


void list_print(ListNode * head)
{
    ListNode *tmp = head;
    cout << "list_print: ";
    if(tmp == NULL)
    {
        cout << "\n"; 
        return;
    }   
    while(tmp->next != NULL)

    {
        cout << " " << tmp->val;
        tmp = tmp->next;
    }
    cout << " " << tmp->val;
    cout << "\n";
    return;
}
jerseyma
关注
LeetCode - Linked List 总结
real_lisa的博客
06-21 198
2. Add Two Numbers # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def addTwoNumbers(self, ...
02-线性结构3 Reversing Linked List（C）
2301_80474443的博客
07-11 621
日常，21分共25分1. 有多余结点不在链表上.............................................段错误2.最大N,最后剩K-1不反转 ......................................... 运行超时。
206. Reverse Linked List 总结
m0_73756442的博客
05-08 900
做题反思
Leetcode Linked List 总结
o0Helloworld0o的博客
07-28 384
206. Reverse Linked List 反转链表 237. Delete Node in a Linked List O(1)时间删除链表节点 21. Merge Two Sorted Lists 合并两个排序链表 83. Remove Duplicates from Sorted List 删除链表中的重复元素，只保留1个 141. Linked List Cycle ...
142. Linked List Cycle II
wilzxu的博客
03-07 180
142. Linked List Cycle II方法1:方法2:方法3: 总结： 南京大乱炖： http://www.cnblogs.com/hiddenfox/p/3408931.html grandyang：http://www.cnblogs.com/grandyang/p/4137302.html 方法1: 思路： 第一次相遇后，让slow,fast继续走，记录到下次相遇时循环了几次。因...
Day 15: Linked List
追求卓越583的博客
03-19 890
题目： C++： #include <stdlib.h> #include <stdio.h> #include <algorithm> #include <vector> #include <map> #include <math.h> #include <string> #inclu...
array和linked list的区别
qq_40914472的博客
09-13 518
数组（Array）：适合频繁读取或随机访问的情况，但插入和删除效率较低，大小固定。链表（Linked List）：适合频繁插入和删除的场景，大小动态，但访问效率较低。
反转链表（Reverse Linked List）
tianshu11tianshu的博客
09-01 1114
该算法的时间复杂度为 O(n)，其中 n 是链表的长度，空间复杂度为 O(1)。输出: 5->4->3->2->1->NULL。对于反转链表这道题目，其高效最优解法是使用迭代实现。进阶:你可以迭代或递归地反转链表。你能否用两种方法解决这道题？示例：输入: 1->2->3->4->5->NULL。
List集合知识总结
m0_74267125的博客
01-09 1146
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。List是一种常用的集合类型，它可以存储任意类型的对象，也可以结合泛型来存储具体的类型对象，本质上就是一个容器。与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。| getLast()： | 返回列表的最后一个元素。| removeLast()： | 删除并返回列表的最后一个元素。
circular_linked_list_4_6.zip_Linked list
09-19
**总结** 环形链表作为一种特殊的链式数据结构，具有独特的性质和广泛的应用场景。理解和熟练掌握环形链表的创建、操作以及在各种算法中的应用，对于提升编程能力，解决实际问题具有重要意义。通过深入学习和实践，...
DoublyLinkedList:用 Java 实现双向链表
06-04
+ int listSize() + T first() + T last() - void verifySize(int size, int position) - DLNode<T> getNodeAtPosition(int position) + T getElementAtPosition(int position) + void setElementAtPosition(int ...
node-linked-list
04-27
本文将围绕“node-linked-list”这一主题，深入探讨JavaScript中的链表实现及其相关知识点。 一、链表的定义与类型 链表是一种线性数据结构，由一系列节点（也称为元素）组成，每个节点包含数据和指向下一个节点的...
用python实现的DBSCAN聚类(一种基于密度的聚类算法)，并且将分布打印在二维平面.zip
08-23
用python实现的DBSCAN聚类(一种基于密度的聚类算法)，并且将分布打印在二维平面.zip
鲸鱼优化算法(WOA)在机器学习分类、回归及时间序列预测中的应用与MATLAB代码实践 v2.0
08-23
鲸鱼优化算法（WOA）及其在分类、回归和时序预测中的应用。首先简述了WOA的基本原理，即通过模拟鲸鱼的捕食行为来进行全局搜索和局部优化。接着分别讨论了WOA在不同机器学习模型中的应用，如支持向量机(SVM)、最小二乘支持向量机(LSSVM)、随机森林(RF)、极限学习机(ELM)等多种模型的参数优化，以及在时序预测中与LSTM、GRU等深度学习模型的结合。最后提供了具体的MATLAB代码示例，展示了如何使用WOA优化SVM模型进行分类预测，并强调了代码的通用性和灵活性，便于用户根据自己的数据集进行修改和扩展。 适用人群：对机器学习有一定了解的研究人员和技术爱好者，尤其是那些希望深入了解优化算法在机器学习中应用的人群。 使用场景及目标：① 提升现有机器学习模型的预测性能；② 学习如何使用WOA优化各种类型的机器学习模型；③ 掌握MATLAB环境下相关模型的代码实现。 其他说明：文中提供的代码为简化版本，实际应用时需根据具体情况调整参数配置和数据预处理步骤。此外，还鼓励读者探索更多优化算法与机器学习模型的组合方式，以应对不同的应用场景。
PLC编程中绝对运动指令的实现与优化(西门子200smart与威纶通触摸屏)
08-23
绝对运动指令 MoveAbsolute 在西门子200smart PLC 和威纶通触摸屏上的实现方法。主要内容涵盖梯形加减速控制、PLS 脉冲指令的手动编写、正反向运动控制、回原点功能以及减速停止功能的具体实现细节。作者分享了在开发过程中遇到的问题及其解决方案，如脉冲丢失、方向切换、回原点搜索模式等，并指出了当前版本存在的不足之处，即不支持超驰功能。 适合人群：PLC 编程初学者、自动化设备开发者、工业控制系统工程师。 使用场景及目标：适用于需要精确控制电机运动的应用场合，如生产线自动化、数控机床等领域。主要目标是帮助读者掌握绝对运动指令的底层实现原理，提高对PLC编程的理解和技术水平。 其他说明：文中提供了详细的代码片段和注释，有助于读者更好地理解和实践相关技术。同时提醒读者注意实际应用中的潜在问题，如输出口反冲等。
机器人开发教程-ROS 进行 SLAM 建图和机器人运动控制
08-23
机器人开发教程——ROS 进行 SLAM 建图和机器人运动控制 环境准备 确保你的开发环境已安装 ROS Noetic 或更高版本，并且安装了适用于 ROS 的 SLAM 和 Moveit2.0 软件包。 创建工作空间和包 mkdir -p ~/catkin_ws/src cd ~/catkin_ws/src catkin_create_pkg my_slam_package std_msgs rospy roscpp cd ~/catkin_ws catkin_make source devel/setup.bash 启动 SLAM 算法 roslaunch my_slam_package slam.launch 保存地图 rosrun map_server map_saver -f my_map 读取地图 在 my_slam_package/launch 目录下创建 map.launch 文件： <launch> <node name="map_server" pkg="map_server" type="map_server" args="my_map.yaml"/> </launch> 启动地图服务器 roslaunch my_slam_package map.launch 控制机器人运动 使用 teleop_twist_keyboard 包控制机器人运动： rosrun teleop_twist_keyboard teleop_twist_keyboard.py 注意事项 确保激光雷达数据正确发布到 /scan 话题。 根据实际机器人调整 SLAM 参数。 在 RViz 中查看地图和机器人位置。
基于阿克曼模型的自动驾驶控制算法仿真测试及学习指南
08-23
阿克曼模型在自动驾驶控制算法中的应用，重点讲解了通过ROS平台对阿克曼模型进行仿真测试的方法及其具体实现。文章从阿克曼模型的基本概念出发，逐步探讨其在自动驾驶中的应用场景，特别是路径规划和运动控制方面的作用。接着，通过具体的仿真测试案例展示了如何利用ROS环境扣取阿克曼控制算法模块，验证其准确性和有效性。最后提供了部分代码实现及详细的注释，帮助读者深入理解该算法的工作原理和技术细节。 适合人群：对自动驾驶技术和机器人操作系统（ROS）有一定了解的研究人员、工程师及高校相关专业学生。 使用场景及目标：适用于希望深入了解阿克曼模型在自动驾驶系统中应用的技术人员，旨在提升他们对于车辆转向几何关系的理解能力，掌握基于ROS平台进行算法仿真的技能。 其他说明：随着自动驾驶技术的发展，阿克曼模型作为关键组件之一，在确保车辆行驶安全性和精度方面扮演着越来越重要的角色。因此，本文不仅有助于理论学习，也为实际项目开发提供了宝贵的参考资料。
TimeWheel：一个基于GO实现的时间轮盘定时器.zip
最新发布
08-23
TimeWheel：一个基于GO实现的时间轮盘定时器.zip
用linked list实现堆栈java
09-13
堆栈是一种具有后进先出（LIFO）特性的数据结构，可以使用链表（linked list）来实现。 在Java中，我们可以通过创建一个链表节点类来实现堆栈。这个节点类包含两个属性：数据（value）和指向下一个节点的引用（next...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值