力扣刷题学习笔记（3）

本次记录最近刷题学习笔记，部分源码借鉴力扣官方和网络，未详细注明，仅作学习使用，部分程序仍然贴出了源码，并做了可以直接在codeblocks下运行的程序：

41. 缺失的第一个正数

难度困难591收藏分享切换为英文关注反馈

给你一个未排序的整数数组，请你找出其中没有出现的最小的正整数。

 

示例 1:

输入: [1,2,0]
输出: 3

示例 2:

输入: [3,4,-1,1]
输出: 2

示例 3:

输入: [7,8,9,11,12]
输出: 1

思路：

个人感觉应该先排序，然后遍历是不是存在全部小于等于0，不全部小于等于0则遍历剩下的，

方法二：置换

除了打标记以外，我们还可以使用置换的方法，将给定的数组「恢复」成下面的形式：

 

如果数组中包含 x \in [1, N]x∈[1,N]，那么恢复后，数组的第 x - 1x−1 个元素为 xx。

 

在恢复后，数组应当有 [1, 2, ..., N] 的形式，但其中有若干个位置上的数是错误的，每一个错误的位置就代表了一个缺失的正数。以题目中的示例二 [3, 4, -1, 1] 为例，恢复后的数组应当为 [1, -1, 3, 4]，我们就可以知道缺失的数为 22。

 

那么我们如何将数组进行恢复呢？我们可以对数组进行一次遍历，对于遍历到的数 x = \textit{nums}[i]x=nums[i]，如果 x \in [1, N]x∈[1,N]，我们就知道 xx 应当出现在数组中的 x - 1x−1 的位置，因此交换 \textit{nums}[i]nums[i] 和 \textit{nums}[x - 1]nums[x−1]，这样 xx 就出现在了正确的位置。在完成交换后，新的 \textit{nums}[i]nums[i] 可能还在 [1, N][1,N] 的范围内，我们需要继续进行交换操作，直到 x \notin [1, N]x∈

/

​        

 [1,N]。

 

注意到上面的方法可能会陷入死循环。如果 \textit{nums}[i]nums[i] 恰好与 \textit{nums}[x - 1]nums[x−1] 相等，那么就会无限交换下去。此时我们有 \textit{nums}[i] = x = \textit{nums}[x - 1]nums[i]=x=nums[x−1]，说明 xx 已经出现在了正确的位置。因此我们可以跳出循环，开始遍历下一个数。

 

由于每次的交换操作都会使得某一个数交换到正确的位置，因此交换的次数最多为 NN，整个方法的时间复杂度为 O(N)O(N)。

 

C++JavaPython3CGolang

 

 

#include

#include

#include

 

using namespace std;

 

class Solution {

public:

    int firstMissingPositive(vector& nums) {

        int n = nums.size();

        for (int i = 0; i < n; ++i) {

                cout<<" ******************  func751"<

                for (int i = 0; i < nums.size(); i++)

                {

 

                    cout <<"nums["<

                }

                cout<

            while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {

                swap(nums[nums[i] - 1], nums[i]);

                cout<<" ******************  func759 while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i])"<

                 for (int i = 0; i < nums.size(); i++)

                {

 

                    cout <<"   nums["<

                }

                cout<

            }

        }

cout<<" $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$  func   769  #############################33"<

                for (int i = 0; i < nums.size(); i++)

                {

 

                    cout <<"nums["<

                }

                cout<

        for (int i = 0; i < n; ++i) {

            if (nums[i] != i + 1) {

                return i + 1;

            }

        }

        return n + 1;

    }

};

 

int main()

{

    vector arry;

    Solution s;

 

    int result=0;

//C++ 输入一维数组

    for (int temp = 0; cin >> temp;)

    {   cout<<__LINE__<<"     "<

        arry.push_back(temp);//push_back 在数组的最后添加一个数据

        if (cin.get() == '\n')

            break;

    }

 

    cout << "输入元素个数为：" << arry.size()<

 

    for (int i = 0; i < arry.size(); i++)

    {

 

        cout <<"arry["<

    }

 

    result= s.firstMissingPositive(arry);

    cout << "输入元素______________________：" <

    cout<

 

   return 0;

}

 

 

203. 移除链表元素

难度简单400收藏分享切换为英文关注反馈

删除链表中等于给定值 val 的所有节点。

示例:

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

class Solution {

public:

    vector<int> res;

    ListNode* removeElements(ListNode* head, int val) {

        if(head != NULL)

        {

            for()

        }

    }

};

 

 

方法：哨兵节点

如果删除的节点是中间的节点，则问题似乎非常简单：

 

图后面有时间再上传吧

选择要删除节点的前一个结点 prev。

将 prev 的 next 设置为要删除结点的 next。

 

 

当要删除的一个或多个节点位于链表的头部时，事情会变得复杂。

 

 

 

可以通过哨兵节点去解决它，哨兵节点广泛应用于树和链表中，如伪头、伪尾、标记等，它们是纯功能的，通常不保存任何数据，其主要目的是使链表标准化，如使链表永不为空、永不无头、简化插入和删除。

 

 

 

在这里哨兵节点将被用于伪头。

 

算法：

 

初始化哨兵节点为 ListNode(0) 且设置 sentinel.next = head。

初始化两个指针 curr 和 prev 指向当前节点和前继节点。

当 curr != nullptr：

比较当前节点和要删除的节点：

若当前节点就是要删除的节点：则 prev.next = curr.next。

否则设 prve = curr。

遍历下一个元素：curr = curr.next。

返回 sentinel.next。

PythonJavaC++

 

class Solution {

  public:

  ListNode* removeElements(ListNode* head, int val) {

    ListNode* sentinel = new ListNode(0);

    sentinel->next = head;

 

    ListNode *prev = sentinel, *curr = head, *toDelete = nullptr;

    while (curr != nullptr) {

      if (curr->val == val) {

        prev->next = curr->next;

        toDelete = curr;

      } else prev = curr;

 

      curr = curr->next;

 

      if (toDelete != nullptr) {

        delete toDelete;

        toDelete = nullptr;

      }

    }

 

    ListNode *ret = sentinel->next;

    delete sentinel;

    return ret;

  }

};

复杂度分析

 

时间复杂度：\mathcal{O}(N)O(N)，只遍历了一次。

空间复杂度：\mathcal{O}(1)O(1)。

 

作者：LeetCode

链接：https://leetcode-cn.com/problems/remove-linked-list-elements/solution/yi-chu-lian-biao-yuan-su-by-leetcode/

来源：力扣（LeetCode）

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

 

class Solution {

public:

    ListNode* removeElements(ListNode* head, int val) {

 

        ListNode* dummy = new ListNode(0);

        dummy->next = head;

 

        ListNode* prev = dummy;

 

        while(prev->next)

        {

            if(prev->next->val == val)

            {

                ListNode* tmp = prev->next;

                prev->next = prev->next->next;

                delete tmp;

            }

            else

            {

                prev = prev->next;

            }

        }

 

        return dummy->next;

    }

};

 

作者：eric-345

链接：https://leetcode-cn.com/problems/remove-linked-list-elements/solution/c-by-eric-345-82/

来源：力扣（LeetCode）

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。