C/C++数据结构与算法笔记3（链表习题）

C/C++数据结构与算法笔记3（链表习题）

作业来自CSDN课程 C/C++ 数据结构与算法 （王桂林）

作业由C++编写，仅供参考！

2.5.1 逆序一个链表 （leetcode206）（注意：这道题给出的head参数不是头指针，而是第一个节点，因此与笔记1不同）

输入 [1 2 3 4 5]

输出 [5 4 3 2 1]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

//采用头插法

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode * q;
        ListNode * p;
        ListNode * t =NULL;
        p = head;
        while(p!=NULL)
        {
            q=p;
            p = p->next;
            q->next = t ;
            t = q;
        }
        return t;
    }
};
//
//

Leetcode测试结果：通过

执行用时：8 ms, 在所有 C++ 提交中击败了92.49%的用户

内存消耗：8.6 MB, 在所有 C++ 提交中击败了27.47%的用户

进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？（待日后补充）

 

2.5.2 如何判断一个链表是否有环 （leetcode141）

给定一个链表，判断链表中是否有环。(图片详见leetcode141原题）

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

如果链表中存在环，则返回 true 。 否则，返回 false 。来源：力扣（LeetCode）

提示：

• 链表中节点的数目范围是 [0, 10^4]
• -10^5 <= Node.val <= 10^5
• pos 为 -1 或者链表中的一个 有效索引 。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode * headA = head;
        ListNode * headB = head ;
        int flag = 0;
        for(int i=0;i<10001;i++)
        {   
            if(head == NULL || head->next == NULL || head->next->next == NULL)
            {
                break;
            }
            else{
                if(headA->next!=NULL && headA->next->next !=NULL && headB->next != NULL){
                    headA = headA->next;
                    headA = headA->next;
                    headB = headB->next;
                    if(headA == headB){
                        flag = 1;
                        break;
                    }
                }
                else{
                    break;
                }
            }
        }
    if(flag==1){
        return true;
    }
    else{return false;}
    }
};

结果：通过

执行用时：4 ms, 在所有 C++ 提交中击败了99.77%的用户

内存消耗：7.8 MB, 在所有 C++ 提交中击败了29.23%的用户

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？ （上述已经是O（1）解决，因为节点小于10^4，只循环一次）

 

2.5.3 求链表的中间节点，要求只用一次循环 （leetcode876）

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL. （来源：力扣（LeetCode））

给定链表的结点数介于 1 和 100 之间。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {

        ListNode* headA = head;
        ListNode* headB = head;
        ListNode* result;
        for(int i=0;i<100;i++)
        {   
            if(head->next == NULL){
                result = head;
                break;
            }
            else if(head->next->next ==NULL)
            {
                result = head->next;
                break;
            }
            else if(headB->next ==NULL)
            {
                result = headA;
                break;
            }
            else if(headB->next->next == NULL)
            {
                result = headA->next;
                break;
            }
            else{
                headA = headA->next;
                headB = headB->next->next;
            }
        }
        return result;
    }
};

结果：通过

执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户

内存消耗：6.8 MB, 在所有 C++ 提交中击败了26.42%的用户

 

2.5.4 约瑟夫环 （leetcode-剑指offer62）

0,1,,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。 来源：力扣（LeetCode）

输入: n = 5, m = 3
输出: 3

• 1 <= n <= 10^5
• 1 <= m <= 10^6

//数学规律反推 效率较高 能通过！

//思路：

//第四轮时，补上m个位置，数组大小是2，那么3对应的下标是(0+3)%2 = 1 

//第三轮时，补上m个位置，数组大小是3，那么3对应的下标是(1+3)%3 = 1 

//第二轮时，补上m个位置，数组大小是4，那么3对应的下标是(1+3)%4 = 0 

//第一轮时，补上m个位置，数组大小是5，那么3对应的下标是(0+3)%5 = 3

//f(n,m)表示数组大小为n时，每次剔除第m个元素后剩下的那一个元素的序号。 f(n,m) = (f(n-1,m) + m) % n

class Solution {
public:
    int lastRemaining(int n, int m) {
        int pos = 0;
        for(int i=2; i<=n; i++)
        {
            pos=(pos+m)%i;
        }
    return pos;
    }
};

//暴力遍历 用例能过 测试超时 因为时间复杂度O（nm）
class Solution {
public:
    int lastRemaining(int n, int m) {
        int arr[100000]={0};
        int pos=0;int k=0;int person=n;
        while(person!=1)
        {
            if(arr[pos]==0)
            {
                k++;
                if(k==m){
                arr[pos]=1;
                person--;
                k=0;
                } 
            }
            pos++;
            if(pos==n)
            {
                pos=0;
            }
        }

        for(int j=0;j<n;j++)
        {
            if(arr[j]==0)
            {
                pos=j;
                break;
            }
        }
    return pos;
    }
};

//测试用例如下图：

 

 

//来自官方的遍历法，用例能过，依然超时
class Solution {
public:
    int lastRemaining(int n, int m) {
        list<int> nums;
        for (int i = 0; i < n; i++) {
            nums.push_back(i);
        }
        auto it = nums.begin();
        int ret = *it;
        while (!nums.empty()) {
            for (int i = 0; i < m - 1; i++) {
                it++;
                if (it == nums.end()) it = nums.begin();  // 循环
            }
            ret = *it;
            it = nums.erase(it);  // list erase 操作返回后序的迭代器
            if (it == nums.end()) it = nums.begin();  // 循环
        }
        return ret;
    }
};

待续。。。