【OJ算法训练】05十一月链表

最新推荐文章于 2022-05-06 21:30:20 发布

龙凌万顷

最新推荐文章于 2022-05-06 21:30:20 发布

阅读量155

点赞数

分类专栏：算法训练文章标签： python c++ 算法数据结构

本文链接：https://blog.youkuaiyun.com/fdk89577/article/details/121412881

版权

算法训练专栏收录该内容

7 篇文章

订阅专栏

链表

参考资料，以下内容来自C/C++/Python大佬们：

https://www.cnblogs.com/TMesh/p/11731484.html

... ...

定义

1. 线性表的链式存储结构，无序，Node节点的对象，value和下一个节点的next；

2. 链表一般分为单向链表、双向链表、环形链表；

3. 只能顺序访问，不能随机访问

实现方式

链表的实现可参考“八月__线性表”内容，本文不再重复描述。

Python链表

这里提供一个python创建和打印链表的模板，参考的力扣大佬代码。

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


def create_linked_list(nums):
    if len(nums) == 0:
        return None

    head = ListNode(nums[0])
    cur = head
    for i in range(1, len(nums)):
        cur.next = ListNode(nums[i])
        cur = cur.next
    return head


def print_linked_list(list_node):
    if list_node is None:
        return

    cur = list_node
    while cur:
        print(cur.val, '->', end=' ')
        cur = cur.next
    print('null')

LeetCode题目

80.删除有序数组中的重复项

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array-ii/

给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素最多出现两次，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

解题思路

快慢指针法：slow(left)、fast(right)

右指针right指向当前将要处理的元素, 左指针left指向下一个将要赋值的位置

Python3方法

# !/usr/bin/env python
# coding: utf-8

import unittest
from typing import List


class Solution:
    def remove_duplicates(self, nums: List[int]) -> int:
        # # 双指针
        # slow = 0
        # for fast in range(len(nums)):
        #     if slow < 2 or nums[fast] != nums[slow - 2]:
        #         nums[slow] = nums[fast]
        #         slow += 1
        # return slow

        # 通解
        def solve(k):
            slow = 0
            for fast in nums:
                if slow < k or nums[slow - k] != fast:
                    nums[slow] = fast
                    slow += 1
            return slow
        return solve(2)


class TestCase(unittest.TestCase):

    def test_01(self):
        nums = [1, 1, 1, 2, 2, 3]
        expected_results = 5
        self.result = Solution()
        res = self.result.remove_duplicates(nums)
        self.assertEqual(res, expected_results)

    def test_02(self):
        nums = [0, 0, 1, 1, 1, 1, 2, 3, 3]
        expected_results = 7
        self.result = Solution()
        res = self.result.remove_duplicates(nums)
        self.assertEqual(res, expected_results)


if __name__ == '__main__':
    unittest.main()

C++方法

#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n <= 2) {
            return n;
        }

        int slow = 2, fast = 2;
        while (fast < n) {
            if (nums[slow - 2] != nums[fast]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
};

void PrintArray(vector<int> arr, int n)
{
    cout << arr[0];
    for (int i = 1; i < n; i++) {
        cout << " " << arr[i];
    }
}

int main()
{
    Solution res;

    vector<int> nums = { 1, 1, 1, 2, 2, 3 };
    int ret = res.removeDuplicates(nums);

    cout << ret << endl;

    PrintArray(nums, ret);
}

142.环形链表II

https://leetcode-cn.com/problems/linked-list-cycle-ii/

给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

解题思路

双指针的快慢指针

Python3方法

# !/usr/bin/env python
# coding: utf-8

# Definition for singly-linked list.
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution:
    def detectCycle(self, head: ListNode):
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            # 相遇
            if slow == fast:
                p = head
                q = slow
                while p != q:
                    p = p.next
                    q = q.next
                return p

        return None

C++方法

#include <iostream>
#include <unordered_set>

using namespace std;

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

class Solution {
public:
    ListNode* detectCycle(ListNode* head) {
        unordered_set<ListNode*> visited;
        while (head != nullptr) {
            if (visited.count(head)) {
                return head;
            }
            visited.insert(head);
            head = head->next;
        }
        return nullptr;
    }
};

209.长度最小的子数组

https://leetcode-cn.com/problems/minimum-size-subarray-sum/

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

解题思路

依然双指针。

Python3方法

# !/usr/bin/env python
# coding: utf-8

from typing import List
import unittest


class Solution:
    def min_sub_array_len(self, target: int, nums: List[int]) -> int:
        length = len(nums)
        if length == 0:
            return 0

        left, right = 0, 0
        sums = 0
        min_len = length + 1
        while right < length:
            sums += nums[right]
            if sums >= target:
                while left < right:
                    if sums - nums[left] >= target:
                        sums -= nums[left]
                        left += 1
                    else:
                        break
                min_len = min(min_len, right - left + 1)
            right += 1
        return 0 if min_len == length + 1 else min_len


class TestCase(unittest.TestCase):

    def test_01(self):
        nums = [2, 3, 1, 2, 4, 3]
        target = 7
        expected_results = 2
        self.result = Solution()
        res = self.result.min_sub_array_len(target, nums)
        self.assertEqual(res, expected_results)

    def test_02(self):
        nums = [1, 4, 4]
        target = 4
        expected_results = 1
        self.result = Solution()
        res = self.result.min_sub_array_len(target, nums)
        self.assertEqual(res, expected_results)

    def test_03(self):
        nums = [1, 1, 1, 1, 1, 1, 1, 1]
        target = 11
        expected_results = 0
        self.result = Solution()
        res = self.result.min_sub_array_len(target, nums)
        self.assertEqual(res, expected_results)


if __name__ == '__main__':
    unittest.main()

C++方法

#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }

        int ans = INT_MAX;
        for (int i = 0; i < n; i++) {
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += nums[j];
                if (sum >= target) {
                    ans = min(ans, j - i + 1);
                    break;
                }
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

int main()
{
    Solution res;

    // int target = 7;
    // vector<int> nums = { 2, 3, 1, 2, 4, 3 };
    int target = 11;
    vector<int> nums = { 1, 2, 3, 4, 5 };
    int ret = res.minSubArrayLen(target, nums);

    cout << ret << endl;
}