Java數據結構和算法總結-字符串相關高頻面試題算法

　　前言：周末閑來無事，看了看字符串相關算法的講解視頻，收貨頗豐，跟着視頻講解簡單做了一下筆記，方便以后翻閱復習同時也很樂意分享給大家。什么字符串在算法中有多重要之類的大路邊上的客套話就不多說了，直接上筆記吧。

一、字符串

• java：String內置類型，不可更改。（如需更改可考慮：StringBuffer, StringBuilder,char[]等）

二、歸類

　字符串涉及到的相關題型通常會是以下幾個方面：

• 概念理解：字典序
• 簡單操作：插入刪除字符、旋轉
• 規則判斷（羅馬數字轉換 是否是合法的整數、浮點數）
• 數字運算（大數加法，二進制加法）
• 排序、交換
• 字符計數：變位詞
• 匹配（正則表達式、全串匹配、KMP、周期判斷）
• 動態規划（LCS、編輯距離、最長回文子串）
• 搜索（單詞變換、排列組合）

三、例題

1、交換：把一個只包含01的串排序，可交換任意兩個數的位置，最少需要多少次交換？

　　思路：從兩頭往中間掃盪，掃盪過程中在左邊遇到1就和右邊遇到的0交換位置，直接到左有下標相遇時結束。 具體代碼如下：

public static void main(String[] strs) {
        int count = 0;
        int[] arrays = new int[] {0, 0, 1, 1, 1, 0, 1, 0, 0, 1};
        int left = 0;
        int right = arrays.length - 1;
        while (true) {
            while (arrays[left] == 0) {
                left++;
            }
            while (arrays[right] == 1) {
                right--;
            }
            if (left >= right) {
                break;
            } else {
                int temp = arrays[left];
                arrays[left] = arrays[right];
                arrays[right] = temp;
                count++;
            }
        }
        Logger.println("交換次數：" + count);
        for (int array : arrays) {
            Logger.print(array + ", ");
        }
}

清晰起見，交換次數和排序后的的字符串輸出如下：

交換次數：3
0, 0, 0, 0, 0, 1, 1, 1, 1, 1,

2、字符串替換和復制：刪除一個字符串所有的a，並且復制所有的b（字符數組足夠大）

　　思路：詳細思路見代碼注釋

public static void main(String[] strs) {
        char[] input = new char[]{'a', 'b', 'c', 'd', 'a', 'f', 'a', 'b', 'c', 'd', 'b', 'b', 'a', 'b'};
        char[] chars = new char[50];
        for (int j = 0; j < input.length; j++) {
            chars[j] = input[j];
        }
        Logger.println("操作前：");
        for (char c:chars
                ) {
            Logger.print(c + ", ");
        }
        int n = 0;
        int countB = 0;
        // 1、刪除a，用n當做新下標，循環遍歷數組，凡是不是a的元素都放到新下標的位置，由於新n增長慢，老下標i增長快，所以元素不會被覆蓋。
        // 並且在刪除a時順便記錄b的數量，以便下一步復制b時可以提前確定數組最終的最大的下標。
        for (int i = 0; chars[i] != '\u0000' && i < chars.length; i++) {
            if (chars[i] != 'a') {
                chars[n++] = chars[i];
            }
            if (chars[i] == 'b') {
                countB++;
            }
        }

        // 2、復制b，由於在第一步中就已經知道了字符串中b的個數，這里就能確定最終字符串的最大下標，從最打下表開始倒着復制原字符串，碰到b時復制即可。
        int newMaxIndex = n + countB - 1;
        for (int k = n - 1; k >= 0; k--) {
            chars[newMaxIndex--] = chars[k];
            if (chars[k] == 'b') {
                chars[newMaxIndex--] = chars[k];
            }
        }

        Logger.println("\n操作后：");
        for (char c:chars
                ) {
            Logger.print(c + ", ");
        }
}

3、交換星號：一個字符串只包含 * 和數字，請把它的 * 都放在開頭。

　　如：1 * 2 * 4 * 3 => * * * 1 2 4 3

• 方案一：倒着操作，從最大下標開始向前遍歷，遇到非 * 號的元素則加入"新"下標中，遍歷完畢后，j即代表 * 號的個數，然后將0-j賦值為 * 即可。（操作后，數字的相對位置不變） 代碼如下：

public static void main(String[] strs) {
        char[] chars = new char[]{'1', '*', '4', '3', '*', '5', '*'};
        // 方案一（操作后，數字的相對位置不變）
        // 倒着操作：從最大下標開始向前遍歷，遇到非*號的元素則加入"新"下標中，遍歷完畢后，j即代表*號的個數，然后將0-j賦值為*即可。
        int j = chars.length - 1;
        for (int i = j; i >= 0; i--) {
            if (chars[i] != '*') {
                chars[j--] = chars[i];
            }
        }
        while (j >= 0) {
            chars[j--] = '*';
        }
        for (char c:chars
                ) {
            Logger.print(c + ", ");
        }
}

輸出結果如下:

*, *, *, 1, 4, 3, 5,

• 方案二（操作后，數組的相對位置會變）快排划分，根據循環不變式（每一步循環之后條件都成立）:如本題[0..i-1]是*,[i..j-1]是數字,[j...n-1]未探測，循環時，隨着i和j增加，維護此條件依然不變，代碼如下:

public static void main(String[] strs) {
        char[] chars = new char[]{'1', '*', '4', '3', '*', '5', '*'};
        // 方案二（操作后，數組的相對位置會變）
        // 快排划分，根據循環不變式（每一步循環之后條件都成立）:如本題[0..i-1]是*,[i..j-1]是數字,[j...n-1]未探測，循環時，隨着i和j增加，維護此條件依然不變
        for (int i = 0, j = 0; j < chars.length; ++j) {
            if (chars[j] == '*') {
                char temp = chars[i];
                chars[i] = chars[j];
                chars[j] = temp;
                i++;
            }
        }
        for (char c:chars
                ) {
            Logger.print(c + ", ");
        }
} 

輸出結果如下：

*, *, *, 3, 1, 5, 4,

4、單詞翻轉

　　例如：I am a student =》 student a am I

　　思路：

　　1、先將整個字符串翻轉：如：I am a student =》 tneduts a ma I

　　2、通過空格判斷出每個單詞，然后對每個單詞進行翻轉

　　代碼如下:

public static void main(String[] strs) {
        String input = "I am a student";
        char[] chars = input.toCharArray();
        int i = 0;
        int j = chars.length - 1;
        while (i < j) {
            swap(chars, i++, j--);
        }
        int front = 1;
        int tail = 0;
        while (front < chars.length) {
            if (chars[front] == ' ') {
                int frontTemp = front - 1;
                while (tail < frontTemp) {
                    swap(chars, tail++, frontTemp--);
                }
                tail = front + 1;
            }
            front++;
        }
        for (char c:chars
                ) {
            Logger.print(c);
        }
}

public static void swap(char[] chars, int index1, int index2) {
        char temp = chars[index1];
        chars[index1] = chars[index2];
        chars[index2] = temp;
}

輸出結果如下:

student a am I

5、子串變位詞：給定兩個串a和b，問b是否a的子串變位詞。

　　例如：a=hello。b=lel，lle，ello都是true；b=elo是false

　　思路：

• • 　　一、首先需要了解對兩個串是否是變位詞的判斷：

1. 1. 　　對兩個串按統一規則排序，排序后若相等則是變位詞。
   2. 　　對兩個串中出現的字母統計，兩串中相同的字母出現的次數一致則為變位詞。

• • 　　二、然后從母串的第一個元素遍歷，每往后遍歷一個元素就把從當前元素開始到加上子串的長度的位置作為一個區間和子串比較是否是變位詞。

最后一題綜合前幾個題用到的一些技巧，還是比較有趣的，這里就不貼出代碼了，也激發一下大家的動手能力，感興趣的童鞋不妨試着寫一寫。

以上問題如有不同思路歡迎交流。