学习笔记 算法

最新推荐文章于 2024-06-01 20:08:47 发布
最新推荐文章于 2024-06-01 20:08:47 发布
阅读量177 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neflibata_mo/article/details/119522644
版权

一、 双指针

  1. 普通双指针：两个指针往同一个方向移动（有时不是同一个方向）
  2. 对撞双指针：两个指针面对面移动
  3. 快慢双指针：慢指针+快指针
  4. 例：a = [1,4,5,7,9]（有序数组） 两个数相加等于12，且两个数不能相同。
    对撞双指针：

例：检测是否为环形链表
快慢双指针：慢指针每次循环移动一格，快指针移动两格，最终是否相遇。

在这里插入图片描述

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null){
            return false;
        }   
        else{
            ListNode slow = head;
            ListNode fast = head;
            while(fast != null && fast.next != null){
                slow = slow.next;
                fast = fast.next.next;
                if (slow == fast){
                    return true;
                }
            }
            return false;
        }
    }
}

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if head == None:
            return False
        else:
            slow = head
            fast = head
            while(fast != None and fast.next != None):
                slow = slow.next
                fast = fast.next.next
                if slow == fast:
                    return True
            return False

在这里插入图片描述

class Solution {
    public int numRescueBoats(int[] people, int limit) {
        Arrays.sort(people);
        int low = 0,high = people.length-1,count = 0;
        while(low<=high){
            if(people[low]+people[high]>limit){
                count += 1;
                high -= 1;
            }
            else{
                count += 1;
                low += 1;
                high -= 1;
            }
        }
        return count;
    }
}

class Solution:
    def numRescueBoats(self, people: List[int], limit: int) -> int:
        people.sort()
        low = 0
        high = len(people)-1
        count = 0
        while(low<=high):
            if people[low]+people[high]>limit:
                count += 1
                high -= 1
            else:
                low += 1
                high -= 1
                count += 1
        return count

二、 二分查找法

  1. 特点：一定要有序（数组元素单调增或单调减）

  2. 例题
    在这里插入图片描述

class Solution {
    public int search(int[] nums, int target) {
        int low = 0,high = nums.length-1,mod;
        while(low<=high){
            mod = (low+high)/2;
            if(nums[mod]== target) {
                return mod;
            }
            else if(nums[mod]>target){
                high = mod - 1;
            }
            else {
                low = mod + 1;
            }
        }
        return -1;
    }
}

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        low = 0
        high = len(nums)-1
        while(low<=high):
            mod = (low+high)//2
            if nums[mod] == target:
                return mod
            elif nums[mod]>target:
                high = mod-1
            else:
                low = mod+1
        return -1

在这里插入图片描述

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if(matrix == null || matrix.length == 0){
            return false;
        }
        else{
            int row = matrix.length;
            int col = matrix[0].length;
            int l = 0;
            int r = row*col-1;
            while(l<=r){
                int m = l+(r-l)/2;
                int element = matrix[m/col][m%col];
                if(element == target){
                    return true;
                }
                else if(element>target){
                    r = m-1;
                }
                else{
                    l = m+1;
                }
            }
            return false;
        }       
    }
}

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        if matrix == None or len(matrix) == 0:
            return False
        else:
            row = len(matrix)
            col = len(matrix[0])
            l = 0
            r = row*col-1
            while(l<=r):
                m = l + (r-l)//2
                element = matrix[m//col][m%col]
                if element == target:
                    return True
                elif element > target:
                    r = m-1
                else:
                    l = m+1
            return False

三、滑动窗口

  1. 目的：减少while循环

  2. 应用：数组中的定长问题

  3. 例题：
    在这里插入图片描述

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int res = nums.length+1;
        int i = 0,j = 0,total = 0;
        while(j<nums.length){
            total += nums[j];
            while(total>=target){
                res = Math.min(res, j - i + 1);
                total -= nums[i];
                i += 1;
            }
            j++;
        }
        if (res == nums.length+1){
            return 0;
        }
        else{
            return res;
        }
    }
}

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        res = len(nums)+1
        count = 0
        i = 0
        j = 0
        while(j<len(nums)):
            count = count+nums[j]
            while(count>=target):
                res = min(res,j-i+1)
                count = count - nums[i]
                i = i+1
            j+=1
        if res == len(nums)+1:
            return 0
        else:
            return res

在这里插入图片描述

class Solution {
    public int maxVowels(String s, int k) {
        int i,count = 0,res = 0;
        char[] ch = s.toCharArray();
        String str = "aeiou";        
        for (i = 0;i<k;i++){
            if (str.indexOf(ch[i])!=-1){
                count+=1;
            }
                }
        res = Math.max(res,count);
        for (i = k;i<s.length();i++){
            if (str.indexOf(ch[i-k])!=-1){
                count -= 1;
            }
            if (str.indexOf(ch[i])!=-1){
                count += 1 ;
            }
            res = Math.max(res,count);
        }
        return res;
    }
}

class Solution:
    def maxVowels(self, s: str, k: int) -> int:
        i = 0
        count = 0
        res = 0
        for i in range(k):
            if s[i] in "aeiou":
                count+=1
        res = max(res,count)
        for i in range(k,len(s)):
            if s[i-k] in "aeiou":
                count -= 1
            if s[i] in "aeiou":
                count += 1 
            res = max(res,count)
        return res

四、递归

  1. 定义：函数直接或者间接调用自己

  2. 四个要素：

  • 接受的参数
  • 返回值
  • 终止条件
  • 递归拆解：如何递归下一层
recursion(int n):	#参数
	if n == 0:		#终止条件
		return 0	
	m = recursion(n-1)	#拆解
	return m		#返回的值
  1. 例题
    在这里插入图片描述
class Solution {
    public int fib(int n) {
        if(n<2){
            return n;
        }
        else{
            return fib(n-1)+fib(n-2);
        }
    }
}

class Solution:
    def fib(self, n: int) -> int:
        if n<2:
            return n
        else:
            sum = self.fib(n-1)+self.fib(n-2)
            return sum

在这里插入图片描述

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        while(head != null && head.next != null){
            ListNode dnext = dummy.next;
            ListNode hnext = head.next;
            dummy.next = head.next;
            head.next = hnext.next;
            hnext.next = dnext;
        }
        return dummy.next; 
    }
}

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        while(head != None and head.next!= None):
            dnext = dummy.next
            hnext = head.next
            dummy.next = hnext
            head.next = hnext.next
            hnext.next = dnext
        return dummy.next

五、分治法

大问题切割成一个个小问题，最后再合并。
用到了递归，自己调用自己。

在这里插入图片描述

class Solution:
    def getNajority(nums,left,right):
        if left == right:
            return nums[left]
        else:
            mid = left+(right-left)//2
            leftNajority = getNajority(nums,left,right)
            rightNajority = getNajority(nums,mid+1,right)
            if leftNajority == rightNajority:
                return leftNajority
            else:
                leftcount = 0
                rightcount = 0
                for i in nums[left,right]:
                    if i == leftNajority:
                        leftcount+=1
                    elif i == rightNajority:
                        rightcount+=1
                if leftcount > rightcount:
                    return leftNajority
                else:
                    return rightNajority
    def majorityElement(self, nums: List[int]) -> int:
        return getNajority(nums,0,len(nums)-1)

六、回溯法

类似枚举，一层一层向下递归，尝试搜索答案。

  • 找到答案后，尝试别的可能或返回答案。
  • 找不到答案，则返回上一层递归，尝试别的路径。

七、深度优先搜索算法 （DFS）

  1. 用到了递归的思想。
  2. DFS：从root节点开始，尽可能深的搜索每一个分支。（把一个分支的结果搜索完，再去看下一个分支）
  3. 主要应用：
  • 二叉树搜索
  • 图搜索
  1. 例：走迷宫
  2. DFS和回溯算法的区别：回溯算法 = DFS + 剪枝

八、广度优先搜索算法（BFS）

  1. 主要思想：层层递进，一层一层遍历
  2. 主要应用：
  • 二叉树搜索
  • 图搜索
  1. DFS与BFS的区别：
    侧重点不同：
  • DFS：分支
  • BFS：层

九、并查集（Union Find）

  1. Union：合并两个元素为同一个根节点
  2. Find：找到某个元素的根节点

十、贪心算法（Greedy）

  1. 核心：
  • 每一步做出的都是当前看起来最好的选择
  • 只是局部的最优选择
  • 而不是整体的最优选择
  1. 例：零钱兑换 最少硬币的情况，应当尽可能取大的硬币

十一、算法记忆化（Memoization）

  1. 目的：减少重复计算

十二、动态规划

  • 题型千变万化
  • 思想千变万化

动态规划三要素：

  • 初始状态（可能是一个数，也可能是多个数）
  • 方程式（状态转移函数）
  • 终止状态
    应用：
  1. 计数：有多少种方式/方法
    例：机器人从左上角到右下角有多少个路径
  2. 求最值：最大值/最小值
    例：机器人从左->右路径的最大数字和
  3. 求存在性：是否存在某个可能
    例：是否存在机器人从左->右的路径

在这里插入图片描述

class Solution {
    public int fib(int n) {
        if(n<2){
            return n;
        }
        else{
            int dp[] = new int[n+1];
            dp[0] = 0;
            dp[1] = 1;
            for(int i=2;i<n+1;i++){
                dp[i] = dp[i-1] + dp[i-2];
            }
            return dp[n];
        }
    }
}

在这里插入图片描述

class Solution {
    public int uniquePaths(int m, int n) {
        int [][] dp =new int[m][n];
        dp[0][0] = 1;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(i-1>=0 && i-1<m){
                    dp[i][j] = dp[i][j]+dp[i-1][j];
                }
                if(j-1>=0 && j-1<n){
                    dp[i][j] = dp[i][j]+dp[i][j-1];
                }
            }
        }
        return dp[m-1][n-1];
    }
}
Neflibata_mo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
因果发现学习笔记 PC 算法详解
叶庭云 成为自己的光
02-28 1535
因果发现学习笔记 PC 算法详解
学习笔记算法
11-23
学习笔记算法
数据结构与算法学习笔记
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
插值算法 学习笔记
qq_52139682的博客
02-18 2664
清风老师的数学建模课学习笔记
学习笔记-Grover 算法
qq_43509553的博客
03-08 3186
Grover 算法
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 39万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
RCNN算法学习笔记
fuchengui的博客
03-16 2342
Region CNN(RCNN)可以说是利用深度学习进行目标检测的开山之作。 Girshick, Ross, et al. “Rich feature hierarchies for accurate object detection and semantic segmentation.” Proceedings of the IEEE conference on computer vision and pattern recognition. 2014.【经典文章】 ———————————————— 参
学习笔记 | 算法导论学习笔记1
Justlovesmile的博客
03-13 3060
《算法导论》打卡1，主要内容：插入排序，分治法，归并排序 第一部分 基础知识 第一章 算法在计算中的作用 1.1 算法 算法就是任何良定义的计算过程，该过程取某个值或值的集合作为输入并产生某个值或者值的集合作为输出。 规范书写： 问题：XXXX 输入：XXXXXXXX 输出：XXXXXXXX 算法步骤： 1.XXXXXXXXXXX 2.XXXXXXXXXXX 注意问题与问题实例的区别。 1.2 作为一种技术的算法 考虑效率：时间与空间资源的消耗 第二章 算法基础 2.1 插入排序 输入：n个
左程云算法学习笔记
qq_45753992的博客
02-11 7265
左程云算法笔记学习简介认识复杂度，对数器，二分法与异或线段树（区间修改树）功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 学习简介 2021寒假学习算法，在B站看到了左程云的算法，看了一下还不错。 认识复杂度，对数器，二分法与异或
unet v2学习笔记
jacke121的专栏
12-14 1250
unet v2学习笔记
学习笔记：Feistel算法
god_001的博客
10-09 2546
Feistel建议使用乘积密码的概念来逼近理想分组密码，他建议密码交替地使用代替和置换。 使用Feistel密码结构，明文分组被分为等长的LE，RE两部分，对这两部分数据进行n次轮换迭代后组合成密文。每一轮得到的输出就是下一轮的输入。 加密方法是： 第一轮次： …… 第n轮次： 最终得到输出密文为： 其中Ki是每一轮次的子密钥，是由整个密钥K推导出的;轮函数F是w位长的右半分组和y位长的子密钥的函数，其输出结果是一个w位长的值。 解密算法： Feistel的解密算法其实就是对其
算法学习笔记
02-25
算法学习笔记
算法导论 学习笔记.pdf
05-04
算法导论 学习笔记
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 504
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
算法训练营day41
stmfresher的博客
05-27 351
动态规划理论基础（主要就是确定动态规划的几个步骤）
【LeetCode刷题】二分查找：寻找旋转排序数组中的最小值、点名
最新发布
认真分享博客，认真分享学习
06-01 500
与 当前数组各个数异或，若结果为x，则返回x；当x等于0时，需要格外处理，有两种情况，缺0或者是最后一个数后面的数。这道题的二分查找很有趣，需要细节，能发现二段性，这题就相当简单。若结果为x，则返回x；当x等于0时，需要格外处理，与思路3一样。遍历数组，寻找后一位减前一位的差为2的数，找到就返回，没找到就返回最后一个数的下一个。这里我们可以有两种方式：以A为参照，以D为参照，来找C点的值。这道题很简单，有很多思路，简单的我就直接讲一下过程就OK。分别将数据导入哈希表，然后查看哪个数的个数为零，返回该值。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 684
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
图形学初识--空间变换
航行的土豆的博客
05-29 858
介绍二维和三维下的变换矩阵以及常见的推导和理解方式。主要就是：平移、旋转、缩放
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 936
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
算法个人学习笔记pdf
07-17
算法个人学习笔记pdf是一种以电子文档形式呈现的算法学习笔记资源。在这个pdf中，个人学习者可以记录和整理自己在学习算法过程中的思考、心得和解题方法。在这个学习笔记pdf中，个人学习者可以自由地添加和编辑自己...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值