力扣刷题学习(跟随视频学着刷)

使用入门

视频链接

【手把手带你刷Leetcode力扣|各个击破数据结构和算法|大厂面试必备技能【已完结】-哔哩哔哩】 https://b23.tv/vIcRT61

时空复杂度

时间:

空间:主要有O(1)和O(n)两种,只用计算开辟的内存,若数组当做参数传进来了,不用计算数组的空间

数组

特点:适合读多写少

操作

  1. 创建数组
  2. 添加元素(追加元素在列表末端,时:O(1),否则为O(n))
  3. 访问元素(时:O(1))
  4. 修改元素(时:O(1))
  5. 删除元素
  6. 遍历数组
  7. 查找元素
  8. 数组长度
  9. 数组排序

相关习题

补充

在Python中,self参数是一个约定俗成的参数名,用于表示对象自身。它通常作为方法的第一个参数,用于引用当前正在调用该方法的对象。

python 复制代码
class Person:
    def _init_(self, name):
        self.name = name
    def introduce(self):
        print("My name is {self.name}.")

person = Person("Tom")
person.introduce()
python 复制代码
My name is Tom.

485. 最大连续 1 的个数

. - 力扣(LeetCode)

测试部分用例对了,还未找到错因

python 复制代码
def findMaxConsecutiveOnes(nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # 遍历列表,遍历到列表中的元素为1时:当前计数+1;碰到0时:将当前计数与最大计数对比,若当前计数大,则将当前计数覆盖最大计数,然后将当前计数归0,如此往复,最后返回当前计数和最大计数中的最大值(当列表最后一个元素为1时,也需要对比当前计数和最大计数)
        now_count = 0	# 当前计数
        final_count = 0 # 最大计数
        for i in range(len(nums)):
            if nums[i] == 1 :
                now_count += 1
            else:
                final_count = max(final_count, now_count)
                now_count = 0
        return max(final_count, now_count)
nums = [1,0,1,1,0,1]
print(findMaxConsecutiveOnes(nums))
python 复制代码
2

时:O(n)

空:O(1)

283. 移动零

. - 力扣(LeetCode)

python 复制代码
def moveZeroes(nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        # 特殊指针法,当前指针遍历列表,若当前指针遍历到非零元素,则将非零元素向前覆盖,然后继续往后遍历;若遍历到0元素,则计数加1。
        count = 0 # 计数,记录0元素个数,用于计算覆盖元素的位置
        for i in range(0,len(nums)):
            if nums[i] != 0:
                # 元素向前覆盖
                nums[i - count] = nums[i]
            else:
                count += 1
        # 后面元素覆0值
        for i in range(0, count):
            nums[len(nums) - 1 - i] = 0
        return nums
nums = [0,1,0,3,12]
print(moveZeroes(nums))
python 复制代码
[1, 3, 12, 0, 0]

易错点:(这个-1一定别忘了,假如此时count=1,代表只有一个0被覆盖了,此时应当是nums[len(nums) - 1] = 0)

时:O(n)

空:O(1)

27. 移除元素

. - 力扣(LeetCode)

python 复制代码
def removeElement(nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        # 特殊指针法,当前指针遍历列表,若当前指针遍历到非val元素,则将非零元素向前覆盖,然后继续往后遍历;若遍历到val元素,则计数加1。
        count = 0 # 计数,记录val元素个数,用于计算覆盖元素的位置
        for i in range(0,len(nums)):
            if nums[i] != val:
                # 元素向前覆盖
                nums[i - count] = nums[i]
            else:
                count += 1
        # 后面元素删除
        for i in range(0, count):
            nums.pop()
        return nums
nums = [3,2,2,3]
print(removeElement(nums, 3))
print(len(nums))
python 复制代码
[2, 2]
2

时:O(n)

空:O(1)

链表

相关习题

203.移除链表元素

. - 力扣(LeetCode)

cpp 复制代码
struct ListNode* removeElements(struct ListNode* head, int val) {
    // 头结点单独处理
    while(head != NULL && head->val == val){
        head = head->next;
    }
    if (NULL == head){
        return head;
    }
    struct ListNode *pre = head, *temp;
    while(pre->next != NULL){
        if(pre->next->val == val){   //该元素需要删除
            temp = pre->next;
            pre->next = temp->next;
            free(temp);
        }else{
            pre = pre->next;
        }
    }
    if(pre->val == val){
        free(pre);
    }
    return head;
}

时:O(n)

空:O(1)

206.反转链表

. - 力扣(LeetCode)

cpp 复制代码
struct ListNode* reverseList(struct ListNode* head) {
    if(head == NULL){
        return head;
    }
    // p用来遍历单链表,r是为了防止断链
    struct ListNode *p = head->next, *r;
    head->next = NULL;
    while( p != NULL){
        r = p->next;
        // 头插法将元素插入
        p->next = head;
        head = p;
        p = r;
    }
    return head;
}

时:O(n)

空:O(1)

2

cpp 复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
int power(int x, int n) {    //该函数用于实现计算x次幂,那么之后求n-1、n-2...次幂都可以用了
    while (n != 1) {
        return x*power(x, n - 1);
    }
    if (n == 1) {
        return x;
    }
}
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    /*
    算法思想:
    (1)用两个指针p、q分别遍历两个单链表,将p所指结点的数据一一加和到countl1中。
    (2)遍历第二个单链表,将q所指结点数据加和countl1到count中,
    (3)q在遍历期间,首先判断是否会进位,然后将count%10,count/10得到的数据覆盖链表l1的数据,为防止l1链表长度不够,还需要票判断链表是否为空(最后返回l1的数据)
    */

    struct ListNode *p = l1, *q = l2;   //p、q分别用来遍历l1、l2
    int countl1 = 0, count = 0;
    int i = 0;
    while(p != NULL){                   //遍历第一个单链表
        countl1 += (p->val * power(10, i));
        p = p->next;
        i++;
    }
    i = 0;
    int insertdata = 0,prepose = 0;     //insertdata是将要插入链表的数据,prepose控制进位
    p = l1;
    while(q != NULL){
        insertdata = countl1%10 + q->val;
        if(insertdata >= 10){    //需要进位
            insertdata /= 10;
            p->val = insertdata + prepose;
            prepose = 1;
        }else{                  //不需要进位
            p->val = insertdata + prepose;
            prepose = 0;
        }

        p = p->next;
        q = q->next;
        countl1 /= 10;
    }
    return l1;



}
cpp 复制代码
#include<iostream>
#include<cmath>
#include<cstddef>
using namespace std;
struct ListNode {
    int val;
    ListNode* next;
    
    ListNode(int value) : val(value), next(nullptr) {}
};

ListNode* createSList(int* nums, int sz) {
    ListNode* head = nullptr;
    ListNode* tail = nullptr;

    for (int i = 0; i < sz; ++i) {
        ListNode* newNode = new ListNode(nums[i]);

        if (tail == nullptr) {
            head = tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
    }

    return head;
}

void destroySList(ListNode* head) {
    while (head != nullptr) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6};
    int sz = sizeof(arr) / sizeof(arr[0]);

    ListNode* plist = createSList(arr, sz);

    // 在程序结束前释放链表占用的内存
    destroySList(plist);

    return 0;
}
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        /*
        算法思想:
        (1)用两个指针p、q分别遍历两个单链表,将p所指结点的数据一一加和到countl1中。
        (2)遍历第二个单链表,将q所指结点数据加和countl1到count中,
        (3)q在遍历期间,首先判断是否会进位,然后将count%10,count/10得到的数据覆盖链表l1的数据,为防止l1链表长度不够,还需要票判断链表是否为空(最后返回l1的数据)
        */
        struct ListNode *p = l1, *q = l2;   //p、q分别用来遍历l1、l2
        int countl1 = 0, count = 0;
        int i = 0;
        while(p != NULL){                   //遍历第一个单链表
            countl1 += (p->val * pow(10, i));
            p = p->next;
            i++;
        }
        i = 0;
        int insertdata = 0,prepose = 0;     //insertdata是将要插入链表的数据,prepose控制进位
        p = l1;
        while(q != NULL){
            insertdata = countl1%10 + q->val;
            if(insertdata >= 10){    //需要进位
                insertdata /= 10;
                p->val = insertdata + prepose;
                prepose = 1;
            }else{                  //不需要进位
                p->val = insertdata + prepose;
                prepose = 0;
            }
            p = p->next;
            q = q->next;
            countl1 /= 10;
        }
        return l1;
}
相关推荐
AI街潜水的八角几秒前
基于C++的决策树C4.5机器学习算法(不调包)
c++·算法·决策树·机器学习
白榆maple26 分钟前
(蓝桥杯C/C++)——基础算法(下)
算法
阿伟来咯~28 分钟前
记录学习react的一些内容
javascript·学习·react.js
JSU_曾是此间年少30 分钟前
数据结构——线性表与链表
数据结构·c++·算法
sjsjs1137 分钟前
【数据结构-合法括号字符串】【hard】【拼多多面试题】力扣32. 最长有效括号
数据结构·leetcode
Suckerbin1 小时前
Hms?: 1渗透测试
学习·安全·网络安全
水豚AI课代表1 小时前
分析报告、调研报告、工作方案等的提示词
大数据·人工智能·学习·chatgpt·aigc
聪明的墨菲特i1 小时前
Python爬虫学习
爬虫·python·学习
Diamond技术流1 小时前
从0开始学习Linux——网络配置
linux·运维·网络·学习·安全·centos
斑布斑布1 小时前
【linux学习2】linux基本命令行操作总结
linux·运维·服务器·学习