十道算法题[二]

Java3y Java3y 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 400+累计阅读 428平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
原创 最新推荐文章于 2026-03-13 00:16:59 发布 428 阅读 AI 写同款· GEO 优化 ›
c++常见入门级算法题五十道 阅读详情 

 
前言

 
清明不小心就拖了两天没更了～～

 
这是十道算法题的第二篇了～上一篇回顾：十道简单算法题

 
最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。

 
只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～

 
很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，因为只要会了归并排序(合并数组)，会了桶排序(获取数字每位的值)，这些都不成问题了。如果还不太熟悉八大基础排序的同学可看:【八大基础排序总结】

 
由于篇幅问题，每篇写十道吧～

 
如果有错的地方，或者有更好的实现，更恰当的理解方式希望大家不吝在评论区留言哦～大家多多交流

 
十道简单算法题

 
题目的总览

 
  1. 删除下标为k的元素
  2. 找出常用的数字
  3. 丢失的数字
  4. 将0放在数组最后
  5. 找出数组的单个数字
  6. 画三角形星星
  7. 罗马数字倒转成阿拉伯数字
  8. 啤酒与饮料
  9. 简单凯撒密码
  10. 求最大公约数

 
一、删除下标为k的元素 

 

  
删除下标为k的元素

 

 
思路：数组后一位往前覆盖即可～

 
    /**     * 删除下标为k的元素     */    public static void deleteK() {        //固定的常量(比数组元素的个数要大)        int N = 10;        int[] arrays = new int[N];        //对数组进行初始化        for (int i = 0; i < 8; i++) {            arrays[i] = i;        }        //要删除下标        int k = 7;        for (int i = k; i < N - 1; i++) {            arrays[i] = arrays[i + 1];        }        System.out.println("公众号：Java3y" + arrays);    }
    public static void deleteK() {


        //固定的常量(比数组元素的个数要大)
        int N = 10;

        int[] arrays = new int[N];

        //对数组进行初始化
        for (int i = 0; i < 8; i++) {
            arrays[i] = i;
        }


        //要删除下标
        int k = 7;

        for (int i = k; i < N - 1; i++) {
            arrays[i] = arrays[i + 1];
        }


        System.out.println("公众号：Java3y" + arrays);


    }

 
二、找出常用的数字 

 

  
给你一个长度为n的数组，其中有一个数字出现的次数至少为n/2，找出这个数字

 

 
这道题可以用栈的思想来做：

 

  640?wx_fmt=png
  

 

 
    /**     * 找出常用的数字：     * 给你一个长度为n的数组，其中有一个数字出现的次数至少为n/2，找出这个数字     */    public static void findMajorityElement(int[] arrays) {        //构建一个静态栈        int[] stack = new int[arrays.length];        // 栈的front指针        int front = -1;        // 遍历给出的数组        for (int i = 0; i < arrays.length; i++) {            // 判断该栈为空，那么直接将元素入栈            if (front == -1) {                stack[++front] = arrays[i];            } else if (stack[front] == arrays[i]) { // 该元素是否与栈的元素一致-->继续入栈                stack[++front] = arrays[i];            } else {                // 只要不一致，就出栈                front--;            }        }        // 只要该数字出现次数大于数组长度的2/1，那么留下来的数字肯定在栈顶中        System.out.println("关注公众号：Java3y--->" + stack[0]);    }

    public static void findMajorityElement(int[] arrays) {


        //构建一个静态栈
        int[] stack = new int[arrays.length];

        // 栈的front指针
        int front = -1;


        // 遍历给出的数组
        for (int i = 0; i < arrays.length; i++) {


            // 判断该栈为空，那么直接将元素入栈
            if (front == -1) {
                stack[++front] = arrays[i];
            } else if (stack[front] == arrays[i]) { // 该元素是否与栈的元素一致-->继续入栈

                stack[++front] = arrays[i];
            } else {
                // 只要不一致，就出栈
                front--;

            }
        }

        // 只要该数字出现次数大于数组长度的2/1，那么留下来的数字肯定在栈顶中
        System.out.println("关注公众号：Java3y--->" + stack[0]);
    }

 
优化：

 
    public static void findMajorityElement2(int[] arrays) {        // 装载栈的元素        int candidate = -1;        // 栈的大小(长度)        int count = 0;        // 遍历给出的数组        for (int i = 0; i < arrays.length; i++) {            // 判断该栈为空，那么直接将元素入栈            if (count == 0) {                candidate = arrays[i];                count++;            } else if (candidate == arrays[i]) { // 该元素是否与栈的元素一致-->入栈(栈多一个元素)                count++;            } else {                // 只要不一致-->出栈(栈少一个元素)                count--;            }        }        // 只要该数字出现次数大于数组长度的2/1，那么留下来的数字肯定在栈顶中        System.out.println("关注公众号：Java3y--->" + candidate);    }

        // 装载栈的元素
        int candidate = -1;

        // 栈的大小(长度)
        int count = 0;


        // 遍历给出的数组
        for (int i = 0; i < arrays.length; i++) {


            // 判断该栈为空，那么直接将元素入栈
            if (count == 0) {

                candidate = arrays[i];
                count++;

            } else if (candidate == arrays[i]) { // 该元素是否与栈的元素一致-->入栈(栈多一个元素)
                count++;
            } else {
                // 只要不一致-->出栈(栈少一个元素)
                count--;

            }
        }

        // 只要该数字出现次数大于数组长度的2/1，那么留下来的数字肯定在栈顶中
        System.out.println("关注公众号：Java3y--->" + candidate);

    }

 
三、丢失的数字 

 

  
给你一个数组{0,1,2,3,….n}，其中有一个数字缺失，请把缺失的数字找出来

 

 
思路：

 
    /**     * 找到缺失的数字     *     * @param arrays     */    public static void missingNumber(int[] arrays) {        // 定义要填充到新数组的数字(随意)        int randomNumber = 89898980;        // 创建一个新的数组(比已缺失的数组多一个长度)        int[] newArrays = new int[arrays.length + 1];        // 填充特殊的数字进新数组中        for (int i = 0; i < newArrays.length; i++) {            // 随意填充数组到新数组中            newArrays[i] = randomNumber;        }        // 遍历题目的数组并使用index替代掉新数组的元素        for (int i = 0; i < arrays.length; i++) {            // 题目数组的值[0,1,2,3,4,...n]其中有一个缺失            int index = arrays[i];            // 重新填充到新数组上，index对应着题目数组的值            newArrays[index] = 3333333;        }        // 遍历新数组，只要还有值为89898980，那么那个就是缺失的数字        for (int i = 0; i < newArrays.length; i++) {            if (newArrays[i] == randomNumber) {                System.out.println("关注公众号：Java3y---->缺失的数字是：" + i);            }        }    }
    public static void missingNumber(int[] arrays) {


        // 定义要填充到新数组的数字(随意)
        int randomNumber = 89898980;


        // 创建一个新的数组(比已缺失的数组多一个长度)
        int[] newArrays = new int[arrays.length + 1];

        // 填充特殊的数字进新数组中
        for (int i = 0; i < newArrays.length; i++) {

            // 随意填充数组到新数组中
            newArrays[i] = randomNumber;
        }

        // 遍历题目的数组并使用index替代掉新数组的元素
        for (int i = 0; i < arrays.length; i++) {

            // 题目数组的值[0,1,2,3,4,...n]其中有一个缺失
            int index = arrays[i];

            // 重新填充到新数组上，index对应着题目数组的值
            newArrays[index] = 3333333;

        }

        // 遍历新数组，只要还有值为89898980，那么那个就是缺失的数字
        for (int i = 0; i < newArrays.length; i++) {


            if (newArrays[i] == randomNumber) {

                System.out.println("关注公众号：Java3y---->缺失的数字是：" + i);

            }


        }


    }

 
结果：

 

  640?wx_fmt=png
  

 

 
优化：

 
所以，我们可以写出这样的代码：

 
    /**     * 利用等差公式找到缺失的数字     *     * @param arrays     */    public static void missingNumber2(int[] arrays) {        // 套用等差求和公式        int sum = (arrays[0] + arrays[arrays.length - 1]) * (arrays.length + 1) / 2;        // 遍历数组，得出的sum减去数组每一位元素，最后即是缺失的数字        for (int value : arrays) {            sum = sum - value;        }        System.out.println("关注公众号：Java3y---->缺失的数字是：" + sum);    }
    public static void missingNumber2(int[] arrays) {

        // 套用等差求和公式
        int sum = (arrays[0] + arrays[arrays.length - 1]) * (arrays.length + 1) / 2;


        // 遍历数组，得出的sum减去数组每一位元素，最后即是缺失的数字

        for (int value : arrays) {
            sum = sum - value;
        }


        System.out.println("关注公众号：Java3y---->缺失的数字是：" + sum);


    }

 
结果：

 

  640?wx_fmt=png
  

 

 
四、将0放在数组最后 

 

  
将一个数组的元素，其中是0的，放在数组的最后

 

 
思路：

 
代码实现：

 
    /**     * 移动元素0到数组最后     *     * @param arrays     */    public static void moveZero(int[] arrays) {        // 记录该数组有多少个0元素        int zero = 0;        for (int i = 0; i < arrays.length; i++) {            // 只要元素不为0，那么就往前面移动            if (arrays[i] != 0) {                arrays[i - zero] = arrays[i];            } else {                // 如果为0，那么zero ++                zero++;            }        }        // 1. 前面已经将非0的元素移动到数组的前面了        // 2. 将为0的元素填满数组，填充的位置就从length - zero开始        int j = arrays.length - zero;        while (j < arrays.length) {            arrays[j] = 0;            j++;        }        System.out.println("关注公众号：Java3y---->" + arrays);    }
    public static void moveZero(int[] arrays) {

        // 记录该数组有多少个0元素
        int zero = 0;


        for (int i = 0; i < arrays.length; i++) {

            // 只要元素不为0，那么就往前面移动
            if (arrays[i] != 0) {
                arrays[i - zero] = arrays[i];
            } else {
                // 如果为0，那么zero ++
                zero++;
            }
        }


        // 1. 前面已经将非0的元素移动到数组的前面了
        // 2. 将为0的元素填满数组，填充的位置就从length - zero开始


        int j = arrays.length - zero;
        while (j < arrays.length) {
            arrays[j] = 0;
            j++;
        }

        System.out.println("关注公众号：Java3y---->" + arrays);


    }

 
结果：

 

  640?wx_fmt=png
  

 

 
还可以换种思路(差别不大)：将数组分成几个部分：在j之前的没有0，j到i全是0，i后面还没有遍历

 
代码实现：

 
    /**     * 移动元素0到数组最后     *     * @param arrays     */    public static void moveZero2(int[] arrays) {        // 在j前面的元素都不是0        int j = 0;        for (int i = 0; i < arrays.length; i++) {            if (arrays[i] != 0) {                // 跟j进行交换，保证j的前面都不是0                int temp = arrays[i];                arrays[i] = arrays[j];                arrays[j]  = temp;                j++;            }        }        // 直至i遍历完毕后，j前面都不是0，j-i都是0(这就完成我们的任务了)        System.out.println("关注公众号：Java3y---->" + arrays);    }
    public static void moveZero2(int[] arrays) {


        // 在j前面的元素都不是0
        int j = 0;


        for (int i = 0; i < arrays.length; i++) {

            if (arrays[i] != 0) {

                // 跟j进行交换，保证j的前面都不是0
                int temp = arrays[i];
                arrays[i] = arrays[j];
                arrays[j]  = temp;

                j++;
            }
        }

        // 直至i遍历完毕后，j前面都不是0，j-i都是0(这就完成我们的任务了)


        System.out.println("关注公众号：Java3y---->" + arrays);



    }

 
结果还是一样的：

 

  640?wx_fmt=png
  

 

 
五、找出数组的单个数字 

 

  
给你一个数组，除了一个数字外，其他的数字都出现了两次，请把这个只出现一次的数字找出来。

 

 
思路：

 
    /**     * 找出数组的单个数字     * @param nums     * @return     */    public static void singleNumber(int[] nums) {        for (int i = 0; i < nums.length; i++) {            int count = countNumber(nums, nums[i]);            // 如果该元素只出现一次，那么就是它了！            if (count == 1) {                System.out.println("关注公众号：Java3y--->单一的元素是：" + nums[i]);                return ;            }        }    }    /**     * 找出每个元素出现的次数     * @param nums 数组     * @param value 想知道出现次数的元素     */    public static int countNumber(int[] nums,int value) {        int count = 0;        for (int i = 0; i < nums.length; i++) {            if (value == nums[i]) {                count++;            }        }        // 返回该元素出现的次数        return count;    }
    public static void singleNumber(int[] nums) {

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

            int count = countNumber(nums, nums[i]);


            // 如果该元素只出现一次，那么就是它了！
            if (count == 1) {
                System.out.println("关注公众号：Java3y--->单一的元素是：" + nums[i]);

                return ;


            }


        }
    }

    /**
     * 找出每个元素出现的次数
     * @param nums 数组
     * @param value 想知道出现次数的元素
     */

    public static int countNumber(int[] nums,int value) {


        int count = 0;

        for (int i = 0; i < nums.length; i++) {
            if (value == nums[i]) {
                count++;
            }
        }
        // 返回该元素出现的次数
        return count;
    }

 
结果：

 

  640?wx_fmt=png
  

 

 
优化：

 
这个问题最佳的解法是用到了位运算的异或操作：

 
从上面的例子可以看出：一堆数字做异或运算^，俩俩相同数字就会被抵消掉～，所以这个特性对于这个题目而言就再适合不过的了：

 
    /**     * 找出数组的单个数字     * @param nums     * @param numsSize     * @return     */    public static int singleNumber(int[] nums, int numsSize) {        // 第一个数和数组后面的数做^运算，留下的必然是单个数字        int k = nums[0];        for (int i = 1; i < numsSize; i++) {            k = (k ^ nums[i]);        }        return k;    }
    public static int singleNumber(int[] nums, int numsSize) {

        // 第一个数和数组后面的数做^运算，留下的必然是单个数字
        int k = nums[0];
        for (int i = 1; i < numsSize; i++) {
            k = (k ^ nums[i]);
        }
        return k;
    }

 
六、画三角形星星 

 

  
画三角形星星

 

 

  640?wx_fmt=png
  

 

 
就是要画上面那种三角形星星，那怎么画呢？？

 
思路：

 
实现代码：

 
    /**     * 画星星     */    public static void drawStar() {        // 我要画5行的星星        int row = 5;        for (int i = 1; i <= 5; i++) {            // 空格数等于最大行数 - 当前行数            for (int j = 1; j <= row - i; j++) {                System.out.print(" ");            }            // 星星数等于(当前行数*2-1)            for (int j = 1; j <= i * 2 - 1; j++) {                System.out.print("*");            }            // 每画一行就换一次行            System.out.println();        }    }
    public static void drawStar() {

        // 我要画5行的星星
        int row = 5;


        for (int i = 1; i <= 5; i++) {

            // 空格数等于最大行数 - 当前行数
            for (int j = 1; j <= row - i; j++) {
                System.out.print(" ");
            }

            // 星星数等于(当前行数*2-1)
            for (int j = 1; j <= i * 2 - 1; j++) {

                System.out.print("*");

            }

            // 每画一行就换一次行
            System.out.println();
        }
    }

 
结果：

 

  640?wx_fmt=png
  

 

 
七、罗马数字倒转成阿拉伯数字 

 

  
罗马数字倒转成阿拉伯数字

 

 
罗马数字我们可能在英语的题目中看得是比较多的，一般常用的我们是阿拉伯数字，那怎么转成阿拉伯数字呢？？我们先来了解一下罗马数字：

 

  640?wx_fmt=png
  

 

 
ps:来源360百科

 
规则在图上已经说得挺明白的了，我举几个例子：

 

  640?wx_fmt=png
  

 

 

  640?wx_fmt=png
  

 

 
看了上面的例子估计我们会手算将罗马数字转成阿拉伯数字了，那么用程序怎么写呢？？？

 
思路是这样的：

 
首先，我们先定义罗马数字和对应的阿拉伯数字(相当于查表)

 
    // 定义罗马数字    char digits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};    // 罗马数字对应的阿拉伯数字    int  values[] = { 1,  5, 10, 50, 100, 500, 1000};
    char digits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};

    // 罗马数字对应的阿拉伯数字
    int  values[] = { 1,  5, 10, 50, 100, 500, 1000};

 
随后，我们得找到罗马数字当前的最大值，找到最大值之前就先得把罗马数字转成是阿拉伯数字

 
    /**     * 将罗马数字转成阿拉伯数字，实际上就是一个查表的过程     *     * @param roman     * @return     */    public static int digitsToValues(char roman) {        // 定义罗马数字        char digits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};        // 罗马数字对应的阿拉伯数字        int values[] = {1, 5, 10, 50, 100, 500, 1000};        for (int i = 0; i < digits.length; i++) {            if (digits[i] == roman) {                return values[i];            }        }        return 0;    }
    public static int digitsToValues(char roman) {

        // 定义罗马数字
        char digits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};

        // 罗马数字对应的阿拉伯数字
        int values[] = {1, 5, 10, 50, 100, 500, 1000};


        for (int i = 0; i < digits.length; i++) {

            if (digits[i] == roman) {
                return values[i];
            }
        }

        return 0;

    }

 
上面的方法已经可以将罗马数字转成阿拉伯数字了，接下来我们要查找出最大值了

 
    /**     * 找到当前罗马数字最大值的角标     *     * @param digits     * @return     */    public static int findMaxIndex(String digits, int L, int R) {        // 假设第一个是最大的        int max = digitsToValues(digits.charAt(L));        int maxIndex = L;        for (int i = L; i < R; i++) {            // 将罗马数字转成是阿拉伯数字            int num = digitsToValues(digits.charAt(i));            if (max < num) {                max = num;                maxIndex = i;            }        }        return maxIndex;    }
    public static int findMaxIndex(String digits, int L, int R) {

        // 假设第一个是最大的
        int max = digitsToValues(digits.charAt(L));
        int maxIndex = L;

        for (int i = L; i < R; i++) {
            // 将罗马数字转成是阿拉伯数字
            int num = digitsToValues(digits.charAt(i));
            if (max < num) {
                max = num;
                maxIndex = i;
            }
        }

        return maxIndex;
    }

 
找到了当前罗马数字的最大值那要怎么做？？？

 
于是乎，我们可以写出下面的代码：

 
    /**     * 将罗马数字转成阿拉伯数字     *     * @param romanNumber     * @param L     * @param R     */    public static int romanToNumber(String romanNumber, int L, int R) {        // 如果只有一个罗马数字，那么可以直接返回了(递归出口)        if (L == R) {            return digitsToValues(romanNumber.charAt(L));        } else if (L > R) { // 如果L和R已经越界了，那么说明没有值了            return 0;        } else {            // 找到当前罗马数字最大值的角标            int maxIndex = findMaxIndex(romanNumber, L, R);            // 得到最大值            int max = digitsToValues(romanNumber.charAt(maxIndex));            // 在最大值左边的，则用最大值减去左边的            int left = romanToNumber(romanNumber, L, maxIndex - 1);            // 在最大值右边的，则用最大值加上右边的            int right = romanToNumber(romanNumber, maxIndex + 1, R);            return max - left  + right;        }    }
    public static int romanToNumber(String romanNumber, int L, int R) {

        // 如果只有一个罗马数字，那么可以直接返回了(递归出口)
        if (L == R) {
            return digitsToValues(romanNumber.charAt(L));
        } else if (L > R) { // 如果L和R已经越界了，那么说明没有值了
            return 0;
        } else {

            // 找到当前罗马数字最大值的角标
            int maxIndex = findMaxIndex(romanNumber, L, R);

            // 得到最大值
            int max = digitsToValues(romanNumber.charAt(maxIndex));

            // 在最大值左边的，则用最大值减去左边的
            int left = romanToNumber(romanNumber, L, maxIndex - 1);

            // 在最大值右边的，则用最大值加上右边的
            int right = romanToNumber(romanNumber, maxIndex + 1, R);

            return max - left  + right;
        }
    }

 
测试一下：

 

  640?wx_fmt=png
  

 

 
八、啤酒与饮料 

 

  
啤酒每罐2.3元，饮料每罐1.9元。小明买了若干啤酒和饮料，一共花了82.3元。我们还知道他买的啤酒比饮料的数量少，请你计算他买了几罐啤酒。

 

 
这是蓝桥杯的一道题，我们可以使用暴力搜索即可解出：

 
    /**     * 啤酒与饮料题目     */    public static void beerAndDrink() {        // 啤酒        for (int i = 0; i < 36; i++) {            // 饮料            for (int j = 0; j < 44; j++) {                // 钱刚好花光了，并且啤酒比饮料少                if (2.3 * i + j * 1.9 == 82.3 && i < j) {                    System.out.println("关注公众号：Java3y--------------->啤酒买了" + i);                }            }        }    }
    public static void beerAndDrink() {

        // 啤酒
        for (int i = 0; i < 36; i++) {

            // 饮料
            for (int j = 0; j < 44; j++) {

                // 钱刚好花光了，并且啤酒比饮料少
                if (2.3 * i + j * 1.9 == 82.3 && i < j) {
                    System.out.println("关注公众号：Java3y--------------->啤酒买了" + i);
                }
            }
        }
    }

 
测试：

 

  640?wx_fmt=png
  

 

 
九、简单凯撒密码 

 

  
简单凯撒密码

 

 
凯撒密码是啥？简单来说：就是通过移位来进行加密

 
上面就是最简单的凯撒密码，将所有的字母进行移一位，实现加密

 

  640?wx_fmt=jpeg
  

 

 
下面我们也来玩一下吧～

 
左移动和右移动：

 
    /**     * 右移     */    public static int rotateRight(int ch) {        if (ch >= 'A' && ch <= 'Y') {            return ch + 1;        } else if (ch >= 'a' && ch <= 'y') {            return ch + 1;        } else if (ch == 'Z') {            return 'A';        } else if (ch == 'z') {            return 'a';        } else {            return ch;        }    }    /**     * 左移     */    public static int rotateLeft(int ch) {        if (ch >= 'B' && ch <= 'Z') {            return ch - 1;        } else if (ch >= 'b' && ch <= 'z') {            return ch - 1;        } else if (ch == 'A') {            return 'Z';        } else if (ch == 'a') {            return 'z';        } else {            return ch;        }    }
    public static int rotateRight(int ch) {
        if (ch >= 'A' && ch <= 'Y') {
            return ch + 1;
        } else if (ch >= 'a' && ch <= 'y') {
            return ch + 1;
        } else if (ch == 'Z') {
            return 'A';
        } else if (ch == 'z') {
            return 'a';
        } else {
            return ch;
        }
    }

    /**
     * 左移
     */
    public static int rotateLeft(int ch) {
        if (ch >= 'B' && ch <= 'Z') {
            return ch - 1;
        } else if (ch >= 'b' && ch <= 'z') {
            return ch - 1;
        } else if (ch == 'A') {
            return 'Z';
        } else if (ch == 'a') {
            return 'z';
        } else {
            return ch;
        }
    }

 
加密：

 
    /**     * 加密     * @param ch     * @param shift     * @return     */    public static int encode(int ch, int shift) {        // 如果没有移动，则直接返回        if (shift == 0) {            return ch;        } else if (shift > 0) {            // 如果shift移动的是正数，那么就向右移动            for (int i = 0; i < shift; i++) {                ch = rotateRight(ch);            }            return ch;        } else {            // 如果shift移动的是负数，那么就向左移动            for (int i = 0; i < -shift; i++) {                ch = rotateLeft(ch);            }            return ch;        }    }
    public static int encode(int ch, int shift) {

        // 如果没有移动，则直接返回
        if (shift == 0) {
            return ch;
        } else if (shift > 0) {

            // 如果shift移动的是正数，那么就向右移动
            for (int i = 0; i < shift; i++) {
                ch = rotateRight(ch);
            }
            return ch;
        } else {

            // 如果shift移动的是负数，那么就向左移动
            for (int i = 0; i < -shift; i++) {
                ch = rotateLeft(ch);
            }
            return ch;
        }
    }

 
测试：

 
        String s = "HELLO WORLD";        char[] ch = new char[s.length()];        for (int i = 0; i < s.length(); i++) {           ch[i] = (char) encode(s.charAt(i), 3);        }        System.out.println("关注公众号：Java3y" + ch);
        char[] ch = new char[s.length()];

        for (int i = 0; i < s.length(); i++) {
           ch[i] = (char) encode(s.charAt(i), 3);
        }

        System.out.println("关注公众号：Java3y" + ch);

 
结果：

 

  640?wx_fmt=png
  

 

 
十、求最大公约数 

 

  
求一个数的最大公约数

 

 
算法：是两个数相余，直到余数为0，如果余数不为0，就用除数和余数求余

 
    /**     * 求最大公约数     *     * @param num1     * @param num2     */    public static int gcd(int num1, int num2) {        // 求余数        int r = num1 % num2;        // 如果余数为0，那么除数就是最大公约数        if (r == 0) {            return num2;        } else {            // 否则，则用除数和余数来进行运算            return gcd(num2, r);        }    }
    public static int gcd(int num1, int num2) {


        // 求余数
        int r = num1 % num2;

        // 如果余数为0，那么除数就是最大公约数
        if (r == 0) {
            return num2;
        } else {

            // 否则，则用除数和余数来进行运算
            return gcd(num2, r);
        }

    }

 
结果：

 

  640?wx_fmt=png
  

 

 
总结

 
没错，你没看错，简单的小算法也要总结！

 
其实我觉得这些比较简单的算法是有"套路"可言的，你如果知道它的套路，你就很容易想得出来，如果你不知道它的套路，那么很可能就不会做了(没思路)。

 
积累了一定的"套路"以后，我们就可以根据经验来推断，揣摩算法题怎么做了。

 
举个很简单的例子：

 

 
  1. 删除下标为k的元素

 
找出常用的数字

 
丢失的数字

 
将0放在数组最后

 
找出数组的单个数字

 
画三角形星星

 
罗马数字倒转成阿拉伯数字

 
啤酒与饮料

 
简单凯撒密码

 
求最大公约数

 

  640?wx_fmt=jpeg
  

 

 
文章的目录导航：https://zhongfucheng.bitcron.com/post/shou-ji/gong-zhong-hao-wen-zhang-zheng-li

 

  
如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y

 

 

 


        

    

  






  




  

    
  




        

          

              版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
          

        

  


  
    
      2022年大厂笔试最高频的十道算法题，你知道多少？
      最近不少小伙伴跟我交流刷题肿么刷，我给的建议就是先剑指offer和力扣hot100，在这些题中还有些重要程度和出现频率是非常非常高的，今天给大家分享当今出现频率最高的10道算法题，学到就是赚到。0X01翻转链表力扣206和剑指offer24原题，题意为：给你单链表的头节点head，请你反转链表，并返回反转后的链表。
    
    阅读详情
  





    

      

        
相关推荐

        
      

      

          
            
字节面试必须拿下的十道算法题，你会几道？

              
最近不少小伙伴跟我交流刷题肿么刷，我给的建议就是先剑指offer和力扣hot100，在这些题中还有些重要程度和出现频率是非常非常高的，今天给大家分享当今出现频率最高的10道算法题，学到就是赚到。

0X01翻转链表
力扣206和剑指offer24原题，题意为：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

分析：
翻转链表，本意是不创建新的链表节点然后在原链表上实现翻转，.

            

                bigsai
                
                  
                    7174
                
            

          
          
            
一天十道算法题（day3）

              
第一题
给你一个长度为50的数字串,问你有多少个子序列构成的数字可以被3整除
答案对1e9+7取模。
【注意：子序列和子串的区别】
public  class Main {//主类
    public static void main(String args[])throws Exception{
       int [] arr = {1,3,2};
       System.out.pr...

            

                很注重数学和408
                
                  
                    569
                
            

          
          
            
SIMPLIS实战：从零构建理想BUCK电路，精准计算与POP稳态分析

              
本文详细介绍了如何使用SIMPLIS软件从零开始构建并仿真一个理想的BUCK降压电路。通过设定关键参数、计算理想器件值，并搭建仿真模型，文章重点演示了暂态仿真以观察电路上电过程，并深入讲解了高效的POP（周期性工作点）稳态分析技术，帮助工程师快速验证设计、评估稳态性能，从而加速电源设计迭代。

            

                weixin_29165465的博客
                
                  
                    395
                
            

          
          
            
10道算法题

              
10道算法题，来自于gitchat王晓华的《算法应该怎么“玩”》专栏。

1. 农夫需要把狼、羊、菜和自己运到河对岸去，只有农夫能够划船，而且船比较小，除农夫之外每次只能运一种东西，还有一个棘手问题，就是如果没有农夫看着，羊会偷吃菜，狼会吃羊。请考虑一种方法，让农夫能够安全地安排这些东西和他自己过河。

2. 请你把10根放在篮子里的香蕉分给10只猴子，每只猴要得到一根，最后...

            

                diaobiao8107的博客
                
                  
                    321
                
            

          
          
            
citespace基本操作

              
聚类分析 时间线图 这些结果都是高被引文献的相关呈现结果，代表该领域的文献基础



下面可以看看该project的前沿领域



选择keywords 和term  go！





















调整显示方式















生成凸线图：表示 在某个研究领域或者时间段内 ，大家对某个领域或者某个词的关注度突然增高，凸显前沿方向的转变   以此来发现热点












...

            

                生信小博士的博客
                
                  
                    1万+
                
            

          
          
            
使用 ANSYS AEDT（双向耦合）对高功率射频同轴滤波器进行热分析

              
使用 ANSYS HFSS，可以精确计算 EM 损耗，然后将其导入 ANSYS 热分析并使用 ANSYS Icepak CFD 求解器进行仿真，以帮助工程师解决最复杂的热挑战，并预测其设计在温度变化下的表现。然后，RF 损耗将与 ANSYS Icepak CFD 求解器耦合，以执行热分析，包括传热的传导、对流和辐射模式，并计算温度曲线。在此演示中，我们将仿真下面的 RF 同轴滤波器，并计算由于所用材料的有限电导率和介电损耗而导致的 RF 传导损耗。设置 HFSS 设计后，我们可以开始 HFSS 仿真。

            

                jkh920184196的博客
                
                  
                    1051
                
            

          
          
            
 十道简单算法题二【Java实现】

              
前言
清明不小心就拖了两天没更了～～
这是十道算法题的第二篇了～上一篇回顾：十道简单算法题
最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。
只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～
很多与排序相关的...

            

                weixin_34307464的博客
                
                  
                    124
                
            

          
          
            
在PLC中将十六进制数据转换为浮点数（通常遵循IEEE 754标准）需要理解数据存储格式，并按以下步骤操作：

              
通过以上步骤，您可以在PLC中实现十六进制到浮点数的转换。T DBD20  // 将数据传送到浮点数变量（如DB1.DBD20）指数位（8位）：实际指数 = 存储值 - 127（偏移量）。：必须确认PLC的存储顺序（大端或小端），否则结果错误。将两个16位寄存器合并为32位数据，需注意。尾数位（23位）：隐含前导1，实际值为。：确保32位数据在寄存器中连续且对齐。符号位（1位）：0表示正，1表示负。：高位寄存器在前（如西门子PLC）。：低位寄存器在前（如三菱FX系列）。，误差因截断导致）。

            

                K11mvp的博客
                
                  
                    4418
                
            

          
          
            
JAVA 判断简单密码算法_十道简单算法题二【Java实现】

              
前言清明不小心就拖了两天没更了～～这是十道算法题的第二篇了～上一篇回顾：十道简单算法题最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，因为只要会了...

            

                weixin_29699433的博客
                
                  
                    309
                
            

          
          
            
Ubuntu 22.04下Realtek R8125网卡驱动安装避坑指南（附DKMS自动编译配置）

              
本文详细介绍了在Ubuntu 22.04系统上为Realtek R8125 2.5GbE网卡安装驱动的完整流程与避坑指南。针对内核通用驱动r8169的冲突问题，重点讲解了如何通过DKMS（Dynamic Kernel Module Support）实现驱动的持久化自动编译与安装，确保系统内核升级后网卡驱动依然有效。内容包括环境准备、驱动源码获取、DKMS标准配置、驱动冲突解决（设置黑名单）以及日常维护与故障排查方法，旨在为用户提供一个一劳永逸的稳定解决方案。

            

                echo99的专栏
                
                  
                    1023
                
            

          
          
            
UG\NX二次开发 一种获取点的面的方法

              
有时，我们需要用户选择“面上的点”时，同时获取点所在的面。例如：调标准件、刻字等。通过点击点，ug会创建一个智能对象，可通过函数获得对象的父项，即为点所在的面。下面是封装的函数以及测试例子点在曲线上，获取点所在的曲线同理。UF_UI_point_constructd点对话框 和 block UI对话框都可以使用。

            

                王牌飞行员_里海的博客
                
                  
                    1779
                
            

          
          
            
java简单算法题_十道简单算法题

              
前言最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，因为只要会了归并排序(合并数组)，会了桶排序(获取数字每位的值)，这些都不成问题了。如果还不太...

            

                weixin_35943736的博客
                
                  
                    993
                
            

          
          
            
自然语言处理之话题建模：BERTopic模型详解

              
BERTopic是一种基于BERT的先进话题建模技术，它结合了BERT的语义理解能力和非参数聚类算法HDBSCAN的灵活性，能够生成高质量、语义丰富的话题。与传统的LDA（Latent Dirichlet Allocation）话题模型相比，BERTopic能够更好地捕捉文本的复杂语义结构，因为它利用了预训练的BERT模型来嵌入文本，从而在话题建模中引入了深度学习的力量。聚类是无监督学习的一种，其目标是将数据集中的样本按照相似性进行分组，每个组称为一个“簇”。

            

                zhubeibei168的博客
                
                  
                    4538
                
            

          
          
            
十道简单算法题

              
前言
最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。
只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～
很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，因为只要会了归并排序(合并数组)，会了桶排序(获取数字每位的值)，这些都不成问...

            

                awxj68104的博客
                
                  
                    227
                
            

          
          
            
Qualcomm AI Engine Direct SDK（QNN）的使用介绍

              
Qualcomm AI Engine Direct SDK，高通新的AI模型推理框架，又名QNN，为AI开发提供统一API的底层框架。通过这个SDK，可以在高通的 CPU/GPU和HTP上对AI模型进行性能加速。2.Qualcomm AI Engine Direct SDK的公开英文文档。1.Qualcomm AI Engine Direct SDK的下载和安装。

            

                u013250861的博客
                
                  
                    6974
                
            

          
          
            
大中型超市收银系统(可直接运行)

              
光步前台收银系统系统功能：商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传，基本资料下载，开钱箱、小票打印、收款结算，支持多币种付款方式（现金、储值卡、礼券、微信等）,支持多种促销。运行环境：.net 4.0登陆信息用户名:1001  密码:123456内置商品信息，商品编码可输入00001000 -  00010000,测试效果相关功能键F5 结算   F9挂单    F11商品查询   F8退货  Insert单品取消  Del整单取消  F12开钱箱F2 会员   Ctrl+Z退出系统      Home 锁屏     相关源码待公开

            

            

          
          
            
JAVA实现十道计算题实训_[2]十道算法题【Java实现】

              
前言清明不小心就拖了两天没更了～～这是十道算法题的第二篇了～上一篇回顾：十道简单算法题最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，因为只要会了...

            

                weixin_34640051的博客
                
                  
                    440
                
            

          
          
            
假人有限元模型

              
假人模型，车辆碰撞假人有限元模型，适合做乘员安全的研究者利用

            

            

          
          
            
java的简单算法题_[2]十道算法题【Java实现】

              
前言清明不小心就拖了两天没更了～～这是十道算法题的第二篇了～上一篇回顾：十道简单算法题最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，因为只要会了...

            

                weixin_39620653的博客
                
                  
                    249
                
            

          
          
            
LinePhone3.2.7(android端最新版本) sip客户端

              
SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/

            

            

          
          
            
IEM模型，地表粗糙度模拟

              
利用微波反演土壤水分时候，利用IEM模型可以实现对随机地表的模拟

            

            

          
          
            
算法题库 java实现_[2]十道算法题【Java实现】

              
前言清明不小心就拖了两天没更了～～这是十道算法题的第二篇了～上一篇回顾：十道简单算法题最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，因为只要会了...

            

                weixin_39818264的博客
                
                  
                    271
                
            

          
          
            
《JAVASE系列》经典十道基础算法题

              
1.打印出1000 - 2000年的闰年
2.打印1-100的素数
3.判断素数
4.判断年龄在什么阶段
5.水仙花数
6.最大公约数
7.二进制的偶数位与奇数位
8.密码登录
9.乘法表
10.数 1 的个数

            

                simple_person的博客
                
                  
                    1211
                
            

          
          
            
[2]十道算法题【Java实现】

              
前言
清明不小心就拖了两天没更了～～
这是十道算法题的第二篇了～上一篇回顾：十道简单算法题
最近在回顾以前使用C写过的数据结构和算法的东西，发现自己的算法和数据结构是真的薄弱，现在用Java改写一下，重温一下。
只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同学可参考一下～
很多与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写...

            

                awxj68104的博客
                
                  
                    80
                
            

          
      

    


  

    

      上一篇：
      
        集合Collection总览
      
    

    

      下一篇：
      
        [2]十道算法题【Java实现】
      
    

  



            
  



          

          


  

    
    
    
    

      点赞
      
      
            0
      
    

    
    
      评论
      
            0
      
    
    
    

      书签
      书签
      
          0
      
    

    
    
    
    
    
    
  


            

            

              

              

            

            


  

    

      
          Java3y
      
      

        

          Java3y
            
                  
                    领域专家: 后端开发技术领域
                      领域专家: 后端开发技术领域
                  
            
        

        

            
              博客等级
            
            码龄9年
          1万+粉丝
          509原创
        

      

    

    

          + 关注
    

  



        

        
      

      

        
      

      





	

		评论	
	

  

    

      

      

      

        
        

          
          

            

              成就一亿技术人!
            

            

              拼手气红包6.0元
            

          

        

        

          

            还能输入1000个字符
          

          

             
          

          

            

              表情包
              插入表情
              

                

              

            

            

              表情包
              代码片
              

                
              

            

            

              
              
              
              
              
              
              
            

          

        

      

    

		

			

			

			

					 条评论被折叠 查看
			

			

				
			

		

	

	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值