前言

清明不小心就拖了兩天沒更了～～

這是十道算法題的第二篇了～上一篇回顧：十道簡單算法題

最近在回顧以前使用C寫過的數(shù)據(jù)結(jié)構(gòu)和算法的東西阶牍，發(fā)現(xiàn)自己的算法和數(shù)據(jù)結(jié)構(gòu)是真的薄弱喷面，現(xiàn)在用Java改寫一下，重溫一下走孽。

只能說慢慢積累吧～下面的題目難度都是簡單的惧辈，算法的大佬可直接忽略這篇文章了～入門或者算法薄弱的同學(xué)可參考一下～

很多與排序相關(guān)的小算法(合并數(shù)組、獲取數(shù)字每位值的和)，我都沒有寫下來了煤痕，因為只要會了歸并排序(合并數(shù)組)，會了桶排序(獲取數(shù)字每位的值)碗脊，這些都不成問題了边翁。如果還不太熟悉八大基礎(chǔ)排序的同學(xué)可看:【八大基礎(chǔ)排序總結(jié)】

由于篇幅問題翎承，每篇寫十道吧～

如果有錯的地方，或者有更好的實現(xiàn)符匾，更恰當(dāng)?shù)睦斫夥绞较Ｍ蠹也涣咴谠u論區(qū)留言哦～大家多多交流

十道簡單算法題

題目的總覽

1. 刪除下標(biāo)為k的元素
2. 找出常用的數(shù)字
3. 丟失的數(shù)字
4. 將0放在數(shù)組最后
5. 找出數(shù)組的單個數(shù)字
6. 畫三角形星星
7. 羅馬數(shù)字倒轉(zhuǎn)成阿拉伯?dāng)?shù)字
8. 啤酒與飲料
9. 簡單凱撒密碼
10. 求最大公約數(shù)

一叨咖、刪除下標(biāo)為k的元素

刪除下標(biāo)為k的元素

思路：數(shù)組后一位往前覆蓋即可～

    /**
     * 刪除下標(biāo)為k的元素
     */
    public static void deleteK() {

        //固定的常量(比數(shù)組元素的個數(shù)要大)
        int N = 10;

        int[] arrays = new int[N];

        //對數(shù)組進(jìn)行初始化
        for (int i = 0; i < 8; i++) {
            arrays[i] = i;
        }

        //要刪除下標(biāo)
        int k = 7;

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

        System.out.println("公眾號：Java3y" + arrays);

    }

二、找出常用的數(shù)字

給你一個長度為n的數(shù)組啊胶，其中有一個數(shù)字出現(xiàn)的次數(shù)至少為n/2甸各，找出這個數(shù)字

這道題可以用棧的思想來做：

• 如果棧是空的，那么先把數(shù)據(jù)存進(jìn)去
• 然后繼續(xù)遍歷其他的數(shù)據(jù)焰坪，只要發(fā)現(xiàn)棧中的數(shù)據(jù)和遍歷中的數(shù)據(jù)不一樣趣倾，那么就出棧
• 如果是相同的，那么就入棧
• 其實就是捉住數(shù)字出現(xiàn)的次數(shù)多于數(shù)組一半的長度這里入手某饰。如果這個數(shù)出現(xiàn)的次數(shù)是大于這個數(shù)組長度的2/1誊酌，那么最后留下的肯定是這個數(shù)

image

    /**
     * 找出常用的數(shù)字：
     * 給你一個長度為n的數(shù)組，其中有一個數(shù)字出現(xiàn)的次數(shù)至少為n/2露乏，找出這個數(shù)字
     */

    public static void findMajorityElement(int[] arrays) {

        //構(gòu)建一個靜態(tài)棧
        int[] stack = new int[arrays.length];

        // 棧的front指針
        int front = -1;

        // 遍歷給出的數(shù)組
        for (int i = 0; i < arrays.length; i++) {

            // 判斷該棧為空碧浊，那么直接將元素入棧
            if (front == -1) {
                stack[++front] = arrays[i];
            } else if (stack[front] == arrays[i]) { // 該元素是否與棧的元素一致-->繼續(xù)入棧

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

            }
        }

        // 只要該數(shù)字出現(xiàn)次數(shù)大于數(shù)組長度的2/1瘟仿，那么留下來的數(shù)字肯定在棧頂中
        System.out.println("關(guān)注公眾號：Java3y--->" + stack[0]);
    }

優(yōu)化：

• 其實沒必要用整個棧來裝載數(shù)組箱锐，因為我們就使用棧頂元素(出現(xiàn)次數(shù)最多的那個),而棧的大小也可以通過一個變量就可以來確定了
• 只要元素相同->入棧(長度+1)。元素不相同-->出棧(長度-1)
• 最終留下來的肯定是出現(xiàn)最頻繁的那個數(shù)字!

    public static void findMajorityElement2(int[] arrays) {

        // 裝載棧的元素
        int candidate = -1;

        // 棧的大小(長度)
        int count = 0;

        // 遍歷給出的數(shù)組
        for (int i = 0; i < arrays.length; i++) {

            // 判斷該棧為空劳较，那么直接將元素入棧
            if (count == 0) {

                candidate = arrays[i];
                count++;

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

            }
        }

        // 只要該數(shù)字出現(xiàn)次數(shù)大于數(shù)組長度的2/1驹止，那么留下來的數(shù)字肯定在棧頂中
        System.out.println("關(guān)注公眾號：Java3y--->" + candidate);

    }

三、丟失的數(shù)字

給你一個數(shù)組{0,1,2,3,....n}观蜗，其中有一個數(shù)字缺失臊恋，請把缺失的數(shù)字找出來

思路：

• 創(chuàng)建一個數(shù)組(題目數(shù)組的長度+1，因為題目的數(shù)組缺失了一個)
• 創(chuàng)建的數(shù)組元素用特殊的符號(數(shù)字)來進(jìn)行填滿
• 將題目給出的數(shù)組遍歷并填充到創(chuàng)建的數(shù)組上墓捻，用index(0,1,2,3..)替代
• 最后遍歷創(chuàng)建的數(shù)組抖仅，哪個還是特殊的符號就是缺失的數(shù)字，返回index(缺失的數(shù)字)即可

    /**
     * 找到缺失的數(shù)字
     *
     * @param arrays
     */
    public static void missingNumber(int[] arrays) {

        // 定義要填充到新數(shù)組的數(shù)字(隨意)
        int randomNumber = 89898980;

        // 創(chuàng)建一個新的數(shù)組(比已缺失的數(shù)組多一個長度)
        int[] newArrays = new int[arrays.length + 1];

        // 填充特殊的數(shù)字進(jìn)新數(shù)組中
        for (int i = 0; i < newArrays.length; i++) {

            // 隨意填充數(shù)組到新數(shù)組中
            newArrays[i] = randomNumber;
        }

        // 遍歷題目的數(shù)組并使用index替代掉新數(shù)組的元素
        for (int i = 0; i < arrays.length; i++) {

            // 題目數(shù)組的值[0,1,2,3,4,...n]其中有一個缺失
            int index = arrays[i];

            // 重新填充到新數(shù)組上砖第，index對應(yīng)著題目數(shù)組的值
            newArrays[index] = 3333333;

        }

        // 遍歷新數(shù)組撤卢，只要還有值為89898980，那么那個就是缺失的數(shù)字
        for (int i = 0; i < newArrays.length; i++) {

            if (newArrays[i] == randomNumber) {

                System.out.println("關(guān)注公眾號：Java3y---->缺失的數(shù)字是：" + i);

            }

        }

    }

結(jié)果：

image

優(yōu)化：

• 題目給出的數(shù)組{0,1,2,3,4,5,....n}其中缺失一個數(shù)字梧兼，要把缺失的數(shù)字找出來...我們可以回顧一下高中學(xué)過的等差求和公式:Sn=(a1+an)n/2

• image

• 假設(shè)我們沒有缺失數(shù)字放吩，等差求和公式可以快速得出答案。比如：{0,1,2,3}--->(0+3)*4/2--->6羽杰，如果此時缺失的是2呢渡紫，就是說題目的給出的數(shù)組是:{0,1,3}到推，我們利用等差公式求和之后減去數(shù)組每個元素，最后剩下的數(shù)就是缺失的數(shù)字惕澎！6-1-3-0--->2

所以莉测，我們可以寫出這樣的代碼：

    /**
     * 利用等差公式找到缺失的數(shù)字
     *
     * @param arrays
     */
    public static void missingNumber2(int[] arrays) {

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

        // 遍歷數(shù)組，得出的sum減去數(shù)組每一位元素集灌，最后即是缺失的數(shù)字

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

        System.out.println("關(guān)注公眾號：Java3y---->缺失的數(shù)字是：" + sum);

    }

結(jié)果：

image

四、將0放在數(shù)組最后

將一個數(shù)組的元素复哆，其中是0的欣喧，放在數(shù)組的最后

思路：

• 使用一個變量zero來記住該數(shù)組有多少個0
• 遍歷這個數(shù)組，如果發(fā)現(xiàn)不是0的梯找，就往數(shù)組前面移動唆阿，如果發(fā)現(xiàn)是0就zero++
• 數(shù)組移動的位置剛好是arr[i-zero]的

代碼實現(xiàn)：

    /**
     * 移動元素0到數(shù)組最后
     *
     * @param arrays
     */
    public static void moveZero(int[] arrays) {

        // 記錄該數(shù)組有多少個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\. 前面已經(jīng)將非0的元素移動到數(shù)組的前面了
        // 2\. 將為0的元素填滿數(shù)組驯鳖，填充的位置就從length - zero開始

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

        System.out.println("關(guān)注公眾號：Java3y---->" + arrays);

    }

結(jié)果：

image

還可以換種思路(差別不大)：將數(shù)組分成幾個部分：在j之前的沒有0，j到i全是0久免，i后面還沒有遍歷

• 如果遍歷到的數(shù)字不是0浅辙，那么跟j進(jìn)行交換，j++(保證j前面沒有0和j到i全是0)
• 直至i遍歷完畢后阎姥，j前面都不是0记舆，j-i都是0(這就完成我們的任務(wù)了)

代碼實現(xiàn)：

    /**
     * 移動元素0到數(shù)組最后
     *
     * @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ìn)行交換，保證j的前面都不是0
                int temp = arrays[i];
                arrays[i] = arrays[j];
                arrays[j]  = temp;

                j++;
            }
        }

        // 直至i遍歷完畢后呼巴，j前面都不是0泽腮，j-i都是0(這就完成我們的任務(wù)了)

        System.out.println("關(guān)注公眾號：Java3y---->" + arrays);

    }

結(jié)果還是一樣的：

image

五、找出數(shù)組的單個數(shù)字

給你一個數(shù)組衣赶，除了一個數(shù)字外诊赊，其他的數(shù)字都出現(xiàn)了兩次，請把這個只出現(xiàn)一次的數(shù)字找出來府瞄。

思路：

• 將該數(shù)組遍歷一次碧磅，記錄每個數(shù)字出現(xiàn)的次數(shù)
• 如果該數(shù)字出現(xiàn)的次數(shù)只有1，那么該數(shù)字就是單個數(shù)字～

    /**
     * 找出數(shù)組的單個數(shù)字
     * @param nums
     * @return
     */
    public static void singleNumber(int[] nums) {

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

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

            // 如果該元素只出現(xiàn)一次遵馆，那么就是它了续崖！
            if (count == 1) {
                System.out.println("關(guān)注公眾號：Java3y--->單一的元素是：" + nums[i]);

                return ;

            }

        }
    }

    /**
     * 找出每個元素出現(xiàn)的次數(shù)
     * @param nums 數(shù)組
     * @param value 想知道出現(xiàn)次數(shù)的元素
     */

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

        int count = 0;

        for (int i = 0; i < nums.length; i++) {
            if (value == nums[i]) {
                count++;
            }
        }
        // 返回該元素出現(xiàn)的次數(shù)
        return count;
    }

結(jié)果：

image

優(yōu)化：

這個問題最佳的解法是用到了位運算的異或操作：

• 如果5^5=0
• 如果5^7^5 = 7
• 如果5^6^6^5^7^8^7 = 8

從上面的例子可以看出：一堆數(shù)字做異或運算^，倆倆相同數(shù)字就會被抵消掉～团搞，所以這個特性對于這個題目而言就再適合不過的了：

    /**
     * 找出數(shù)組的單個數(shù)字
     * @param nums
     * @param numsSize
     * @return
     */
    public static int singleNumber(int[] nums, int numsSize) {

        // 第一個數(shù)和數(shù)組后面的數(shù)做^運算严望，留下的必然是單個數(shù)字
        int k = nums[0];
        for (int i = 1; i < numsSize; i++) {
            k = (k ^ nums[i]);
        }
        return k;
    }

六、畫三角形星星

畫三角形星星

image

就是要畫上面那種三角形星星逻恐，那怎么畫呢像吻？峻黍？

思路：

• 首先，我們可以發(fā)現(xiàn)：每行星星的個數(shù)是(2行數(shù)-1)拨匆，每行的空格數(shù)就是最大行數(shù)減去第n行*(最大4行姆涩，第4行沒有空格，最大4行惭每，第三行1個空格)
• 有了上面的規(guī)律骨饿，套個for循環(huán)即可生成三角形星星～

實現(xiàn)代碼：

    /**
     * 畫星星
     */
    public static void drawStar() {

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

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

            // 空格數(shù)等于最大行數(shù) - 當(dāng)前行數(shù)
            for (int j = 1; j <= row - i; j++) {
                System.out.print(" ");
            }

            // 星星數(shù)等于(當(dāng)前行數(shù)*2-1)
            for (int j = 1; j <= i * 2 - 1; j++) {

                System.out.print("*");

            }

            // 每畫一行就換一次行
            System.out.println();
        }
    }

結(jié)果：

image

七、羅馬數(shù)字倒轉(zhuǎn)成阿拉伯?dāng)?shù)字

羅馬數(shù)字倒轉(zhuǎn)成阿拉伯?dāng)?shù)字

羅馬數(shù)字我們可能在英語的題目中看得是比較多的台腥，一般常用的我們是阿拉伯?dāng)?shù)字宏赘，那怎么轉(zhuǎn)成阿拉伯?dāng)?shù)字呢？黎侈？我們先來了解一下羅馬數(shù)字：

image

ps:來源360百科

規(guī)則在圖上已經(jīng)說得挺明白的了察署，我舉幾個例子：

• 左邊的數(shù)比右邊小，則是用右邊的數(shù)減去左邊的
• 左邊的數(shù)比右邊大峻汉，則是用右邊的數(shù)加上左邊的

image

image

看了上面的例子估計我們會手算將羅馬數(shù)字轉(zhuǎn)成阿拉伯?dāng)?shù)字了贴汪，那么用程序怎么寫呢？休吠？扳埂？

思路是這樣的：

• 先找到羅馬數(shù)字最大的那個數(shù)字
• 要是左邊的數(shù)比右邊小，則是用右邊的數(shù)減去左邊的
• 左邊的數(shù)比右邊大瘤礁，則是用右邊的數(shù)加上左邊的
• .....如此循環(huán)則最后獲取阿拉伯?dāng)?shù)字

首先聂喇，我們先定義羅馬數(shù)字和對應(yīng)的阿拉伯?dāng)?shù)字(相當(dāng)于查表)

    // 定義羅馬數(shù)字
    char digits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};

    // 羅馬數(shù)字對應(yīng)的阿拉伯?dāng)?shù)字
    int  values[] = { 1,  5, 10, 50, 100, 500, 1000};

隨后，我們得找到羅馬數(shù)字當(dāng)前的最大值蔚携，找到最大值之前就先得把羅馬數(shù)字轉(zhuǎn)成是阿拉伯?dāng)?shù)字

    /**
     * 將羅馬數(shù)字轉(zhuǎn)成阿拉伯?dāng)?shù)字希太，實際上就是一個查表的過程
     *
     * @param roman
     * @return
     */
    public static int digitsToValues(char roman) {

        // 定義羅馬數(shù)字
        char digits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};

        // 羅馬數(shù)字對應(yīng)的阿拉伯?dāng)?shù)字
        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;

    }

上面的方法已經(jīng)可以將羅馬數(shù)字轉(zhuǎn)成阿拉伯?dāng)?shù)字了，接下來我們要查找出最大值了

    /**
     * 找到當(dāng)前羅馬數(shù)字最大值的角標(biāo)
     *
     * @param digits
     * @return
     */
    public static int findMaxIndex(String digits, int L, int R) {

        // 假設(shè)第一個是最大的
        int max = digitsToValues(digits.charAt(L));
        int maxIndex = L;

        for (int i = L; i < R; i++) {
            // 將羅馬數(shù)字轉(zhuǎn)成是阿拉伯?dāng)?shù)字
            int num = digitsToValues(digits.charAt(i));
            if (max < num) {
                max = num;
                maxIndex = i;
            }
        }

        return maxIndex;
    }

找到了當(dāng)前羅馬數(shù)字的最大值那要怎么做酝蜒？誊辉？？

• 左邊的比右邊的要小亡脑，則右邊的減去左邊的值
• 左邊的比右邊的要大堕澄，則右邊的加上左邊的值
• ....///實際上是一個遞歸的過程

于是乎，我們可以寫出下面的代碼：

    /**
     * 將羅馬數(shù)字轉(zhuǎn)成阿拉伯?dāng)?shù)字
     *
     * @param romanNumber
     * @param L
     * @param R
     */
    public static int romanToNumber(String romanNumber, int L, int R) {

        // 如果只有一個羅馬數(shù)字霉咨，那么可以直接返回了(遞歸出口)
        if (L == R) {
            return digitsToValues(romanNumber.charAt(L));
        } else if (L > R) { // 如果L和R已經(jīng)越界了蛙紫，那么說明沒有值了
            return 0;
        } else {

            // 找到當(dāng)前羅馬數(shù)字最大值的角標(biāo)
            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;
        }
    }

測試一下：

image

八坑傅、啤酒與飲料

啤酒每罐2.3元，飲料每罐1.9元喷斋。小明買了若干啤酒和飲料唁毒，一共花了82.3元蒜茴。我們還知道他買的啤酒比飲料的數(shù)量少，請你計算他買了幾罐啤酒浆西。

這是藍(lán)橋杯的一道題粉私，我們可以使用暴力搜索即可解出：

• 如果82.3全買啤酒最多能買82.3/2.3=35瓶
• 如果82.3全買飲料最多能買82.3/1.9=43瓶
• 以此作為控制條件

    /**
     * 啤酒與飲料題目
     */
    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("關(guān)注公眾號：Java3y--------------->啤酒買了" + i);
                }
            }
        }
    }

測試：

image

九近零、簡單凱撒密碼

簡單凱撒密碼

凱撒密碼是啥诺核？簡單來說：就是通過移位來進(jìn)行加密

• 比如，A-->B,B-->C,C-->D.......

上面就是最簡單的凱撒密碼久信，將所有的字母進(jìn)行移一位窖杀，實現(xiàn)加密

image

下面我們也來玩一下吧～

左移動和右移動：

    /**
     * 右移
     */
    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移動的是正數(shù)入篮，那么就向右移動
            for (int i = 0; i < shift; i++) {
                ch = rotateRight(ch);
            }
            return ch;
        } else {

            // 如果shift移動的是負(fù)數(shù)陈瘦，那么就向左移動
            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("關(guān)注公眾號：Java3y" + ch);

結(jié)果：

image

十幌甘、求最大公約數(shù)

求一個數(shù)的最大公約數(shù)

算法：是兩個數(shù)相余潮售，直到余數(shù)為0，如果余數(shù)不為0锅风，就用除數(shù)和余數(shù)求余

• 若發(fā)現(xiàn)余數(shù)為0酥诽，那么當(dāng)前的除數(shù)就是最大公約數(shù)

    /**
     * 求最大公約數(shù)
     *
     * @param num1
     * @param num2
     */
    public static int gcd(int num1, int num2) {

        // 求余數(shù)
        int r = num1 % num2;

        // 如果余數(shù)為0，那么除數(shù)就是最大公約數(shù)
        if (r == 0) {
            return num2;
        } else {

            // 否則皱埠，則用除數(shù)和余數(shù)來進(jìn)行運算
            return gcd(num2, r);
        }

    }

結(jié)果：

image

總結(jié)

沒錯肮帐，你沒看錯，簡單的小算法也要總結(jié)边器！

其實我覺得這些比較簡單的算法是有"套路"可言的训枢，你如果知道它的套路，你就很容易想得出來忘巧，如果你不知道它的套路恒界，那么很可能就不會做了(沒思路)。

積累了一定的"套路"以后砚嘴，我們就可以根據(jù)經(jīng)驗來推斷十酣，揣摩算法題怎么做了。

舉個很簡單的例子：

• 乘法是在加法的基礎(chǔ)之上的际长，那乘法我們是怎么學(xué)的耸采？背(積累)出來的，9*9乘法表誰沒背過工育？比如看到2+2+2+2+2虾宇，會了乘法(套路)以后，誰還會慢慢加上去如绸∥牧簦看見了5個2好唯，就直接得出2*5了

1. 刪除下標(biāo)為k的元素
   • 后一位往前一位覆蓋即可
2. 找出常用的數(shù)字
   • 利用棧的思想，只要該數(shù)組出現(xiàn)的次數(shù)大于2分之1燥翅，那么他肯定是在棧里面
3. 丟失的數(shù)字
   • 實現(xiàn)1：兩個數(shù)組進(jìn)行遍歷骑篙，如果某一個不存在，利用數(shù)組的角標(biāo)就可以找到～
   • 實現(xiàn)2：使用等差求和公式森书，缺失的數(shù)字可以減出來靶端！
4. 將0放在數(shù)組最后
   • 實現(xiàn)1：使用變量zero來記住有多少個0，只要不是0就往前面移動凛膏，最后將zero補全杨名！
   • 實現(xiàn)2：將數(shù)組分成3個部分；在j之前的沒有0猖毫，j到i全是0台谍，i后面還沒有遍歷，直至i遍歷完畢后吁断，j前面都不是0趁蕊，j-i都是0(這就完成我們的任務(wù)了)
5. 找出數(shù)組的單個數(shù)字
   • 實現(xiàn)1：遍歷數(shù)組計算某個元素出現(xiàn)的次數(shù)，外層再遍歷數(shù)組仔役，只要該元素出現(xiàn)的次數(shù)是1掷伙，那么它就是單個的！
   • 實現(xiàn)2：位運算的異或操作又兵，相同的兩個數(shù)字會抵消掉任柜！
6. 畫三角形星星
   • 找到畫星星和空格的規(guī)律！星星和空格都與行數(shù)有關(guān)聯(lián)沛厨！
7. 羅馬數(shù)字倒轉(zhuǎn)成阿拉伯?dāng)?shù)字
   • 將羅馬數(shù)組和阿拉伯?dāng)?shù)字對應(yīng)起來宙地，“查表”進(jìn)行轉(zhuǎn)換！找到最大的值逆皮，左邊比右邊要小宅粥，則右減左。反之右加左页屠！
8. 啤酒與飲料
   • 使用暴力查詢的方式來將具體的值搜索出來粹胯！
9. 簡單凱撒密碼
   • char本質(zhì)上就是int，移動時要主要Z辰企，A這些字符～
10. 求最大公約數(shù)

*   如果余數(shù)為0风纠，那么除數(shù)就是最大公約數(shù)，否則就是除數(shù)和余數(shù)再繼續(xù)運算牢贸！

image

補充：@大航海家給出的幾個優(yōu)化和思路：

啤酒題目：

2018-04-27_143932.png

二分查找缺失值：

2018-04-27_143938.png

將0移動到數(shù)組最后：

2018-04-27_143942.png

具體的代碼可在評論區(qū)下找~

文章的目錄導(dǎo)航：https://zhongfucheng.bitcron.com/post/shou-ji/gong-zhong-hao-wen-zhang-zheng-li

如果文章有錯的地方歡迎指正竹观，大家互相交流。習(xí)慣在微信看技術(shù)文章，想要獲取更多的Java資源的同學(xué)臭增，可以關(guān)注微信公眾號:Java3y