簡單的反轉(zhuǎn)還不夠，我要花式反轉(zhuǎn)

541. 反轉(zhuǎn)字符串II

力扣題目鏈接

給定一個(gè)字符串 s 和一個(gè)整數(shù) k，從字符串開頭算起, 每計(jì)數(shù)至 2k 個(gè)字符，就反轉(zhuǎn)這 2k 個(gè)字符中的前 k 個(gè)字符。

如果剩余字符少于 k 個(gè)，則將剩余字符全部反轉(zhuǎn)。

如果剩余字符小于 2k 但大于或等于 k 個(gè)，則反轉(zhuǎn)前 k 個(gè)字符，其余字符保持原樣。

示例:

輸入: s = “abcdefg”, k = 2
輸出: “bacdfeg”

思路

這道題目其實(shí)也是模擬，實(shí)現(xiàn)題目中規(guī)定的反轉(zhuǎn)規(guī)則就可以了。

一些同學(xué)可能為了處理邏輯：每隔2k個(gè)字符的前k的字符，寫了一堆邏輯代碼或者再搞一個(gè)計(jì)數(shù)器，來統(tǒng)計(jì)2k，再統(tǒng)計(jì)前k個(gè)字符。

其實(shí)在遍歷字符串的過程中，只要讓 i += (2 * k)，i 每次移動 2 * k 就可以了，然后判斷是否需要有反轉(zhuǎn)的區(qū)間。

因?yàn)橐业囊簿褪敲? * k 區(qū)間的起點(diǎn)，這樣寫，程序會高效很多。

所以當(dāng)需要固定規(guī)律一段一段去處理字符串的時(shí)候，要想想在在for循環(huán)的表達(dá)式上做做文章。

性能如下：

那么這里具體反轉(zhuǎn)的邏輯我們要不要使用庫函數(shù)呢，其實(shí)用不用都可以，使用reverse來實(shí)現(xiàn)反轉(zhuǎn)也沒毛病，畢竟不是解題關(guān)鍵部分。

C++代碼

使用C++庫函數(shù)reverse的版本如下：

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 個(gè)字符的前 k 個(gè)字符進(jìn)行反轉(zhuǎn)
            // 2. 剩余字符小于 2k 但大于或等于 k 個(gè)，則反轉(zhuǎn)前 k 個(gè)字符
            if (i + k <= s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );
            } else {
                // 3. 剩余字符少于 k 個(gè)，則將剩余字符全部反轉(zhuǎn)。
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

那么我們也可以實(shí)現(xiàn)自己的reverse函數(shù)，其實(shí)和題目344. 反轉(zhuǎn)字符串道理是一樣的。

下面我實(shí)現(xiàn)的reverse函數(shù)區(qū)間是左閉右閉區(qū)間，代碼如下：

class Solution {
public:
    void reverse(string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 個(gè)字符的前 k 個(gè)字符進(jìn)行反轉(zhuǎn)
            // 2. 剩余字符小于 2k 但大于或等于 k 個(gè)，則反轉(zhuǎn)前 k 個(gè)字符
            if (i + k <= s.size()) {
                reverse(s, i, i + k - 1);
                continue;
            }
            // 3. 剩余字符少于 k 個(gè)，則將剩余字符全部反轉(zhuǎn)。
            reverse(s, i, s.size() - 1);
        }
        return s;
    }
};

另一種思路的解法

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size(),pos = 0;
        while(pos < n){
            //剩余字符串大于等于k的情況
            if(pos + k < n) reverse(s.begin() + pos, s.begin() + pos + k);
            //剩余字符串不足k的情況 
            else reverse(s.begin() + pos,s.end());
            pos += 2 * k;
        }
        return s;
    }
};

其他語言版本

C：

char * reverseStr(char * s, int k){
    int len = strlen(s);

    for (int i = 0; i < len; i += (2 * k)) {
        //判斷剩余字符是否少于 k
        k = i + k > len ? len - i : k;

        int left = i;
        int right = i + k - 1;
        while (left < right) {
            char temp = s[left];
            s[left++] = s[right];
            s[right--] = temp;
        }
    }

    return s;
}

Java：

//解法一
class Solution {
    public String reverseStr(String s, int k) {
        StringBuffer res = new StringBuffer();
        int length = s.length();
        int start = 0;
        while (start < length) {
            // 找到k處和2k處
            StringBuffer temp = new StringBuffer();
            // 與length進(jìn)行判斷，如果大于length了，那就將其置為length
            int firstK = (start + k > length) ? length : start + k;
            int secondK = (start + (2 * k) > length) ? length : start + (2 * k);

            //無論start所處位置，至少會反轉(zhuǎn)一次
            temp.append(s.substring(start, firstK));
            res.append(temp.reverse());

            // 如果firstK到secondK之間有元素，這些元素直接放入res里即可。
            if (firstK < secondK) { //此時(shí)剩余長度一定大于k。
                res.append(s.substring(firstK, secondK));
            }
            start += (2 * k);
        }
        return res.toString();
    }
}

//解法二（似乎更容易理解點(diǎn)）
//題目的意思其實(shí)概括為 每隔2k個(gè)反轉(zhuǎn)前k個(gè)，尾數(shù)不夠k個(gè)時(shí)候全部反轉(zhuǎn)
class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0; i < ch.length; i += 2 * k){
            int start = i;
            //這里是判斷尾數(shù)夠不夠k個(gè)來取決end指針的位置
            int end = Math.min(ch.length - 1, start + k - 1);
            //用異或運(yùn)算反轉(zhuǎn) 
            while(start < end){
                ch[start] ^= ch[end];
                ch[end] ^= ch[start];
                ch[start] ^= ch[end];
                start++;
                end--;
            }
        }
        return new String(ch);
    }
}


// 解法二還可以用temp來交換數(shù)值，會的人更多些
class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0;i < ch.length;i += 2 * k){
            int start = i;
            // 判斷尾數(shù)夠不夠k個(gè)來取決end指針的位置
            int end = Math.min(ch.length - 1,start + k - 1);
            while(start < end){
                
                char temp = ch[start];
                ch[start] = ch[end];
                ch[end] = temp;

                start++;
                end--;
            }
        }
        return new String(ch);
    }
}

// 解法3
class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        // 1. 每隔 2k 個(gè)字符的前 k 個(gè)字符進(jìn)行反轉(zhuǎn)
        for (int i = 0; i< ch.length; i += 2 * k) {
            // 2. 剩余字符小于 2k 但大于或等于 k 個(gè)，則反轉(zhuǎn)前 k 個(gè)字符
            if (i + k <= ch.length) {
                reverse(ch, i, i + k -1);
                continue;
            }
            // 3. 剩余字符少于 k 個(gè)，則將剩余字符全部反轉(zhuǎn)
            reverse(ch, i, ch.length - 1);
        }
        return  new String(ch);

    }
    // 定義翻轉(zhuǎn)函數(shù)
    public void reverse(char[] ch, int i, int j) {
    for (; i < j; i++, j--) {
        char temp  = ch[i];
        ch[i] = ch[j];
        ch[j] = temp;
    }

    }
}

Python：

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        """
        1. 使用range(start, end, step)來確定需要調(diào)換的初始位置
        2. 對于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超過最大長度，則會返回至字符串最后一個(gè)值，這個(gè)特性可以避免一些邊界條件的處理。
        3. 用切片整體替換，而不是一個(gè)個(gè)替換.
        """
        def reverse_substring(text):
            left, right = 0, len(text) - 1
            while left < right:
                text[left], text[right] = text[right], text[left]
                left += 1
                right -= 1
            return text
        
        res = list(s)

        for cur in range(0, len(s), 2 * k):
            res[cur: cur + k] = reverse_substring(res[cur: cur + k])
        
        return ''.join(res)

Python3 (v2):

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        # Two pointers. Another is inside the loop.
        p = 0
        while p < len(s):
            p2 = p + k
            # Written in this could be more pythonic.
            s = s[:p] + s[p: p2][::-1] + s[p2:]
            p = p + 2 * k
        return s

Go：

func reverseStr(s string, k int) string {
    ss := []byte(s)
    length := len(s)
    for i := 0; i < length; i += 2 * k {
     // 1. 每隔 2k 個(gè)字符的前 k 個(gè)字符進(jìn)行反轉(zhuǎn)
     // 2. 剩余字符小于 2k 但大于或等于 k 個(gè)，則反轉(zhuǎn)前 k 個(gè)字符
        if i + k <= length {
            reverse(ss[i:i+k])
        } else {
            reverse(ss[i:length])
        }
    }
    return string(ss)
}

func reverse(b []byte) {
    left := 0
    right := len(b) - 1
    for left < right {
        b[left], b[right] = b[right], b[left]
        left++
        right--
    }
}

javaScript:

/**
 * @param {string} s
 * @param {number} k
 * @return {string}
 */
var reverseStr = function(s, k) {
    const len = s.length;
    let resArr = s.split(""); 
    for(let i = 0; i < len; i += 2 * k) {  // 每隔 2k 個(gè)字符的前 k 個(gè)字符進(jìn)行反轉(zhuǎn)
        let l = i - 1, r = i + k > len ? len : i + k;
        while(++l < --r) [resArr[l], resArr[r]] = [resArr[r], resArr[l]];
    }
    return resArr.join("");
};

TypeScript：

function reverseStr(s: string, k: number): string {
    let left: number, right: number;
    let arr: string[] = s.split('');
    let temp: string;
    for (let i = 0, length = arr.length; i < length; i += 2 * k) {
        left = i;
        right = (i + k - 1) >= length ? length - 1 : i + k - 1;
        while (left < right) {
            temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    return arr.join('');
};

Swift:

func reverseStr(_ s: String, _ k: Int) -> String {
    var ch = Array(s)

    for i in stride(from: 0, to: ch.count, by: 2 * k) {
        var left = i
        var right = min(s.count - 1, left + k - 1)
      
        while left < right {
            (ch[left], ch[right]) = (ch[right], ch[left])
            left += 1
            right -= 1
        }
    }
    return String(ch)
}

C#：

public class Solution
{
    public string ReverseStr(string s, int k)
    {
        Span<char> span = s.ToCharArray().AsSpan();
        for (int i = 0; i < span.Length; i += 2 * k)
        {
            span[i + k < span.Length ? i..(i + k) : i..].Reverse();
        }
        return span.ToString();
    }
}

Scala:

版本一: (正常解法)

object Solution {
  def reverseStr(s: String, k: Int): String = {
    val res = s.toCharArray // 轉(zhuǎn)換為Array好處理
    for (i <- s.indices by 2 * k) {
      // 如果i+k大于了res的長度，則需要全部翻轉(zhuǎn)
      if (i + k > res.length) {
        reverse(res, i, s.length - 1)
      } else {
        reverse(res, i, i + k - 1)
      }
    }
    new String(res)
  }
  // 翻轉(zhuǎn)字符串，從start到end
  def reverse(s: Array[Char], start: Int, end: Int): Unit = {
    var (left, right) = (start, end)
    while (left < right) {
      var tmp = s(left)
      s(left) = s(right)
      s(right) = tmp
      left += 1
      right -= 1
    }
  }
}

版本二: 首先利用grouped每隔k個(gè)進(jìn)行分割，再使用zipWithIndex添加每個(gè)數(shù)組的索引，緊接著利用map做變換，如果索引%2==0則說明需要翻轉(zhuǎn)，否則原封不動，最后再轉(zhuǎn)換為String

object Solution {
  def reverseStr(s: String, k: Int): String = {
    // s = "abcdefg", k = 2
    s.grouped(k) // Iterator ["ab", "cd", "ef", "g"]
      .zipWithIndex // Iterator [("ab", 0), ("cd", 1), ("ef", 2), ("g", 3)]
      .map {
        case (subStr, index) => 
          if (index % 2 == 0) subStr.reverse else subStr
      }
      .mkString
  }
}

版本三: (遞歸)

import scala.annotation.tailrec

object Solution {
  def reverseStr(s: String, k: Int): String = {
    @tailrec // 這個(gè)函數(shù)已經(jīng)優(yōu)化成了尾遞歸
    def reverse(s: String, needToReverse: Boolean, history: String): String = {
      // 截取前k個(gè)字符（判斷是否翻轉(zhuǎn)）
      val subStr = if (needToReverse) s.take(k).reverse else s.take(k)
      // 如果字符串長度小于k，返回結(jié)果
      // 否則，對于剩余字符串進(jìn)行同樣的操作
      if (s.length < k) history + subStr
      else reverse(s.drop(k), !needToReverse, history + subStr)
    }
    reverse(s, true, "")
  }
}

Rust:文章來源地址http://www.zghlxwxcb.cn/news/detail-491132.html

impl Solution {
    pub fn reverse(s: &mut Vec<char>, mut begin: usize, mut end: usize){
        while begin < end {
            let temp = s[begin];
            s[begin] = s[end];
            s[end] = temp;
            begin += 1;
            end -= 1;
        }
    }
    pub fn reverse_str(s: String, k: i32) -> String {
        let len = s.len();
        let k = k as usize;
        let mut s = s.chars().collect::<Vec<_>>();
        for i in (0..len).step_by(2 * k) {
            if i + k < len {
                Self::reverse(&mut s, i, i + k - 1);
            }
            else {
                Self::reverse(&mut s, i, len - 1);
            }
        }
        s.iter().collect::<String>()
    }
}

到了這里，關(guān)于算法刷題-字符串-反轉(zhuǎn)字符串II的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！