LeetCode（String)1768. Merge Strings Alternately

约定不等于承诺〃 2023-09-27 20:53 20阅读 0赞

# 1.问题 #

You are given two strings word1 and word2. Merge the strings by adding letters in alternating order, starting with word1. If a string is longer than the other, append the additional letters onto the end of the merged string.

Return the merged string.

Example 1:

> Input: word1 = “abc”, word2 = “pqr”  
> Output: “apbqcr”  
> Explanation: The merged string will be merged as so:  
> word1: a b c  
> word2: p q r  
> merged: a p b q c r

Example 2:

> Input: word1 = “ab”, word2 = “pqrs”  
> Output: “apbqrs”  
> Explanation: Notice that as word2 is longer, “rs” is appended to the end.  
> word1: a b  
> word2: p q r s  
> merged: a p b q r s

Example 3:

> Input: word1 = “abcd”, word2 = “pq”  
> Output: “apbqcd”  
> Explanation: Notice that as word1 is longer, “cd” is appended to the end.  
> word1: a b c d  
> word2: p q  
> merged: a p b q c d

Constraints:

1 <= word1.length, word2.length <= 100  
word1 and word2 consist of lowercase English letters.

# 2. 解题思路 #

## 方法1： ##

> 1.计算字符串 word1 和 word2 的长度  
> 2.定义 StringBuffer 类型的结果字符串 s  
> 3. 定义指针 i，初始值为 0  
> 4.当两个字符串的长度均未变为 0 时，依次取出一个字符，将其拼接到结果字符串中  
> 5.返回最终的结果字符串

## 方法2： ##

> 使用双指针，从两个字符串的第一个字符开始，依次取出一个字符，将其拼接到结果字符串中。然后移动指针，直到其中一个字符串的指针到达字符串末尾。

## 方法3： ##

> 1.  定义空字符串作为结果
> 2.  循环遍历长度
> 3.  如果word1长度大于i，则把第i个字符加入结果字符串中
> 4.  如果word2长度大于i，则把第i个字符加入结果字符串中
> 5.  返回结果字符串

# 3. 代码 #

## 代码1： ##

class Solution {
        
        public String mergeAlternately(String word1, String word2) {
        
            // 计算字符串 word1 和 word2 的长度
            int len1 = word1.length();
            int len2 = word2.length();
            // 定义 StringBuffer 类型的结果字符串 s
            StringBuffer s = new StringBuffer();
            // 定义指针 i，初始值为 0
            int i = 0;
            // 当两个字符串的长度均未变为 0 时，依次取出一个字符，将其拼接到结果字符串中
            while (len1 != 0 || len2 != 0) {
        
                if (len1 != 0) {
        
                    s.append(word1.charAt(i));
                    len1--;
                }
                if (len2 != 0) {
        
                    s.append(word2.charAt(i));
                    len2--;
                }
                i++;
            }
            // 返回最终的结果字符串
            return s.toString();
        }
    }

## 代码2： ##

class Solution {
        
        public String mergeAlternately(String word1, String word2) {
        
            // 计算字符串 word1 和 word2 的长度
            int n1 = word1.length(), n2 = word2.length();
            // 定义 StringBuilder 类型的结果字符串 res
            StringBuilder res = new StringBuilder();
            // 定义双指针 i 和 j，初始值均为 0
            int i = 0, j = 0;
            // 当两个指针均未到达字符串末尾时，依次取出一个字符，将其拼接到结果字符串中
            while (i < n1 && j < n2) {
        
                res.append(word1.charAt(i++));
                res.append(word2.charAt(j++));
            }
            // 当其中一个字符串的指针到达字符串末尾时，将另一个字符串的剩余部分全部拼接到结果字符串中
            if (i < n1) {
        
                res.append(word1.substring(i));
            }
            if (j < n2) {
        
                res.append(word2.substring(j));
            }
            // 返回最终的结果字符串
            return res.toString();
        }
    }

> 解题思路相同

class Solution {
        
        public String mergeAlternately(String w1, String w2) {
        
            int n = w1.length(), m = w2.length(), i = 0, j = 0;
            StringBuilder res = new StringBuilder(); // 定义 StringBuilder 类型的结果字符串 res
            while (i < n || j < m) {
         // 只要 i 或 j 指针未到达字符串末尾，就继续拼接字符串
                if (i < w1.length()) // 如果 i 指针未到达 w1 的末尾，就取出当前字符，拼接到结果字符串中
                    res.append(w1.charAt(i++));
                if (j < w2.length()) // 如果 j 指针未到达 w2 的末尾，就取出当前字符，拼接到结果字符串中
                    res.append(w2.charAt(j++));
            }
            return res.toString(); // 返回最终的结果字符串
        }
    }

class Solution {
        
        public String mergeAlternately(String word1, String word2) {
        
            StringBuilder result = new StringBuilder(); // 定义 StringBuilder 类型的结果字符串
            int i = 0;
            while (i < word1.length() || i < word2.length()) {
         // 只要 i 指针未到达 word1 和 word2 的末尾，就继续拼接字符串
                if (i < word1.length()) {
         // 如果 i 指针未到达 word1 的末尾，就取出当前字符，拼接到结果字符串中
                    result.append(word1.charAt(i));
                }
                if (i < word2.length()) {
         // 如果 i 指针未到达 word2 的末尾，就取出当前字符，拼接到结果字符串中
                    result.append(word2.charAt(i));
                }
                i++; // 指针向后移动一位
            }
            return result.toString(); // 返回最终的结果字符串
        }
    }

## 代码3： ##

class Solution {
        
        public String mergeAlternately(String word1, String word2) {
        
            String ans = ""; // 定义空字符串作为结果
            int len = Math.max(word1.length(), word2.length()); // 计算两个字符串的最大长度
            for (int i = 0; i < len; i++) {
         // 循环遍历长度
                if (i < word1.length()) ans += "" + word1.charAt(i); // 如果word1长度大于i，则把第i个字符加入结果字符串中
                if (i < word2.length()) ans += "" + word2.charAt(i); // 如果word2长度大于i，则把第i个字符加入结果字符串中
            }
            return ans; // 返回结果字符串
        }
    }