算法刷题-字符串-替换空格

news2024/9/24 17:16:14

题目：剑指Offer 05.替换空格

力扣题目链接

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

示例 1：
输入：s = “We are happy.”
输出：“We%20are%20happy.”

思路

如果想把这道题目做到极致，就不要只用额外的辅助空间了！

首先扩充数组到每个空格替换成"%20"之后的大小。

然后从后向前替换空格，也就是双指针法，过程如下：

i指向新长度的末尾，j指向旧长度的末尾。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UOQ3D3Dc-1687011835976)(https://code-thinking.cdn.bcebos.com/gifs/%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.gif)]

有同学问了，为什么要从后向前填充，从前向后填充不行么？

从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

  1. 不用申请新数组。
  2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

时间复杂度，空间复杂度均超过100%的用户。

C++代码如下：

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0; // 统计空格的个数
        int sOldSize = s.size();
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == ' ') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是每个空格替换成"%20"之后的大小
        s.resize(s.size() + count * 2);
        int sNewSize = s.size();
        // 从后先前将空格替换为"%20"
        for (int i = sNewSize - 1, j = sOldSize - 1; j < i; i--, j--) {
            if (s[j] != ' ') {
                s[i] = s[j];
            } else {
                s[i] = '0';
                s[i - 1] = '2';
                s[i - 2] = '%';
                i -= 2;
            }
        }
        return s;
    }
};
  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

此时算上本题，我们已经做了七道双指针相关的题目了分别是：

  • 27.移除元素
  • 15.三数之和
  • 18.四数之和
  • 206.翻转链表
  • 142.环形链表II
  • 344.反转字符串

拓展

这里也给大家拓展一下字符串和数组有什么差别，

字符串是若干字符组成的有限序列，也可以理解为是一个字符数组，但是很多语言对字符串做了特殊的规定，接下来我来说一说C/C++中的字符串。

在C语言中，把一个字符串存入一个数组时，也把结束符 '\0’存入数组，并以此作为该字符串是否结束的标志。

例如这段代码：

char a[5] = "asd";
for (int i = 0; a[i] != '\0'; i++) {
}

在C++中，提供一个string类，string类会提供 size接口，可以用来判断string类字符串是否结束，就不用’\0’来判断是否结束。

例如这段代码:

string a = "asd";
for (int i = 0; i < a.size(); i++) {
}

那么vector< char > 和 string 又有什么区别呢？

其实在基本操作上没有区别，但是 string提供更多的字符串处理的相关接口，例如string 重载了+，而vector却没有。

所以想处理字符串，我们还是会定义一个string类型。

其他语言版本

C：

char* replaceSpace(char* s){
    //统计空格数量
    int count = 0;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        if (s[i] == ' ') {
            count++;
        }
    }

    //为新数组分配空间
    int newLen = len + count * 2;
    char* result = malloc(sizeof(char) * newLen + 1);
    //填充新数组并替换空格
    for (int i = len - 1, j = newLen - 1; i >= 0; i--, j--) {
        if (s[i] != ' ') {
            result[j] = s[i];
        } else {
            result[j--] = '0';
            result[j--] = '2';
            result[j] = '%';
        }
    }
    result[newLen] = '\0';

    return result;
}

Java：

//使用一个新的对象，复制 str，复制的过程对其判断，是空格则替换，否则直接复制，类似于数组复制
public static String replaceSpace(String s) {
        if (s == null) {
            return null;
        }
        //选用 StringBuilder 单线程使用，比较快，选不选都行
        StringBuilder sb = new StringBuilder();
        //使用 sb 逐个复制 s ，碰到空格则替换，否则直接复制
        for (int i = 0; i < s.length(); i++) {
            //s.charAt(i) 为 char 类型，为了比较需要将其转为和 " " 相同的字符串类型
            //if (" ".equals(String.valueOf(s.charAt(i)))){}
            if (s.charAt(i) == ' ') {
                sb.append("%20");
            } else {
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }

//方式二：双指针法
public String replaceSpace(String s) {
    if(s == null || s.length() == 0){
        return s;
    }
    //扩充空间，空格数量2倍
    StringBuilder str = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
        if(s.charAt(i) == ' '){
            str.append("  ");
        }
    }
    //若是没有空格直接返回
    if(str.length() == 0){
        return s;
    }
    //有空格情况 定义两个指针
    int left = s.length() - 1;//左指针：指向原始字符串最后一个位置
    s += str.toString();
    int right = s.length()-1;//右指针：指向扩展字符串的最后一个位置
    char[] chars = s.toCharArray();
    while(left>=0){
        if(chars[left] == ' '){
            chars[right--] = '0';
            chars[right--] = '2';
            chars[right] = '%';
        }else{
            chars[right] = chars[left];
        }
        left--;
        right--;
    }
    return new String(chars);
}

Go：

// 遍历添加
func replaceSpace(s string) string {
    b := []byte(s)
    result := make([]byte, 0)
    for i := 0; i < len(b); i++ {
        if b[i] == ' ' {
            result = append(result, []byte("%20")...)
        } else {
            result = append(result, b[i])
        }
    }
    return string(result)
}

// 原地修改
func replaceSpace(s string) string {
    b := []byte(s)
    length := len(b)
    spaceCount := 0
    // 计算空格数量
    for _, v := range b {
        if v == ' ' {
            spaceCount++
        }
    }
    // 扩展原有切片
    resizeCount := spaceCount * 2
    tmp := make([]byte, resizeCount)
    b = append(b, tmp...)
    i := length - 1
    j := len(b) - 1
    for i >= 0 {
        if b[i] != ' ' {
            b[j] = b[i]
            i--
            j--
        } else {
            b[j] = '0'
            b[j-1] = '2'
            b[j-2] = '%'
            i--
            j = j - 3
        }
    }
    return string(b)
}

python：

class Solution:
    def replaceSpace(self, s: str) -> str:
        counter = s.count(' ')
        
        res = list(s)
        # 每碰到一个空格就多拓展两个格子，1 + 2 = 3个位置存’%20‘
        res.extend([' '] * counter * 2)
        
        # 原始字符串的末尾，拓展后的末尾
        left, right = len(s) - 1, len(res) - 1
        
        while left >= 0:
            if res[left] != ' ':
                res[right] = res[left]
                right -= 1
            else:
                # [right - 2, right), 左闭右开
                res[right - 2: right + 1] = '%20'
                right -= 3
            left -= 1
        return ''.join(res)
            

class Solution:
    def replaceSpace(self, s: str) -> str:
        # method 1 - Very rude
        return "%20".join(s.split(" "))

        # method 2 - Reverse the s when counting in for loop, then update from the end.
        n = len(s)
        for e, i in enumerate(s[::-1]):
            print(i, e)
            if i == " ":
                s = s[: n - (e + 1)] + "%20" + s[n - e:]
            print("")
        return s

javaScript:

/**
 * @param {string} s
 * @return {string}
 */
 var replaceSpace = function(s) {
   // 字符串转为数组
  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('');
};

TypeScript：

function replaceSpace(s: string): string {
    let arr: string[] = s.split('');
    let spaceNum: number = 0;
    let oldLength: number = arr.length;
    for (let i = 0; i < oldLength; i++) {
        if (arr[i] === ' ') {
            spaceNum++;
        }
    }
    arr.length = oldLength + 2 * spaceNum;
    let cur: number = oldLength - 1;
    for (let i = arr.length - 1; i >= 0; i--, cur--) {
        if (arr[cur] !== ' ') {
            arr[i] = arr[cur]
        } else {
            arr[i] = '0';
            arr[--i] = '2';
            arr[--i] = '%';
        }
    }
    return arr.join('');
};

Swift:

func replaceSpace(_ s: String) -> String {
    var strArr = Array(s)
    var count = 0

    // 统计空格的个数
    for i in strArr {
        if i == " " {
            count += 1
        }
    }
    // left 指向旧数组的最后一个元素
    var left = strArr.count - 1
    // right 指向扩容后数组的最后一个元素（这里还没对数组进行实际上的扩容）
    var right = strArr.count + count * 2 - 1

    // 实际对数组扩容
    for _ in 0..<(count * 2) {
        strArr.append(" ")
    }

    while left < right {
        if strArr[left] == " " {
            strArr[right] = "0"
            strArr[right - 1] = "2"
            strArr[right - 2] = "%"
            left -= 1
            right -= 3
        } else {
            strArr[right] = strArr[left]
            left -= 1
            right -= 1
        }
    }

    return String(strArr)
}

Scala:

方式一: 双指针

object Solution {
  def replaceSpace(s: String): String = {
    var count = 0
    s.foreach(c => if (c == ' ') count += 1) // 统计空格的数量
    val sOldSize = s.length // 旧数组字符串长度
    val sNewSize = s.length + count * 2 // 新数组字符串长度
    val res = new Array[Char](sNewSize) // 新数组
    var index = sNewSize - 1 // 新数组索引
    // 逆序遍历
    for (i <- (0 until sOldSize).reverse) {
      if (s(i) == ' ') {
        res(index) = '0'
        index -= 1
        res(index) = '2'
        index -= 1
        res(index) = '%'
      } else {
        res(index) = s(i)
      }
      index -= 1
    }
    res.mkString
  }
}

方式二: 使用一个集合，遇到空格就添加%20

object Solution {
  import scala.collection.mutable.ListBuffer
  def replaceSpace(s: String): String = {
    val res: ListBuffer[Char] = ListBuffer[Char]()
    for (i <- s.indices) {
      if (s(i) == ' ') {
        res += '%'
        res += '2'
        res += '0'
      }else{
        res += s(i)
      }
    }
    res.mkString
  }
}

方式三: 使用map

object Solution {
  def replaceSpace(s: String): String = {
    s.map(c => if(c == ' ') "%20" else c).mkString
  }
  }

PHP：

function replaceSpace($s){
    $sLen = strlen($s);
    $moreLen = $this->spaceLen($s) * 2;

    $head = $sLen - 1;
    $tail = $sLen + $moreLen - 1;

    $s = $s . str_repeat(' ', $moreLen);
    while ($head != $tail) {
        if ($s[$head] == ' ') {
            $s[$tail--] = '0';
            $s[$tail--] = '2';
            $s[$tail] = '%';
        } else {
            $s[$tail] = $s[$head];
        }
        $head--;
        $tail--;
    }
    return $s;
}
// 统计空格个数
function spaceLen($s){
    $count = 0;
    for ($i = 0; $i < strlen($s); $i++) {
        if ($s[$i] == ' ') {
            $count++;
        }
    }
    return $count;
}

Rust

impl Solution {
    pub fn replace_space(s: String) -> String {
        let mut len: usize = s.len();
        let mut s = s.chars().collect::<Vec<char>>();
        let mut count = 0;
        for i in &s {
            if i.is_ascii_whitespace() {
                count += 1;
            }
        }
        let mut new_len = len + count * 2;
        s.resize(new_len, ' ');
        while len < new_len {
            len -= 1;
            new_len -= 1;
            if s[len].is_ascii_whitespace() {
                s[new_len] = '0';
                s[new_len - 1] = '2';
                s[new_len - 2] = '%';
                new_len -= 2;
            }
            else { s[new_len] = s[len] }
        }
        s.iter().collect::<String>()
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/658161.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python 3 | 菜鸟教程 （一）

Python 3 | 菜鸟教程 （一）

目录 一、Python3 简介 二、Python 发展历史 三、Python 特点 &#xff08;一&#xff09;易于学习 &#xff08;二&#xff09;易于阅读 &#xff08;三&#xff09;易于维护 &#xff08;四&#xff09;一个广泛的标准库 &#xff08;五&#xff09;互动模式 &#…
阅读更多...
【C】static关键字详解

【C】static关键字详解

概述 static的汉语意思是静态的&#xff0c;在C语言中static关键字可以用来修饰局部变量、全局变量和函数。 在这里给大家补充一个知识&#xff0c;我们的数据在内存中存储时&#xff0c;大概分为3个区域。 1.栈区&#xff1a;我们创建的局部变量、形参等一般就存放在这个区域…
阅读更多...
Python3 数字(Number)与字符串 | 菜鸟教程（五）

Python3 数字(Number)与字符串 | 菜鸟教程（五）

目录 一、Python3 数字(Number) &#xff08;一&#xff09;Python 数字数据类型用于存储数值。 1、以下实例在变量赋值时 Number 对象将被创建&#xff1a; 2、您也可以使用del语句删除一些数字对象的引用。 3、您可以通过使用del语句删除单个或多个对象的引用 &#xff08;…
阅读更多...
Golang每日一练(leetDay0100) 数据流中位数、二叉树序列化

Golang每日一练(leetDay0100) 数据流中位数、二叉树序列化

目录 295. 数据流的中位数 Find-median-from-data-stream &#x1f31f;&#x1f31f;&#x1f31f; 297. 二叉树的序列化与反序列化 Serialize-and-deserialize-binary-tree &#x1f31f;&#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Rus…
阅读更多...
从零开始Vue项目中使用MapboxGL开发三维地图教程（六）加载点、线、面图层以及三维面图层（白模）

从零开始Vue项目中使用MapboxGL开发三维地图教程（六）加载点、线、面图层以及三维面图层（白模）

目录 1、加载点图层2、加载线和面图层3、加载三维面图层&#xff08;白模&#xff09; 1、加载点图层 开发地图应用时&#xff0c;加载POI等点状数据&#xff0c;显示文字或者图标信息&#xff0c;mapbox-gl对应使用的是符号图层&#xff08;symbol&#xff09;&#xff0c;下面…
阅读更多...
Canvas.drawText 是以哪里为基线往什么方向开始画的。有什么居中方案？

Canvas.drawText 是以哪里为基线往什么方向开始画的。有什么居中方案？

0 前言 Canvas.drawText(String text, float x, float y, Paint paint) 这个方法在绘制文本时是从以什么为基线向什么地方开始绘制呢&#xff0c;水平方向上&#xff0c;可以通过设置 setTextAlign(Paint.Align.??) 来设置基线在文本左边、右边或者中间。但是垂直方向上是在哪…
阅读更多...
三、DI 依赖注入学习总结

三、DI 依赖注入学习总结

文章目录 一、依赖注入1.1 构造函数注入1.2 Setter 方法注入&#xff08;重点掌握&#xff09;1.2.1 通过 Set 注入复杂类型和集合类型数据 一、依赖注入 依赖注入&#xff08;Dependency Injection&#xff0c;DI&#xff09;是 Spring 框架的核心特性之一&#xff0c;也是 S…
阅读更多...
chatgpt赋能python：Python中如何输出换行符\n

chatgpt赋能python：Python中如何输出换行符\n

Python中如何输出换行符\n 如果你是一个Python开发者&#xff0c;你可能已经熟悉了多个输出Python变量的方法。但是&#xff0c;当你需要输出换行符’\n’时&#xff0c;你可能会遇到一些问题。这篇文章将介绍在Python中输出换行符的几种方法&#xff0c;并且告诉你哪种方法是…
阅读更多...
13.IOC容器

13.IOC容器

IOC容器 IOC&#xff1a;Inversion of Control&#xff0c;翻译过来是反转控制 IOC思想 获取资源的传统方式&#xff1a;在应用程序中的组件需要获取资源时&#xff0c;传统的方式是组件主动的从容器中获取所需要的资源&#xff0c;在这样的模式下开发人员往往需要知道在具体…
阅读更多...
第12课【嵌入式常见存储器类型】ROM RAM 一次性 DDR双倍速率 Flash

第12课【嵌入式常见存储器类型】ROM RAM 一次性 DDR双倍速率 Flash

目录 存储器易失性存储器RAMDRAMSDRAMDDR SDRAM SRAMDRAM/SRAM总结 非易失性存储器ROMMASK ROMOTPROMEPROMEEPROM FLASH 存储器 存储器是组成计算机的重要部分&#xff0c;它可以存储数据&#xff0c;能让计算机拥有“记忆”。目前根据断电后&#xff0c;存储的数据是否会丢失…
阅读更多...
TiDB v7.1.0 版本 Resource Control体验

TiDB v7.1.0 版本 Resource Control体验

作者&#xff1a; Ming 原文来源&#xff1a; https://tidb.net/blog/8abfaa25 简介 近期迎来了 TiDB v7.1.0 版本&#xff0c;也是2023年首发的LTS&#xff08;Long-Term Support Release&#xff09;版本&#xff0c;相比于之前的 v6.5.0 LTS版本已经过去了很长时间&…
阅读更多...
Android PagerSnapHelper改造RecyclerView为ViewPage，kotlin

Android PagerSnapHelper改造RecyclerView为ViewPage，kotlin

Android PagerSnapHelper改造RecyclerView为ViewPage&#xff0c;kotlin <?xml version"1.0" encoding"utf-8"?> <androidx.recyclerview.widget.RecyclerView xmlns:android"http://schemas.android.com/apk/res/android"xmlns:tool…
阅读更多...
Spring Web vs Spring Webflux

Spring Web vs Spring Webflux

当你需要构建Web应用程序时&#xff0c;Spring Web 和 Spring Webflux 是Spring生态系统中的两个框架&#xff0c;但它们之间有一些关键区别。 Spring Web 是一个传统的Web框架&#xff0c;它构建在Servlet API之上。它旨在处理阻塞式I/O&#xff0c;即线程在从数据库或其他服务…
阅读更多...
CTFHub | 过滤cat

CTFHub | 过滤cat

0x00 前言 CTFHub 专注网络安全、信息安全、白帽子技术的在线学习&#xff0c;实训平台。提供优质的赛事及学习服务&#xff0c;拥有完善的题目环境及配套 writeup &#xff0c;降低 CTF 学习入门门槛&#xff0c;快速帮助选手成长&#xff0c;跟随主流比赛潮流。 0x01 题目描述…
阅读更多...
Springboot读取配置文件的方式以及多环境读取的方式

Springboot读取配置文件的方式以及多环境读取的方式

Springboot读取配置文件的方式以及多环境读取的方式 一.首先介绍一下读取配置文件中的值的方式1.Value注解2.ConfigurationProperties注解赋值3.使用 Environment 读取配置文件 多环境读取 在项目中我们可能需要灵活的配置一些参数&#xff0c;就会将这些参数写到yaml文件或者p…
阅读更多...
C++技能系列 ( 4 ) - 深入理解C++临时对象【解析与提高性能手段】

C++技能系列 ( 4 ) - 深入理解C++临时对象【解析与提高性能手段】

系列文章目录 C技能系列 C高性能优化编程系列 深入理解软件架构设计系列 高级C并发线程编程 期待你的关注哦&#xff01;&#xff01;&#xff01; 现在的一切都是为将来的梦想编织翅膀&#xff0c;让梦想在现实中展翅高飞。 Now everything is for the future of dream w…
阅读更多...
Ubuntu设置虚拟机共享目录/mnt/hgfs下无文件显示相关问题归纳

Ubuntu设置虚拟机共享目录/mnt/hgfs下无文件显示相关问题归纳

文章目录 问题一&#xff1a;/mnt目录下无hgfs文件夹问题二&#xff1a;/mnt/hgfs 文件夹为空 问题一&#xff1a;/mnt目录下无hgfs文件夹 问题背景&#xff1a; 在打开共享目录A的时候&#xff0c;突然改变共享目录&#xff0c;也就是从A改到了B&#xff0c;但是资源管理器还…
阅读更多...
TiDB v7.1.0版本 相关（部署、在线扩容、数据迁移）测试

TiDB v7.1.0版本 相关（部署、在线扩容、数据迁移）测试

作者&#xff1a; tomxu 原文来源&#xff1a; https://tidb.net/blog/69083bca TiDB v7.1.0版本 相关&#xff08;部署、在线扩容、数据迁移&#xff09;测试 一、服务器信息参数 | 序号 | 服务器型号 | 主机名 | 配置 | | IP地址 | 用户名 | 密码 | | -- | --------- | …
阅读更多...
chatgpt赋能python：Python怎么过滤异常值-降噪数据的利器

chatgpt赋能python：Python怎么过滤异常值-降噪数据的利器

Python怎么过滤异常值 - 降噪数据的利器 什么是异常值 在数据分析和机器学习领域&#xff0c;我们常常需要对数据进行预处理&#xff0c;其中一个常见的问题就是异常值。也可以称为噪声数据或离群点&#xff0c;指数据集中与其他值相差较大的点。通常这些异常值出现的原因有很…
阅读更多...
6.10 面向对象抽象

6.10 面向对象抽象

抽象类 1 概念 Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法. Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类 如果一个类含有抽象方法,那么它一定是抽象类 抽象类中的方法实现交给子类来完成 2 抽象…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023