代码随想录Day08-字符串

今日任务

• 344.反转字符串
• 541. 反转字符串II
• 剑指Offer 05.替换空格
• 151.翻转字符串里的单词
• 剑指Offer58-II.左旋转字符串

344.反转字符串

 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

双指针（python）

class Solution(object):
    def reverseString(self, s):
        """
        :type s: List[str]
        :rtype: None Do not return anything, modify s in-place instead.
        """
        # 双指针
        left, right = 0, len(s) - 1
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
            

 JS

var reverseString = function(s) {
    let l = 0, r = s.length - 1;
    while(l < r) {
        [s[l], s[r]] = [s[r], s[l]];
        l++;
        r--;
    }
    
};

541.反转字符串II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

思路:每2*k个区间反转时一次

# 定义反转函数
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)

p = 0
        while p < len(s):
            p2 = p + k
            s = s[:p] + s[p: p2][::-1] + s[p2:]
            p = p + 2 *k
        return s

JS 

var reverseStr = function(s, k) {
    const len = s.length;
    let res = s.split("");
    for(let i = 0; i < len; i += 2*k) {
        let l = i - 1, r = i + k > len ? len : i + k;
        while(++l < --r) [res[l], res[r]] = [res[r], res[l]];
    }
    return res.join('')

剑指 Offer 05. 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

直接替换

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        s = s.split(' ')
        s = '%20'.join(s)
        return s

var replaceSpace = function(s) {
    return s.split(' ').join('%20');

};

 

双指针法 

# 双指针
        counter = s.count(' ')
        res = list(s)
        # .extend()函数用于在列表末尾一次性追加另一个序列的多个值()
        res.extend([' '] * counter * 2)
        l, r = len(s) - 1, len(res) - 1
        while l >= 0:
            if s[l] != ' ':
                res[r] = s[l]
                r -= 1
            else:
                res[r - 2:r + 1] = '%20'
                r -= 3
            l -= 1
        return ''.join(res)

 // 字符串转为数组
  const strArr = Array.from(s);
  let count = 0;

  // 计算空格数量
  for(let i = 0; i < strArr.length; i++) {
    if (strArr[i] === ' ') {
      count++;
    }
  }

  let left = strArr.length - 1;
  let right = strArr.length + count * 2 - 1;

  while(left >= 0) {
    if (strArr[left] === ' ') {
      strArr[right--] = '0';
      strArr[right--] = '2';
      strArr[right--] = '%';
      left--;
    } else {
      strArr[right--] = strArr[left--];
    }
  }

  // 数组转字符串
  return strArr.join('');
};

151. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格

双指针法： 一开始没注意到空格问题

 python

class Solution(object):
    def trim_spaces(self,s):
        n = len(s)
        l, r = 0, n-1
        while l <= r and s[l] == ' ':
            l += 1
        while l <= r and s[r] == ' ':
            r -= 1
        tmp = []
        while l <= r:
            if s[l] != ' ':
                tmp.append(s[l])
            elif tmp[-1] != ' ': # 当前位置是空格，但是上一个位置不是空格是合理的
                tmp.append(s[l])
            l += 1
        return tmp
    

    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        s = ''.join(self.trim_spaces(s))
        s = s.split(' ')
        l, r = 0, len(s) - 1
        while l <= r:
            s[l], s[r] = s[r], s[l]
            l += 1
            r -= 1
        return ' '.join(s)

JS

遇到的问题，JS 数组获取最后一个元素，s.slice(-1)

/**
 * @param {string} s
 * @return {string}
 */

 // 清除空格
 var trim_space = function(s) {
    let l = 0, r = s.length - 1;
    while(l <= r && s[l] === ' ') {
        l += 1;
    }
    while(l <= r && s[r] === ' ') {
        r -= 1;
    }
    tmp = new Array();
    while(l <=r ) {
        if(s[l] != ' ') {
            tmp.push(s[l]);
        }
        else if(tmp.slice(-1) != ' ') {
            tmp.push(s[l]);
        }
        
        l += 1;
    }
    return tmp;
 }
var reverseWords = function(s) {
    s = trim_space(s).join('');
    // return s;
    s = s.split(' ');
    // return s.length;
    let l = 0, r = s.length - 1;
    while(l <= r) {
        [s[l], s[r]] = [s[r], s[l]];
        l += 1;
        r -= 1;
    }
    return s.join(" ");
};

剑指Offer58-II.左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：
输入: s = "abcdefg", k = 2
输出: "cdefgab"

示例 2：
输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

限制：

1 <= k < s.length <= 10000

python

切片

class Solution(object):
    
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        """
        return s[n:] + s[0:n]   

 

思路：局部反转+整体反转

 

# 局部+全部反转
        s = list(s)
        s[0:n] = list(reversed(s[0:n]))
        s[n:] = list(reversed(s[n:]))
        s.reverse()
        return "".join(s)

# 自定义函数
        def reverse_sub(lst, left, right):
            while left <= right:
                lst[left], lst[right] = lst[right], lst[left]
                left += 1
                right -= 1
        res = list(s)
        end = len(res) - 1
        reverse_sub(res, 0, n-1)
        reverse_sub(res, n, end)
        reverse_sub(res, 0,end)
        return ''.join(res)

JS

/**
 * @param {string} s
 * @param {number} n
 * @return {string}
 */
var reverseLeftWords = function (s, n) {
    /** Utils */
    function reverseWords(strArr, start, end) {
        let temp;
        while (start < end) {
            temp = strArr[start];
            strArr[start] = strArr[end];
            strArr[end] = temp;
            start++;
            end--;
        }
    }
    /** Main code */
    let strArr = s.split('');
    let length = strArr.length;
    reverseWords(strArr, 0, length - 1);
    reverseWords(strArr, 0, length - n - 1);
    reverseWords(strArr, length - n, length - 1);
    return strArr.join('');
};