极客03练习题目笔记

最新推荐文章于 2023-02-25 15:01:38 发布
最新推荐文章于 2023-02-25 15:01:38 发布
阅读量460 收藏
点赞数
分类专栏： 极客算法学习 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35412050/article/details/107913395
版权 
一些小结：勉励自己
1.从计划刷题以来，出现了一些方法策略的错误，在朋友的帮助下，慢慢回到正轨，效率up 开心up
2.代码写完要向优秀代码学习，对自己的代码进行优化，比如格式，判断语句如何写更精炼
3.判断，循环类语句注意空格 例：for 🈳️（....）
4.加油，没有翻不过的大山，没有什么是战胜不了的，坚持，成为一种习惯

283.移动零easy

class Solution {
    public void moveZeroes(int[] nums) {
        

        int j = 0;
        for(int i = 0;i < nums.length;++i){
            if(nums[i] != 0){
                nums[j] = nums[i];
                if (i != j){
                    nums[i] = 0;
                }
                j++;
            }
            
        }
    }
}

11.盛水最多的容器medium

【way 1】嵌套循环遍历

class Solution {
    public int maxArea(int[] height) {
            int max = 0;
            for (int i = 0; i < height.length - 1; ++i){
                for (int j = i + 1; j < height.length; ++j){
                    //int area = _getArea(i,j);
                    int area = (j - i) * Math.min(height[i], height[j]);
                    max = Math.max(max, area);

                }
            }
        
        return max;
    }
}

【way 2】左右边界，向中间收敛，O(n)
简称：左右夹逼

class Solution {
    public int maxArea(int[] a) {
        int max = 0;
        for(int i = 0,j = a.length - 1;i < j;){
            int minHeight = a[i] < a[j] ? a[i ++] : a[j --];
            int area = (j - i + 1) * minHeight;
            max = Math.max(max, area);
        }
        return max;
    }
}

70爬楼梯 easy

思想：最近重复子问题
1:1
2:2
3:f(1) + f(2)
4:f(2) + f(3)
:
n:f(n-1)+f(n-2)
本质：Fibonacci数列

class Solution(object):
    def climbStairs(self, n):
        if(n <= 2): return n
        f1,f2,f3 = 1, 2, 3
        for i in range(3, n+1):
            f3 = f1 + f2
            f1 = f2
            f2 = f3
        return f3

1 两数之和easy

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i = 0;i < nums.length;i++){
            for(int j = i+1;j < nums.length;j++){
                if(nums[j] == target - nums[i]){
                    return new int[]{i,j};
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] a = new int[2];
        int numsSize = nums.length;
        for(int i = 0;i < numsSize - 1;i++){
            for(int j = i + 1;j < numsSize;j++){
                if(nums[i] + nums[j] == target){
                    a[0] = i;
                    a[1] = j;
                    return a;
                }

            }
        }
        return new int[0];
        
    }
}

15 三数之和-med-高频老题

双指针法-首先排序
空间复杂度 O(1)：指针使用常数大小的额外空间

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //a + b = -c
        //1.暴力求解O(n ^ 3)
        //2.hash表
        //3.双指针，左右下标往中间推进
        Arrays.sort(nums);//排序
        List<List<Integer>> res = new ArrayList<>();
        for(int k =0; k < nums.length - 2; k++){
            if(nums[k] > 0) break;
            if(k > 0 && nums[k] == nums[k - 1]) continue;
            int i = k + 1, j = nums.length - 1;
            while(i < j){
                int sum = nums[i] + nums[j] + nums[k];
                if(sum < 0){
                    while(i < j && nums[i] == nums[++i]);
                }
                else if(sum > 0){
                    while(i < j && nums[j] == nums[--j]);
                }
                else{
                    res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[i], nums[j])));
                    while(i < j && nums[i] == nums[++i]);
                    /*while(i < j){
                        i = i + 1;
                        if(nums[i -1] == nums[i]){
                            //do sth
                        }
                    }*/
                    while(i < j && nums[j] == nums[--j]);
                }
            }
        }
        return res;
    }
}

141.环形链表easy

class Solution {
public:
    bool hasCycle(ListNode *head) {
        //int pos = -1;
        //快慢指针，也可用哈希表（目前未实现）
        ListNode* slow = head;
        ListNode*  fast= head;
         if(!head || !head->next) return nullptr;
        while(fast && fast -> next ){
            slow = slow -> next;
            fast = fast -> next -> next;
            if(fast == slow){
                return true;
            }
        }

      return false;  
    }
};

142.环形链表2 MED

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast -> next != NULL){
            slow = slow -> next;
            fast = fast -> next -> next;
            //快慢指针相遇，确认环的入口点，思路还需再思考
            if(slow == fast){
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2){
                    index1 = index1 -> next;
                    index2 = index2 -> next;
                }
                return index2;
            }
        }
        return NULL;   
    }
};

25.K个一组翻转链表-hard

【way1 原地翻转】

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        //原地翻转链表
        ListNode* dummyhead = new ListNode(-1);
        dummyhead -> next = head;
        ListNode* starts = head;//记录移动的后面一个指针
        ListNode* ends = head;//每次需要翻转的第k个指针
        ListNode* pre = dummyhead;//记录当前的头指针
        ListNode* nexts,*cur;//cur 记录当前要移动的指针
        //链表翻转
        while(1){
            for (int i = 0; i < k - 1; i++){
                if (ends == NULL){
                    break;
                }
            
            ends = ends -> next;
        }
        if(ends == NULL){
            break;
        }
        nexts = ends -> next;
        //原地翻转
        for(int i = 0; i < k - 1;i ++){
            cur = starts;
            starts = starts -> next;

            pre -> next = starts;
            cur -> next = ends -> next;
            ends -> next = cur;
        }
        starts = nexts;
        ends = nexts;
        for(int i = 0; i < k;i++){
            pre = pre -> next;
        }  
        
    }
    return dummyhead -> next;
}
};

【way2 头插法】

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* dummynode = new ListNode(-1);
        ListNode* current = head;
        ListNode* starts = head;
        ListNode* nexts = starts -> next;
        ListNode* pre = dummynode;
        pre -> next = NULL;
        while(1){
            for(int i = 0;i < k -1; i++){
                if(current == NULL){
                    break;
                }
                current = current -> next;
            }
            if(current == NULL){
                break;
            }
            for(int i = 0; i < k; i++){
                nexts = starts -> next;
                starts -> next = pre -> next;
                pre -> next = starts;
                starts = nexts;
            }
            //头插前k个指针
            for(int i = 0; i < k;i++){
                pre = pre -> next;
            }
            current = nexts;
        
        }
        while(starts){
            pre -> next = starts;
            pre = pre -> next;
            starts = starts -> next;
        }
        pre -> next = NULL;
        return dummynode -> next;


        
    }
};

21.合并两个有序链表

【way 1 递归】

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        //注意题意，l1 和 l2 都是升序的
        if(l1 == nullptr ){
            return l2;
        } else if (l2 == nullptr){
            return l1;
        } else if(l1 -> val < l2 -> val ){
            l1 -> next = mergeTwoLists(l1 -> next,l2);
            return l1;
        } else{
            l2 -> next = mergeTwoLists(l1,l2 -> next);
            return l2;
        } 
    } 
    
};

【way 2 迭代】


public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        //迭代
        ListNode* preHead = new ListNode(-1);//哨兵节点
        ListNode* prev = preHead;//全程借助prev 不断调整prev指针的next

        while (l1 != nullptr && l2 != nullptr){
            if (l1 -> val < l2 -> val){
                prev -> next = l1;
                l1 = l1 -> next;
            } else {
                prev -> next = l2;
                l2 = l2 -> next;
            }
            prev = prev -> next;  
        }
        //合并剩余的
        prev -> next = l1 == nullptr ? l2 : l1;
        return preHead -> next; 
    }
};

88.合并两个有序数组Easy🤔

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i = nums1.size() - 1;
        m --;
        n --;
        while(n >= 0){
            while (m >= 0 && nums1[m] > nums2[n]){
                swap(nums1[i --],nums1[m --]);
            }
            swap(nums1[i--],nums2[n--]);
        }    
    }
};

二叉树遍历思路-递归方法，未主动维护一个栈
使用一个存放结果的动态数组res 存放结果
子函数实现递归调用

94.二叉树的中序遍历

class Solution {
public:
//递归，未主动维护一个栈
    void mid_order(TreeNode* root,vector<int>& res){
        if(root == NULL){
            return;
        }
        mid_order(root -> left,res);
        res.push_back(root -> val);
        mid_order(root -> right,res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        mid_order(root,res);
        return res;

        
    }
};

144.二叉树的前序遍历

class Solution {
public:
    void pre_order(TreeNode* root,vector<int>& res){
        if(root == NULL) return;
        res.push_back(root -> val);
        pre_order(root -> left,res);
        pre_order(root -> right,res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        pre_order(root,res);
        return res;

    }
};

590.n叉树的后序遍历

class Solution {
public:
    vector<int> res;
    void order(Node* root){
        Node* tmp;
        for(int i = 0;i < root -> children.size();i++){
            tmp = root -> children[i];
            order(tmp);
        }
        res.push_back(root -> val);
    }
    vector<int> postorder(Node* root) {
        //vector<int> res;
        if(!root) return res;
        order(root);
        return res;
        
    }
};

589.n叉树的前序遍历

class Solution {
public:
    vector<int> res;
    void order(Node* root){
        Node* tmp;
        res.push_back(root -> val);
        for(int i = 0;i < root -> children.size();i++){
            tmp = root -> children[i];
            order(tmp);
        }
    }

    vector<int> preorder(Node* root) {
        if(!root) return res;
        order(root);
        return res;
        
    }
};

70.爬楼梯

#找 最近 重复子问题

#if else
# for while recursion
#只有两种可能性：走一步或者走两步
#1: 1
#2: 2
#3: f（1）+ f（2），mutual exclusive，complete exhaustive
#4: f（2）+ f（3）
#f（n） = f（n-1） + f（n-2）：Fibonnacci
class Solution(object):
    def climbStairs(self, n):
        if(n <= 2): return n
        f1,f2,f3 = 1, 2, 3
        for i in range(3, n+1):
            f3 = f1 + f2
            f1 = f2
            f2 = f3
        return f3

22.括号生成

class Solution {
    private List<String> result;

    public List<String> generateParenthesis(int n) {
        result = new ArrayList<String>();
        _generate(0, 0, n, "");
        return result;
    }
    private void _generate(int left, int right, int n, String s) {//java 不要用太多的大写
        //terminator
        if ( left == n && right == n){
            System.out.println(s);
            result.add(s);
            return ;
        }
        /*if (level >= max) {
            //filter the invalid   
            // left： 随时加，只要超标 right 必须之前有左括号，且左括号> 右括号
            System.out.println(s);
            return;
        }*/
        //process current logic:left, right
        /*代码优化
        String s1 = s + "(";
        String s2 = s + ")";
        */


        //drill down
        if(left < n){
            _generate(left + 1,right, n, s + "(");

        }
        if(left > right ){
            _generate(left, right + 1, n, s + ")");
        }
        //_generate(level + 1,max, s + "(";
        //_generate(level + 1,max, s + "(");

        //reverse states 

    }

    
}

50.Pow(x , n)

class Solution {
public:
    double subproblem(double x, long long  n){
        if(n == 0) return 1;
        if(n == 1) return x;
        double subresult = subproblem(x, n / 2);

        if(n % 2 == 1) {
            return subresult * subresult * x;
        }else{
            return subresult * subresult;
        }
        

    }
    double myPow(double x, int n) {
        long long N = n;
        if (N < 0){
            x = 1 / x;
            N = - N;
        }
        return subproblem(x ,N);

    }
    
};
//听课思路记录
 /*
        1.暴力
        result = 1
        for i: 0 -> n{
            result *= x
        }
        O(n)
        */

        //2.牛顿迭代法，难

        /*3.分治：转换成子问题
        template：1.terminator 2.process(spilt your big problem) 3.drill down(subproblems,merge(subresult))4.reverse states
        x^n --> 2^10 : 2^5 -> (2^2)*2

        pow(x,n):
            subproblems: subresult = pow(x,n/2)
        log(N)

        merge:
            if(n % 2 == 1){
                // odd
                result = subresult * subresult * x;
            }else{
                // even
                result = subresult * subresult;

            }
        */

78.子集

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();

        if(nums == null) { return ans; }
        dfs(ans, nums, new ArrayList<Integer>(), 0);
        return ans;
    }
    private void dfs(List<List<Integer>> ans, int[] nums, List<Integer> list, int index) {
        // terminator 终结者
        if (index == nums.length) {
            ans.add(new ArrayList<Integer>(list));
            return;
        }

        dfs(ans, nums, list, index + 1);//not pick the number at this index

        list.add(nums[index]);
        dfs(ans, nums, list, index + 1);// pick the number at this index

        // reverse the current state
        list.remove(list.size() - 1);
    }
}

【python】

class Solution(object):
    def subsets(self, nums):
        """
        迭代法
        """
        subsets = [[]]

        for num in nums:
            newsets = [];
            for subset in subsets:
                new_subset = subset + [num]
                newsets.append(new_subset)
            subsets.extend(newsets);

        return subsets

【python3】

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = [[]];
        for i in nums:
            res = res + [[i] + num for num in res]简写，掌握
        return res
Alina_zzz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
成功解决Error：invalid character in identifier
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
04-16 1万+
成功解决Error：invalid character in identifier 目录 解决问题 解决思路 解决方法 解决问题 解决思路 错误:标识符中的字符无效 解决方法 将单引号改为双引号即可！ 将代码改为 str1104=str02+"\n"+str03+"\n"+str04+"\n"+st...
LeetCode高频题目
Fred_18的博客
10-29 2013
字符串 3 无重复字符的最长字串(medium 高) 5 最长回文子串(medium 高) 22 括号生成(medium 高) 13 罗马数字转整数(easy 高) 6 Z字形变换(medium 高) 38 报数(easy 高) 17 电话号码的字母组合(medium 高) 10 正则表达式匹配(hard 高) 20 有效的括号(easy 高) 72 编辑距离(hard 高) 12 整数转罗马数字...
plot_pseudotime_heatmap报错Error in intI(i, n = x@Dim[1], dn[[1]], give.dn = FALSE) : invalid chara
weixin_54434521的博客
02-25 1013
原因a向量中有部分基因不在HSMM的行名中。解决办法，删除这部分基因即可。
极客时间算法训练营2019版LeetCode练习题题库
m0_46596994的博客
10-18 515
03课 数组、链表、跳表 两数之和题目 Arrays实战 LeetCode#11 盛最多水的容器 LeetCode#283 移动零 LeetCode#70 爬楼梯 LeetCode#15 三数之和 Linked List 实战题目 #141 环形链表 #206 反转链表 #24 两两交换链表中的节点 #92 反转链表II #25 k个一组翻转链表 课后作业 #26 删除有序数组中的重复项 #189 旋转数组 #21 合并两个有序链表 #88 合并两个有序数组 #1 两数之和题目 #283 移动零 #66 加
史上最全的小白常犯的python错误及改正方法
weixin_38410551的博客
06-05 419
IndentationError:unexpected indent 错误原因：缩进错误 链接： https://blog.csdn.net/weixin_42717711/article/details/82800192
极客小马笔记
02-26
极客小马笔记
seatgeek-frontend:座椅极客前端练习
05-29
Seatgeek 前端编码测试 您好，欢迎来到 SeatGeek 的前端编码测试，这是一种为您的一天增添乐趣的可验证方式！ 在这个挑战中，您的任务是在我们的之后对名为 Chairnerd 的个人博客实用程序进行一些开发工作。...
myHomeMaker:设置我的极客笔记本电脑！
03-20
我的家庭制作工具 TLDR； 要求： Linux / Mac安装程序： ...关闭所有打开的终端窗口，然后重新打开以运行命令： config 要将您的设置更新为最新的应用程序版本，只需运行： update ... LogLine格式化程序可向此执行...
JAVA极客学院笔记
03-31
JAVA极客学院笔记
极客时间算法练习题总结
约定的博客
11-14 742
文章出处：极客时间《数据结构和算法之美》-作者：王争。该系列文章是本人的学习笔记。 在极客时间《数据结构和算法之美》最后，王争老师加餐了7天训练内容，对每一部分需要掌握的数据结构与算法做了总结。现在我把这些题目放在一起，并且和自己写的代码做了超链接。 数组 实现一个支持动态扩容的数组 实现一个大小固定的有序数组，支持动态增删改操作 实现两个有序数组合并为一个有序数组 ...
二叉树面试题总结（Java）
qq_15720911的博客
08-08 641
本文参考博客：http://www.jianshu.com/p/0190985635eb 先上二叉树的数据结构： class TreeNode{ int val; //左孩子 TreeNode left; //右孩子 TreeNode right; } 二叉树的题目普遍可以用递归和迭代的方式来解 1.求二叉树的最大深度 int maxDea
极客网个人刷题记录汇总
qq_21924213的博客
04-10 374
1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 /** * 思路：左下角的值是一行中最小，一列中最大的，所以从这个值开始比较，如果比这个值大，就将列加1，再比较， * 如果比这个值小，就将行加1，往上查，总的时间复杂度为O...
二叉树的典型习题总结
qq_41185460的博客
01-19 4769
二叉树的三种遍历方式： 1.给定一个二叉树，返回它的前序遍历。root-left-right 递归实现： public List<Integer> preorderTraversal(TreeNode root) { List<Integer> list = new ArrayList<>(); //每次遍历都会产生一个新的...
超级楼梯
11-13 267
超级楼梯 Time Limit: 1000ms   Memory limit: 32768K  有疑问？点这里^_^ 题目描述 有一楼梯共M级，刚开始时你在第一级，若每次只能跨上一级或二级，要走上第M级，共有多少种走法？ 输入 输入数据首先包含一个整数N，表示测试实例的个数，然后是N行数据，每行包含一个整数M（1 输出 对于每个测试实例，请输出不同走法的数量。 示例
python_错题本
热门推荐
CSDN
01-03 1万+
  1.转义: 右斜杠  \       除: 左斜杠    / 2. 报错类型 print（'hello'）     print(“hello”) #中文圆括号、引号，出现以下错误 SyntaxError: invalid character in identifier（翻译：标识符中无效字符） print(萨达)     #不加引号，会出现以下错误 变量没定义 3.py...
R语言：使用SMOTE出现错误
qq_35155649的博客
12-03 8082
错误1、“length of 'dimnames' [2] not equal to array extent” 我的原代码： balanceData &lt;- SMOTE(status~.,selecData,perc.over=500,perc.under=100) 错误原因是将tibble数据结构传入了DMwR::SMOTE()，使用as.data.frame（）将数据un-tib...
Python极客项目编程.pptx
最新发布
10-13
第七部分，Python极客项目编程读书笔记。本部分为作者对前六部分内容的总结和思考，帮助读者巩固所学知识，并提供进一步学习的方向和资源。 通过阅读《Python极客项目编程》，读者可以系统地学习Python编程的各个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值