算法题 仅仅反转字母

最新推荐文章于 2025-10-18 16:45:32 发布
最新推荐文章于 2025-10-18 16:45:32 发布
阅读量841 收藏 18
点赞数 7
CC 4.0 BY-SA版权
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1256afafaafr/article/details/152085685

仅仅反转字母

问题描述

给你一个字符串 s，根据以下规则反转字符串：

  • 所有非字母字符保持原来的位置
  • 所有字母字符反转它们的位置

返回反转后的字符串。

示例：

输入: s = "ab-cd"
输出: "dc-ba"

输入: s = "a-bC-dEf-ghIj"
输出: "j-Ih-gfE-dCba"

输入: s = "Test1ng-Leet=code-Q!"
输出: "Qedo1ct-eeLg=ntse-T!"

算法思路

核心思路：

  • 双指针法：使用左右两个指针，分别从字符串两端向中间移动
  • 跳过非字母字符：当指针遇到非字母字符时，继续移动直到找到字母字符
  • 交换字母字符：当左右指针都指向字母字符时，交换它们的位置

关键点：

  • 需要正确判断字符是否为字母（包括大小写字母）
  • 双指针相遇时停止，避免重复交换
  • 保持非字母字符的原始位置不变

代码实现

方法一：双指针 + 字符数组

class Solution {
    /**
     * 仅仅反转字符串中的字母字符，非字母字符保持原位置
     * 使用双指针法，时间复杂度O(n)，空间复杂度O(n)
     * 
     * @param s 输入字符串
     * @return 反转字母后的字符串
     */
    public String reverseOnlyLetters(String s) {
        // 边界情况处理
        if (s == null || s.length() <= 1) {
            return s;
        }
        
        // 转换为字符数组便于修改
        char[] chars = s.toCharArray();
        int left = 0;                    // 左指针
        int right = s.length() - 1;      // 右指针
        
        // 双指针向中间移动
        while (left < right) {
            // 左指针跳过非字母字符
            while (left < right && !Character.isLetter(chars[left])) {
                left++;
            }
            
            // 右指针跳过非字母字符
            while (left < right && !Character.isLetter(chars[right])) {
                right--;
            }
            
            // 交换左右指针指向的字母字符
            if (left < right) {
                char temp = chars[left];
                chars[left] = chars[right];
                chars[right] = temp;
                left++;
                right--;
            }
        }
        
        return new String(chars);
    }
}

方法二：手动判断字母

class Solution {
    /**
     * 手动实现字母判断，不依赖Character.isLetter()
     * 
     * @param s 输入字符串
     * @return 反转字母后的字符串
     */
    public String reverseOnlyLetters(String s) {
        if (s == null || s.length() <= 1) {
            return s;
        }
        
        char[] chars = s.toCharArray();
        int left = 0;
        int right = s.length() - 1;
        
        while (left < right) {
            // 左指针找字母
            while (left < right && !isLetter(chars[left])) {
                left++;
            }
            
            // 右指针找字母
            while (left < right && !isLetter(chars[right])) {
                right--;
            }
            
            // 交换字母
            if (left < right) {
                char temp = chars[left];
                chars[left] = chars[right];
                chars[right] = temp;
                left++;
                right--;
            }
        }
        
        return new String(chars);
    }
    
    /**
     * 手动判断字符是否为字母
     * 
     * @param c 待判断字符
     * @return 是否为字母
     */
    private boolean isLetter(char c) {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }
}

方法三：使用栈

import java.util.*;

class Solution {
    /**
     * 使用栈存储所有字母，然后重新构建字符串
     * 空间复杂度较高，但思路直观
     * 
     * @param s 输入字符串
     * @return 反转字母后的字符串
     */
    public String reverseOnlyLetters(String s) {
        if (s == null || s.length() <= 1) {
            return s;
        }
        
        // 将所有字母压入栈中（自然反转顺序）
        Stack<Character> letterStack = new Stack<>();
        for (char c : s.toCharArray()) {
            if (Character.isLetter(c)) {
                letterStack.push(c);
            }
        }
        
        // 重新构建字符串
        StringBuilder result = new StringBuilder();
        for (char c : s.toCharArray()) {
            if (Character.isLetter(c)) {
                // 字母位置用栈顶元素（反转后的字母）
                result.append(letterStack.pop());
            } else {
                // 非字母字符保持原样
                result.append(c);
            }
        }
        
        return result.toString();
    }
}

算法分析

  • 时间复杂度：O(n)
    • 双指针法：每个字符最多被访问两次
    • 栈方法：需要两次遍历字符串
  • 空间复杂度：
    • 双指针法：O(n) - 字符数组存储
    • 栈方法：O(n) - 栈存储所有字母 + StringBuilder
  • 方法对比：
    • 双指针法：空间效率高，一次遍历完成，推荐使用
    • 栈方法：思路直观，但空间开销大
    • 手动判断：避免依赖内置方法

算法过程

输入：s = "a-bC-dEf-ghIj"

双指针过程：

初始状态：['a', '-', 'b', 'C', '-', 'd', 'E', 'f', '-', 'g', 'h', 'I', 'j']

  • left=0 (‘a’), right=12 (‘j’) → 交换 → ['j', '-', 'b', 'C', '-', 'd', 'E', 'f', '-', 'g', 'h', 'I', 'a']
  • left=1 (‘-’) 跳过 → left=2 (‘b’)
  • right=11 (‘I’) → 交换 → ['j', '-', 'I', 'C', '-', 'd', 'E', 'f', '-', 'g', 'h', 'b', 'a']
  • left=3 (‘C’), right=10 (‘h’) → 交换 → ['j', '-', 'I', 'h', '-', 'd', 'E', 'f', '-', 'g', 'C', 'b', 'a']
  • left=4 (‘-’) 跳过 → left=5 (‘d’)
  • right=9 (‘g’) → 交换 → ['j', '-', 'I', 'h', '-', 'g', 'E', 'f', '-', 'd', 'C', 'b', 'a']
  • left=6 (‘E’), right=8 (‘-’) 跳过 → right=7 (‘f’) → 交换 → ['j', '-', 'I', 'h', '-', 'g', 'f', 'E', '-', 'd', 'C', 'b', 'a']
  • left=7, right=6 → left >= right，结束

结果："j-Ih-gfE-dCba"

栈方法过程：

  1. 提取字母：['a', 'b', 'C', 'd', 'E', 'f', 'g', 'h', 'I', 'j']
  2. 压入栈后：栈顶到栈底为 ['j', 'I', 'h', 'g', 'f', 'E', 'd', 'C', 'b', 'a']
  3. 重建字符串：
    • ‘a’ → ‘j’
    • ‘-’ → ‘-’
    • ‘b’ → ‘I’
    • ‘C’ → ‘h’
    • …
  4. 结果："j-Ih-gfE-dCba"

测试用例

public static void main(String[] args) {
    Solution solution = new Solution();
    
    // 测试用例1：标准示例
    System.out.println("Test 1: " + solution.reverseOnlyLetters("ab-cd")); // "dc-ba"
    System.out.println("Test 2: " + solution.reverseOnlyLetters("a-bC-dEf-ghIj")); // "j-Ih-gfE-dCba"
    System.out.println("Test 3: " + solution.reverseOnlyLetters("Test1ng-Leet=code-Q!")); // "Qedo1ct-eeLg=ntse-T!"
    
    // 测试用例2：无字母
    System.out.println("Test 4: " + solution.reverseOnlyLetters("123!@#")); // "123!@#"
    
    // 测试用例3：全字母
    System.out.println("Test 5: " + solution.reverseOnlyLetters("abcdef")); // "fedcba"
    System.out.println("Test 6: " + solution.reverseOnlyLetters("ABCDEF")); // "FEDCBA"
    
    // 测试用例4：单字符
    System.out.println("Test 7: " + solution.reverseOnlyLetters("a")); // "a"
    System.out.println("Test 8: " + solution.reverseOnlyLetters("1")); // "1"
    System.out.println("Test 9: " + solution.reverseOnlyLetters("-")); // "-"
    
    // 测试用例5：空字符串
    System.out.println("Test 10: " + solution.reverseOnlyLetters("")); // ""
    
    // 测试用例6：只有非字母
    System.out.println("Test 11: " + solution.reverseOnlyLetters("!@#$%^&*()")); // "!@#$%^&*()"
    
    // 测试用例7：字母和数字混合
    System.out.println("Test 12: " + solution.reverseOnlyLetters("a1b2c3")); // "c1b2a3"
    
    // 测试用例8：大小写字母混合
    System.out.println("Test 13: " + solution.reverseOnlyLetters("AbCdEf")); // "fEdCbA"
    
    // 测试用例9：边界情况
    System.out.println("Test 14: " + solution.reverseOnlyLetters("a-")); // "a-"
    System.out.println("Test 15: " + solution.reverseOnlyLetters("-a")); // "-a"
    
    // 测试用例10：长字符串
    StringBuilder longStr = new StringBuilder();
    for (int i = 0; i < 100; i++) {
        if (i % 3 == 0) {
            longStr.append((char)('a' + i % 26));
        } else {
            longStr.append('-');
        }
    }
    System.out.println("Test 16: Length = " + solution.reverseOnlyLetters(longStr.toString()).length()); // 验证长度不变
    
    // 测试用例11：null值
    System.out.println("Test 17: " + solution.reverseOnlyLetters(null)); // null
}

关键点

  1. 双指针的核心思想：

    • 左右指针分别寻找字母字符
    • 跳过非字母字符，只交换字母字符
    • 保证非字母字符位置不变

  2. 字母判断方法：

    • Character.isLetter()：Java内置方法，支持Unicode
    • 手动判断：(c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')，仅支持ASCII

  3. 边界处理：

    • 空字符串和null值
    • 单字符字符串
    • 无字母或全字母的特殊情况

  4. 空间效率：

    • 双指针法只需要字符数组的空间
    • 栈方法需要额外的栈空间存储所有字母

常见问题

  1. 为什么不用String直接操作？

    • Java中String是不可变的，无法直接修改字符
    • 必须转换为字符数组或使用StringBuilder

  2. Character.isLetter()和手动判断有什么区别？

    • Character.isLetter() 支持所有Unicode字母
    • 手动判断只支持ASCII字母（A-Z, a-z）

  3. 双指针法的时间复杂度真的是O(n)吗？

    • 虽然有嵌套循环，但每个字符最多被访问两次
    • 左指针和右指针总共移动n次，所以是O(n)
有趣的算法题：反转不包含字母的字符串
Always-Learning
12-04 445
题目描述 博主最近看面经的时候，发现字节在面试的时候，问了候选人一道这样的算法题：请反转不包含字母的字符串。 解题思路 首先将字符串分割为单个的字符。 使用一个变量记录遍历到的字符是字母还是数字。 如果属于数字或者横线则将其倒序加入到临时数组中，如果不属于数字或者横线则将临时数组的内容加入到结果数组并拼接字符，然后将临时数组给清空。 最后返回数组。 function reverseStr(str) { const result = []; const arr = str.split('')
13.面试算法-字符串常见算法题（二）
weixin_36401695的博客
09-22 903
面试算法-字符串常见算法题
leetcode算法题--仅仅反转字母
bob的博客
02-26 171
原题链接：https://leetcode-cn.com/problems/reverse-only-letters/ class Solution { public: string reverseOnlyLetters(string s) { int n = s.size(); int i = 0, j = n - 1; while (i < j) { while(i < n && !isalpha
《算法题》leetcode917. 仅仅反转字母
Maysheeo的博客
07-28 284
算法思路分享
[LeetCode专题] 仅仅反转字母
qq_42956868的博客
12-29 268
仅仅反转字母
Leetcode算法——917、仅仅反转字母
R.I.P Kobe Bryant
02-23 274
Leetcode算法——917、仅仅反转字母
leetcode 算法题849 (简单240) 仅仅反转字母
FYuu95100的博客
10-24 288
leetcode 算法题849 (简单240) 仅仅反转字母 题目介绍 给定一个字符串 S， 返回 “反转后的” 字符串， 其中不是字母的字符都保留在原地， 而所有字母的位置发生反转。 示例 输入：“ab-cd” 输出：“dc-ba” 输入：“a-bC-dEf-ghIj” 输出：“j-Ih-gfE-dCba” 输入：“Test1ng-Leet=code-Q!” 输出：“Qedo...
Leetcode刷题java之917. 仅仅反转字母
逆水行舟，不进则退
08-02 383
执行结果： 通过 显示详情 执行用时 :1 ms, 在所有 Java 提交中击败了98.91% 的用户 内存消耗 :35 MB, 在所有 Java 提交中击败了89.84%的用户 题目： 给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。 示例 1： 输入："ab-cd" 输出："dc-ba" 示例 2： ...
【力扣每日一题】917. 仅仅反转字母
mandarava的博客
02-23 388
题目 给你一个字符串 s ，根据下述规则反转字符串： 所有非英文字母保留在原有位置。 所有英文字母（小写或大写）位置反转。 返回反转后的 s 。 地址：https://leetcode-cn.com/problems/reverse-only-letters/ 题解 解题思路 字符串，对撞指针，具体定义可看https://blog.csdn.net/AtalantaDavis/article/details/122692769 代码 var reverseOnlyLetters = function(s
leetcode917. 仅仅反转字母
AI_ELF的博客
12-25 592
给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。 示例： 输入：“ab-cd” 输出：“dc-ba” 提示： S.length <= 100 33 <= S[i].ASCIIcode <= 122 S 中不包含 \ or " 思路： 首先定义两个变量begin和end，begin记录字符串的首位置，end记录字符串的尾 其次如果begin和end记录的位置都是字母时，这两个位置的字母进行交换 最后begin和end跳向
算法修炼之路—【字符串】Leetcode 345 反转字符串中的元音字母
12-20
在算法修炼之路上，我们经常会遇到各种有趣的编程挑战，其中之一便是LeetCode的第345题——反转字符串中的元音字母。本题目的目标是设计一个函数，接收一个字符串作为输入，然后仅反转其中的元音字母。元音字母包括...
JAVA练习156-仅仅反转字母
qq_48772498的博客
02-23 545
给你一个字符串 s ，根据下述规则反转字符串： 所有非英文字母保留在原有位置。 所有英文字母（小写或大写）位置反转。 返回反转后的 s 。 示例 1： 输入：s = "ab-cd" 输出："dc-ba" 示例 2： 输入：s = "a-bC-dEf-ghIj" 输出："j-Ih-gfE-dCba" 示例 3： 输入：s = "Test1ng-Leet=code-Q!" 输出："Qedo1ct-eeLg=ntse-T!" 提示 1 <= s.length <= 100 s 仅由 A
算法通关村——字符串反转问题解析
moqi997752的博客
11-17 772
本文介绍了字符串反转的几个经典算法题
互联网大厂高频面试题基本总结回顾（含笔试高频算法整理）
热门推荐
张彦峰的博客
04-03 176万+
1.自我介绍+项目介绍+项目细节/难点提问-------这个主要看个人的经历了，每个人都不一样 2.基础知识点考核---------还是可以去增强自己的，也是这次的主要的一些总结思路 3.算法题-----------一般都是LeetCode高频题，这个得在找工作之前的好好的练习(d对常见的高频题进行总结分析，见对应的链接提示)
强化学习【Monte Carlo Learning][MC Basic 算法]
4AM_明朝百晓生
10-17 933
状态转移概率往往是未知的，在这种情况下，我们通常会采用蒙特卡洛（Monte Carlo）方法进行求解（该方法本质上是通过大数定律来计算数学期望）。在使用基于模型（model-based）的强化学习方法，特别是进行策略迭代时，我们通常会通过上述公式来求解。在 Policy iteration 的时候计算了 state-action 的均值（大数定律里面的切比雪夫不等式）值迭代（value-iteration）和策略迭代（policy iteration）。蒙特卡洛 ε-贪婪算法（MC ε-greedy)
数据结构 06 线性结构
im_AMBER的博客
10-18 886
pta练习题，需要多回顾，多小结，记得常回来看看~
【MATLAB例程】基于USBL和DVL的线性回归误差补偿，对USBL和DVL导航数据进行相互补偿，提高定位精度，附代码下载链接
985工科博士毕业，专攻定位、导航和滤波等算法研究。从业10年，主要使用MATLAB
10-17 731
该程序通过线性回归和加权融合方法优化水下USBL和DVL传感器的定位数据。程序首先生成圆形加直线的真实轨迹，并模拟USBL（含随机噪声、系统偏差）和DVL（含随机噪声、累积漂移）的误差数据。随后进行双向补偿：利用DVL数据校正USBL的系统偏差，用USBL数据修正DVL的累积漂移。最后基于方差最优加权融合两种传感器数据，显著提高定位精度。结果显示融合后的轨迹误差明显减小，适用于复杂水下环境中的AUV/ROV导航。程序提供完整的误差统计分析和多维度可视化图表。
CC18 复制无向图
2401_88004140的博客
10-18 335
摘要： 本文实现了一个无向图的复制算法，采用BFS遍历结合哈希表存储节点映射关系。算法首先处理边界条件，然后初始化哈希表和队列，复制起始节点后开始BFS遍历。对于每个节点，复制其未被访问的邻居节点，并维护邻居关系。时间复杂度和空间复杂度均为O(N)，其中N为节点数量。代码包含节点定义、核心复制逻辑及测试方法，适用于处理带自环的无向图复制场景。
【基础算法】01BFS
最新发布
2401_87820834的博客
10-18 953
解决边权为 0 和 1 的最短路问题——01BFS
算法题大驼峰大小写反转
09-08
对于这个问题，你可以使用以下的算法来实现大驼峰大小写反转： 1. 首先，定义一个空字符串用于存储结果。 2. 遍历给定的字符串，对于每个字符执行以下操作： - 如果字符是小写字母，则将其转换为大写字母，并将其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值