十道算法题[二]

最新推荐文章于 2022-07-12 22:05:55 发布
最新推荐文章于 2022-07-12 22:05:55 发布
阅读量347 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Java_3y/article/details/98867526
版权 
 
 
前言
 
 
清明不小心就拖了两天没更了～～
 
 
这是十道算法题的第二篇了～上一篇回顾：十道简单算法题
 
 
最近在回顾以前使用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
 
 
 
 

 


                

        

        

    




    

      

        

            

              
                
                  Java3y
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

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

				
			

			

				

					bigsai
				

				

					12-29
					
					6332
					
				

			

		

		

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

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

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

			
		

	



                

              
                



	

		

			

				
					
10道算法题

				
			

			

				

					diaobiao8107的博客
				

				

					08-22
					
					229
					
				

			

		

		

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

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

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

			
		

	



                


  
              

                


	

		

			

				
					
一天十道算法题（day3）

				
			

			

				

					很注重数学和408
				

				

					04-11
					
					462
					
				

			

		

		

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

			
		

	





	

		

			

				
					
十道经典面试算法真题详解

				
			

			

				

					weixin_62650212的博客
				

				

					04-01
					
					2万+
					
				

			

		

		

			
				
分享一下腾讯常考的十道算法题（真题）。在金三银四，希望对大家有帮助呀。重排链表最长递增子序列环形链表反转链表最长回文子串全排列LRU 缓存合并K个升序链表无重复字符的最长子串删除链表的倒数第 N 个结点1.  重排链表给定一个单链表 L 的头节点 head ，单链表 L 表示为：L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：L0...

			
		

	



		

			
		



	

		

			

				
					
十道腾讯算法真题解析

				
			

			

				

					weixin_64314555的博客
				

				

					03-08
					
					6900
					
				

			

		

		

			
				
前言

大家好，这里收集了腾讯常考的十道算法题（真题）。在金三银四，希望对大家有帮助呀。

重排链表
	最长递增子序列
	环形链表
	反转链表
	最长回文子串
	全排列
	LRU 缓存
	合并K个升序链表
	无重复字符的最长子串
	删除链表的倒数第 N 个结点
公众号：捡田螺的小男孩
1. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：


L0 → L1 → … → Ln - 1 → Ln
复制代码

请将其重新排列后变为：


L0 → Ln → L1 → Ln - 1 → 

			
		

	





	

		

			

				
					
C语言经典算法100道实战题

				
			

			

				

					C/C++编程指南
				

				

					07-12
					
					2万+
					
				

			

		

		

			
				
C语言经典算法100道实战题

			
		

	





	

		

			

				
					
70道面试常见算法题

				
			

			

				

					GavinGreenson的博客
				

				

					05-18
					
					1363
					
				

			

		

		

			
				
字符串的循环移位
三次翻转


字符串的包含
哈希表


字符串全排列
next_permutation算法


字符串的所有组合
dfs


字符串转整数
stoi(), stol(), 注意边界


回文判断：判断字符串是否为回文串
双指针从两头往中间扫描


判断链表是否回文
（1）快慢指针找中点（2）翻转后半部分（3）遍历比较两段链表


判断栈是否回文
出栈后再入栈，与原字符串比较是否完全相同


最长回文子串
manacher算法：（1）预处理（2）id记录最远回文串中心，mx记录最远回文串..

			
		

	





	

		

			

				
					
2020年专业408的算法题

				
			

			

				

					韩江雪de 小屋
				

				

					09-26
					
					7440
					
				

			

		

		

			
				
文章目录1 题目2 解法一（朴素算法）3 解法二
1 题目
定义三元组（a,b,c）(a,b,c均为整数)的距离D=∣a−b∣+∣b−c∣+∣c−a∣D=|a-b| + |b-c|+|c-a|D=∣a−b∣+∣b−c∣+∣c−a∣。给定3个非空整数集合S1，S2和S3，按升序分别存储在3个数组中。请设计一种尽可能高效的算法，计算并输出所有可能的三元组(a,b,c)(a∈S1,b∈S2,c∈S3a \in S1,b \in S2,c \in S3a∈S1,b∈S2,c∈S3)中的最小距离。
例如，S1={-1

			
		

	





	

		

			

				
					
Leetcode算法题：几道二维数组题

				
			

			

				

					yfy1127yfy的博客
				

				

					12-04
					
					5400
					
				

			

		

		

			
				
对角线算法可以进一步合并，但不合并的话可读性更好，这里就不合并了。

一、对角线遍历

给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素，对角线遍历如下图所示。



示例:


输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]

输出:  [1,2,4,7,5,3,6,8,9]

解释:


...

			
		

	





	

		

			

				
					
2020最新-精选基础算法100题（面试必备）

					
热门推荐

				
			

			

				

					ATFWUS的博客
				

				

					05-18
					
					28万+
					
				

			

		

		

			
				
0x01.概述

作为一个程序员，算法能力必不可少，虽然不一定是算法工程师，但是算法还是彰显着个人的编码能力，面试中也经常会被问到，甚至会被要求临场做算法题，所以，还是好好积累吧。


个人其实对算法挺有兴趣的，从3月份开始，陆陆续续刷了一些算法题，把一些有意义的记录下来了，也顺便写了一些题解，个人认为，还是挺有收获的。
之前写了一篇算法文章的目录，不过后来就忘了实时去更新了，于是现在，想把之前做过的一些有意义的算法题分享出来，刚好整理了100篇比较有意义的。希望对大家有所帮助。


0x02.说明


关

			
		

	





	

		

			

				
					
关于数据结构与算法80道题

				
			

			

				

					03-16
				

			

		

		

			
				
通过解决这80道题，学习者可以全面掌握数据结构与算法的核心概念，提高编程能力，并为面试和实际工作中的问题解决打下坚实基础。在实践中不断迭代和优化解决方案，将有助于深入理解这些基础知识，并能够灵活应用到...

			
		

	





	

		

			

				
					
自己总结的二十四道js算法题

				
			

			

				

					11-19
				

			

		

		

			
				
js所有的算法，自己总结的，如有遗漏，请留言。希望可以帮助到需要的人

			
		

	





	

		

			

				
					
C语言算法题C语言算法题.zip

				
			

			

				

					01-28
				

			

		

		

			
				
"C语言算法题.zip"这个压缩包很可能包含了一系列的C语言编程练习，旨在帮助学习者提升算法设计和实现的能力。在C语言中，算法是解决问题的关键，通过编写高效的代码，可以有效地处理数据和执行计算任务。  1. **基础...

			
		

	





	

		

			

				
					
20道Python算法题及答案

				
			

			

				

					06-11
				

			

		

		

			
				
以下是对这20道Python算法题及答案的详细解析：  1. **排序算法**：Python中常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。了解它们的基本原理和时间复杂度对于优化代码性能至关重要。  2. ...

			
		

	





	

		

			

				
					
算法笔试题：（Python实现）—— 算法面试题汇总

				
			

			

				

					01-21
				

			

		

		

			
				
算法笔试题：（Python实现）—— 算法面试题汇总算法笔试题：（Python实现）—— 算法面试题汇总开始之前Python实现只出现一次的数字多数元素搜索二维矩阵 II合并两个有序数组鸡蛋掉落字符串Python实现验证回文串...

			
		

	





	

		

			

				
					
超市管理系统，基于javaweb.zip

				
			

			

				

					08-15
				

			

		

		

			
				
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助
【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无积分，此资源可私信获取】
【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助
【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步
【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中
可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能
#注
1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担
2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于收集和整理资料耗费时间的酬劳

			
		

	





	

		

			

				
					
vue3面试题2023,84页，几十道vue面试题，准备vue的面试，这么一份文件就够了

				
			

			

				

					08-15
				

			

		

		

			
				
vue3面试题2023：
Vue 的优缺点
 优点
1.创建单页面应用的轻量级Web应用框架
2.简单易用
3.双向数据绑定
4.组件化的思想
5.虚拟DOM
6.数据驱动视图
缺点
不支持IE8

			
		

	





	

		

			

				
					
【雷达跟踪】基于matlab雷达目标生成与跟踪【含Matlab源码 7220期】.zip

				
			

			

				

					08-15
				

			

		

		

			
				
CSDN海神之光上传的代码均可运行，亲测可用，直接替换数据即可，适合小白；
1、代码压缩包内容
主函数：main.m；
调用函数：其他m文件；无需运行 
运行结果效果图；

2、代码运行版本
Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主；

3、运行操作步骤
步骤一：将所有文件放到Matlab的当前文件夹中； 
步骤二：双击打开main.m文件； 
步骤三：点击运行，等程序运行完得到结果；

4、仿真咨询
如需其他服务，可私信博主或扫描博客文章底部QQ名片；
4.1 博客或资源的完整代码提供
4.2 期刊或参考文献复现
4.3 Matlab程序定制
4.4 科研合作
功率谱估计：
故障诊断分析：
雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩
滤波估计：SOC估计
目标定位：WSN定位、滤波跟踪、目标定位
生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG
通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪（CEEMDAN）、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信


			
		

	





	

		

			

				
					
CTR2024中国广告主营销趋势调查报告.pdf

					
最新发布

				
			

			

				

					08-15
				

			

		

		

			
				
【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2

			
		

	





	

		

			

				
					
C++程序设计与算法真题解析

				
			

			

				

					
				

			

		

		

			
				
本资源是关于二级C++考试的真题及答案，涵盖了计算机基础知识、C++语言程序设计、算法设计、数据结构、面向对象方法、软件开发、数据库系统等多个方面的知识点。下面是对标题、描述、标签和部分内容的详细解释和知识...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值