算法总结案例

已于 2024-01-26 11:08:39 修改
阅读量162 收藏 1
点赞数
分类专栏： 数据结构算法 文章标签： 算法 leetcode 数据结构
于 2023-02-12 22:46:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GZ946/article/details/129001207
版权

算法总结案例


本文分享力扣算法学习，每日一算法
力扣官网链接链接

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

  • 我的答案
class Solution {
    public int[] twoSum(int[] nums, int target) {
           int[] result= new int[2];
           int length= nums.length;
           for(int i=0;i<length;i++){
               for(int j=i+1;j<length;j++){
                 if (nums[i]+nums[j] == target){
                    return new int[]{i, j};
                 }
               }
           }
           return new int[0];
    }
}
  • 官网答案
class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(target - nums[i])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
}

*总结
通过空间换时间，通过使用哈希数据结构，把数与索引值放到hash里面进判断

2.回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true
示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。

  • 答案
class Solution {
    public boolean isPalindrome(int x) {

       if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int revertedNumber =0;

        while(x>revertedNumber){
           revertedNumber = revertedNumber * 10 + x % 10;
            x/=10;
        }
       return x == revertedNumber || x == revertedNumber / 10;
        
    }
}
  • 总结
    充分利用了取模，除法运算

3.罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数

  • 答案
class Solution {
    Map<Character, Integer> symbolValues = new HashMap<Character, Integer>() {{
        put('I', 1);
        put('V', 5);
        put('X', 10);
        put('L', 50);
        put('C', 100);
        put('D', 500);
        put('M', 1000);
    }};

    public int romanToInt(String s) {
         int ans = 0;
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            int value = symbolValues.get(s.charAt(i));
            if (i < n - 1 && value < symbolValues.get(s.charAt(i + 1))) {
                ans -= value;
            } else {
                ans += value;
            }
        }
        return ans;

    }
}
  • 总结
    罗马数字，一般是右边比左边大，进行加法运算，但有个例，左边比右边小，直接减

4.最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1：

输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”
示例 2：

输入：strs = [“dog”,“racecar”,“car”]
输出：“”
解释：输入不存在公共前缀。

  • 我的答案
class Solution {
   public static String longestCommonPrefix(String[] strs) {
        String result="";
        if(strs.length==1){
            result = strs[0];
            return result;
        }
        for(int i=0;i<strs[0].length();i++){
            char c=strs[0].charAt(i);
            for(int j=1;j<strs.length;j++){
               if(strs[j].length()>i){
                   char b=strs[j].charAt(i);
                   if(c==b && j==strs.length-1){
                       result=result+c;
                   }else if(c==b){
                       continue;
                   }else{
                       return result;
                   }
               }else{
                   return result;
               }

            }
        }
        return result;
    }
          
}
  • 官方答案
class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int length = strs[0].length();
        int count = strs.length;
        for (int i = 0; i < length; i++) {
            char c = strs[0].charAt(i);
            for (int j = 1; j < count; j++) {
                if (i == strs[j].length() || strs[j].charAt(i) != c) {
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    }
}

5.有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = “()”
输出：true
示例 2：

输入：s = “()[]{}”
输出：true
示例 3：

输入：s = “(]”
输出：false

  • 答案
class Solution {
     public boolean isValid(String s) {
        int n = s.length();
        if (n % 2 == 1) {
            return false;
        }

        Map<Character, Character> pairs = new HashMap<Character, Character>() {{
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        Deque<Character> stack = new LinkedList<Character>();
        for (int i = 0; i < n; i++) {
            char ch = s.charAt(i);
            if (pairs.containsKey(ch)) {
                if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
                    return false;
                }
                stack.pop();
            } else {
                stack.push(ch);
            }
        }
        return stack.isEmpty();
    }

}
  • 总结
    这里巧妙用到了栈的数据结构，先进后出
    stack.pop 从栈顶移除元素
    stack.push从栈顶添加元素
    stack.peek从栈顶获取元素
    例如 ：({})、（）、{}
    先把左元素放入栈中，然后右元素进行对比，有则从栈顶移除，没有，说明不对称

6.合并两个有序链表

在这里插入图片描述

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            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;
        }
    }
}
  • 总结
    运用递归算法进行层层比较，赋值

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

在这里插入图片描述

  • 答案
class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
}
  • 总结
    这个需要认真读懂题意，需要断言判断nums,取重后，按照返回结果循环遍历取值，说明nums 里面值进行前后比较，移动覆盖

8.移除元素

在这里插入图片描述

  • 我的答案
class Solution {
    public int removeElement(int[] nums, int val) {
       int len=nums.length;
        int mid;
        int result=0;
        for(int i=0;i<len;i++){
            if(nums[i]==val){
                mid=nums[i];
                for(int j=i+1;j<len;j++){
                    if(nums[j] != val){
                        nums[i]=nums[j];
                        nums[j]=mid;
                        result++;
                        break;
                    }
                }
            }else{
                result++;
            }
        }
        return result;
    }
}
  • 官方答案
class Solution {
    public int removeElement(int[] nums, int val) {
        int n = nums.length;
        int left = 0;
        for (int right = 0; right < n; right++) {
            if (nums[right] != val) {
                nums[left] = nums[right];
                left++;
            }
        }
        return left;
    }
}
  • 总结
    我的方法就比较麻烦了，我刚开始思路是，与val相等，就进行替换，那么应该替换到那一个呢，那就是与val不相等的值。我当时也想，可不可以记录替换的位置，进行下一次不相等的值进行替换，这个思路就截止到这，官方的答案确实这个思路进行实现的，不是相邻位置替换，是对记录位置进行替换

9.找出字符串中第一个匹配项的下标

在这里插入图片描述

  • 暴力解法
    在这里插入图片描述
    在这里插入图片描述
class Solution {
    public int strStr(String haystack, String needle) {
      int n = haystack.length(), m = needle.length();
        for (int i = 0; i + m <= n; i++) {
            boolean flag = true;
            for (int j = 0; j < m; j++) {
                if (haystack.charAt(i + j) != needle.charAt(j)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                return i;
            }
        }
        return -1;


    }
}
  • 官方答案
    运用kmp算法
class Solution {
    public int strStr(String haystack, String needle) {
        int n = haystack.length(), m = needle.length();
        if (m == 0) {
            return 0;
        }
        int[] pi = new int[m];
        //获取next数组，里面的值为前缀与后缀相等部分
        //1.先初始化数组 2.前后缀不相等,向前移动一位，3.前后缀相等，j++，
        for (int i = 1, j = 0; i < m; i++) {
            while (j > 0 && needle.charAt(i) != needle.charAt(j)) {
                j = pi[j - 1];
            }
            if (needle.charAt(i) == needle.charAt(j)) {
                j++;
            }
            pi[i] = j;
        }
        
        //同理
        for (int i = 0, j = 0; i < n; i++) {
            while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
                j = pi[j - 1];
            }
            if (haystack.charAt(i) == needle.charAt(j)) {
                j++;
            }
            if (j == m) {
                return i - m + 1;
            }
        }
        return -1;
    }
}

10.搜索插入位置

在这里插入图片描述

  • 官方答案
class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;
        int left = 0, right = n - 1, ans = n;
        while (left <= right) {
            int mid = ((right - left) >> 1) + left;
            if (target <= nums[mid]) {
                ans = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}
  • 总结
    使用二分法 进行求解， >> 1 表示右移1位，相等于 /2

11.最后一个单词的长度

在这里插入图片描述

  • 答案
class Solution {
    public int lengthOfLastWord(String s) {
        int index = s.length() - 1;
        while (s.charAt(index) == ' ') {
            index--;
        }
        int wordLength = 0;
        while (index >= 0 && s.charAt(index) != ' ') {
            wordLength++;
            index--;
        }
        return wordLength;
    }
}
  • 总结
    反向计算

12.加一

在这里插入图片描述

  • 答案
class Solution {
    public int[] plusOne(int[] digits) {
        int n = digits.length;
        for (int i = n - 1; i >= 0; --i) {
            if (digits[i] != 9) {
                ++digits[i];
                for (int j = i + 1; j < n; ++j) {
                    digits[j] = 0;
                }
                return digits;
            }
        }

        // digits 中所有的元素均为 9
        int[] ans = new int[n + 1];
        ans[0] = 1;
        return ans;
    }
}
  • 总结
    倒序，找出第一个不为9的数，进行+1，全为9，才进行创建新的数组、

13 爬楼梯

在这里插入图片描述

  • 答案
class Solution {
    public int climbStairs(int n) {
       int p = 0, q = 0, r = 1;
        for (int i = 1; i <= n; ++i) {
            p = q; 
            q = r; 
            r = p + q;
        }
        return r;
    }
}
  • 总结
    dp【i】=dp[i-1]+dp[i-2]

14 二叉树中序排列

在这里插入图片描述

  • 答案
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}

15 删除排序链表中的重复元素

在这里插入图片描述

  • 我的解法
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
           repeat(head);
           return head;
    }

    public void repeat(ListNode head){
        if(head==null || head.next ==null){
           return ; 
        }
         if(head.val==head.next.val){
            head.next=head.next.next;
            repeat(head);
         }else{
            repeat(head.next);
         }
    }

}

16 菲波那契数列

菲波那契数列 ：0 1 1 2 3 5 8 …

求 n项 是多少

代码实现
运用了动态规划，空间换时间

#include <iostream>
#include <vector>

int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    
    std::vector<int> dp(n + 1);
    dp[0] = 0;
    dp[1] = 1;

    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[n];
}

int main() {
    int n = 10;  // 求第 n 项
    int result = fibonacci(n);
    std::cout << "第 " << n << " 项的菲波那契数列值为：" << result << std::endl;
    return 0;
}
我叫果冻
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python 排序算法总结及实例详解
09-21
主要介绍了python 排序算法总结及实例详解的相关资料,需要的朋友可以参考下
贪心算法总结
qq_57533658的博客
11-14 1362
1 贪心算法基本思想 顾名思义，贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。 因此可以得出用局部解构造全局解，即从问题的某一个初始解逐步逼近给定的目标，以尽可能快的求得更好的解。当某个算法中的某一步不能再继续前进时，算法停止。 2 贪心算法的基本要素 问题要满足以下条件： （1）贪心选择性质 所谓的贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪...
哈希算法总结及案例实现
m0_64529944的博客
07-10 870
哈希算法可用于验证数据完整性，具有防篡改检测的功能；常用的哈希算法有 MD5 、 SHA-1 等；用哈希存储口令时要考虑彩虹表攻击。Hmac 算法是一种标准的基于密钥的哈希算法，可以配合 MD5 、 SHA-1 等哈希算法，计算的摘要长度和原摘要算法长度相同。BouncyCastle 是一个开源的第三方算法提供商；BouncyCastle 提供了很多 Java 标准库没有提供的哈希算法和加密算法；
Hash算法总结
qq_32534441的博客
04-29 4188
https://blog.csdn.net/asdzheng/article/details/702260071. Hash是什么，它的作用 先举个例子。我们每个活在世上的人，为了能够参与各种社会活动，都需要一个用于识别自己的标志。也许你觉得名字或是身份证就足以代表你这个人，但是这种代表性非常脆弱，因为重名的人很多，身份证也可以伪造。最可靠的办法是把一个人的所有基因序列记录下来用来代表这个人，但显...
聚类算法总结
热门推荐
CharlesDavid
12-27 2万+
聚类算法 文章目录聚类算法聚类算法简介认识聚类算法聚类算法的概念聚类算法与分类算法最大的区别聚类算法api初步使用api介绍案例聚类算法实现流程k-means聚类步骤案例练习小结模型评估误差平方和(SSE \The sum of squares due to error)：“肘”方法 (Elbow method)— K值确定轮廓系数法（Silhouette Coefficient）CH系数（Calinski-Harabasz Index）总结算法优化Canopy算法配合初始聚类K-means++二分k-me
神经网络优化算法总结
AI蜗牛车
05-09 4786
Datawhale干货编译：王小新，来源：量子位在调整模型更新权重和偏差参数的方式时，你是否考虑过哪种优化算法能使模型产生更好且更快的效果？应该用梯度下降，随机梯度下降，还是Adam方法？这篇文章介绍了不同优化算法之间的主要区别，以及如何选择最佳的优化方法。什么是优化算法？优化算法的功能，是通过改善训练方式，来最小化(或最大化)损失函数E(x)。模型内部有些参数，是用...
机器学习算法总结21
08-03
简介k近邻（KNN)是一种基本分类与回归方法。其思路如下：给一个训练数据集和一个新的实例，在训练数据集中找出与这个新实例最近的 个训练实例，然后统计最近的 个训
Java常用加密算法实例总结
08-29
主要介绍了Java常用加密算法,结合实例形式总结分析了base64、md5、sha、rsa、des等加密算法实现技巧,需要的朋友可以参考下
Java常用HASH算法总结【经典实例】
08-29
主要介绍了Java常用HASH算法,结合实例形式总结分析了Java常用的Hash算法,包括加法hash、旋转hash、FNV算法、RS算法hash、PJW算法、ELF算法、BKDR算法、SDBM算法、DJB算法、DEK算法、AP算法等,需要的朋友可以参考下
Codeforces Round 941 (Div. 2) （A~D）
weixin_61825750的博客
04-28 675
然后考虑若此时存在两个堆，那么对于Alice而言，其操作可以使得小的那个堆只剩下1，下一步Bob必须选1，然后Alice就胜利了。相反，若小的那个堆一开始就是1，那么Alice就输了。接下来推广到若干堆的情况：对于任意一方而言，若最小堆不是1，那么便可以控制胜利，于是我们只需要枚举到最小堆不是1的情况即可，然后看是谁在操作就是谁赢。思路：若要使得所有方格同色，关键在于四个角上的颜色，若对角上的颜色一样就能直接将所有格子变为同色。思路：首先处理 < k 的部分，我们可以通过二进制的思想来构造整数，例如。
密度峰值聚类(DPC)算法（Python3实现）
helloWorld的博客
04-27 748
密度峰值聚类（Density peaks clustering, DPC）算法是由Rodriguez和Laio于2014年提出的一种聚类分析算法。其原始文献名是在在 Science上发表的，论文名称为“Clustering by Fast Search and Find of Density Peaks”。这种聚类方法该算法是一种基于密度的聚类算法，可以自动确定聚类中心和聚类的数量并适用于处理各种形状和分布的数据集。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 101
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
排序算法（1）
2301_79783967的博客
04-28 1311
1. 堆排序使用堆来选数，效率就高了很多。2. 时间复杂度：O(N*logN)3. 空间复杂度：O(1)4. 稳定性：不稳定。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
最新发布
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 470
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
二分搜索法
m0_73950754的博客
04-26 230
二分搜索法
算法~本质
sweet_Mary的博客
04-30 204
数据结构分为数组和链表，数据结构的目的是提升增删改查的效率。算法的本质是基于这两种数据结构进行高效穷举。2.如何聪明地穷举？--并查集/贪心/KMP）数组--二分搜索/双指针/滑动窗口/前缀+差分。二叉树系列（回溯算法+动态规划）eg.求二叉树最大深度。2. 分解问题计算答案。2.分解问题计算答案。eg.二叉树前缀遍历。
c入门基础题（3）
梦昼初
04-26 866
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
【力扣】16. 最接近的三数之和
嵌入式小菜鸟一枚~
04-25 383
【力扣】16. 最接近的三数之和
A star前置算法优先队列
m0_52021450的博客
04-30 143
优先队列是0个元素和多个元素的集合，每一个元素都有一个优先权限，我们可以对这个队列进行的操作有 插入，删除，当我们首先优先队列 一般是由满二叉堆来实现的 而二叉堆逻辑上是一个满二叉树。假设一个二叉树由k层 ，在k-1层之前 每一层的结点的都是2^(k-1-1) 而且第二层的结点都是从最左边网友排列的根据子节点和父节点的关系 又可以分为最大堆，最小堆最大堆：每一个结点的值总是大于或者等于子节点的值，因此最大堆的跟节点就是堆的最大值最小堆。
python聚类算法总结及对应实例代码
05-26
下面是一些常用的聚类算法及对应实例代码。 1. K-Means算法 K-Means算法是一种基于距离的聚类算法，其核心思想是将数据集分成K个簇，使得每个数据点都属于离其最近的簇。K-Means算法的步骤如下： 1. 随机选择K个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我叫果冻

你的鼓励将是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值