LeetCode344_344. 反转字符串

Posted 2023-04-05 落叶飘雪2014

LeetCode344_344. 反转字符串

一、描述

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

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

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

提示：

1 <= s.length <= 10的5次方
s[i] 都是 ASCII 码表中的可打印字符

二、题解

方法一：左右指针

    //中文版新的题目对输入参数、返回值做了一定的修改，具体如下
    //采用左右指针
    /*
    执行结果：通过
    执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
    内存消耗：47.7 MB, 在所有 Java 提交中击败了95.93%的用户
    通过测试用例：477 / 477
     */
    public void reverseString(char[] s) 
        int left = 0;
        int right = s.length - 1;
        while (left < right) 
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        
    

三、原英文版本题目及解法

1、题目描述

Write a function that takes a string as input and returns the string reversed.

Example:
Given s = "hello", return "olleh".

2、解法

    //方法一：直接将所有的字符反过来追加到StringBuffer中
    //这种方法速度较慢：Your runtime beats 4.87 % of java submissions.
    public String reverseString(String s) 
        StringBuffer br = new StringBuffer();
        for (int i = s.length() - 1; i >= 0; i--) 
            br.append(s.charAt(i));
        
        return br + "";
    

之所以给这里单独列出来，是因为中英文的函数的输入和返回值都发送了改变。

LeetCode 257. 二叉树的所有路径
LeetCode 258. 各位相加
LeetCode 263. 丑数
LeetCode 268. 丢失的数字
LeetCode 283. 移动零
LeetCode 287. 寻找重复数
LeetCode 290. 单词规律
LeetCode 292. Nim 游戏
LeetCode 303. 区域和检索 - 数组不可变
LeetCode 326. 3 的幂
LeetCode 342. 4的幂
LeetCode 344. 反转字符串

声明：
        题目版权为原作者所有。文章中代码及相关语句为自己根据相应理解编写，文章中出现的相关图片为自己实践中的截图和相关技术对应的图片，若有相关异议，请联系删除。感谢。转载请注明出处，感谢。

By luoyepiaoxue2014

B站： https://space.bilibili.com/1523287361 点击打开链接
微博： http://weibo.com/luoyepiaoxue2014 点击打开链接

leetcode_数据结构_链表_206反转链表（重点：递归）

题目链接：

https://leetcode-cn.com/problems/reverse-linked-list/

两种方法：

1.迭代

使用头插法反转链表，代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head==NULL)return NULL;
        ListNode *newHead=head,*p1=head,*p2=NULL;
        while(newHead->next)newHead=newHead->next;
        ListNode *tail=newHead;
        while(p1!=newHead){
            // p2=p1->next;//尾插，输出错误
            // p1->next=NULL;
            // tail->next=p1;
            // tail=p1;
            // p1=p2;
            
            p2=p1->next;//头插法
            p1->next=newHead->next;
            newHead->next=p1;
            p1=p2;

        }
        return p1;
    }
};

2.递归，代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL||head->next==NULL)return head;
        ListNode *p=reverseList(head->next);
        head->next->next=head;
        head->next=NULL;//如果不加此句，头节点处会产生闭环
        return p;//返回的一直是原链表的最后的一个结点，即反转后链表的头节点
    }
};

注意，递归每次返回的一直是原链表的最后一个结点，即反转后链表的头节点；

刚开始用递归做时一直有一个误区是本级递归一定会用到之前已经递归好返回的东西，本级递归一定会返回“本级的东西+本级之前递归好的东西”，于是一直感觉会返回一个类似reverseList（head）之类的东西，看着哪个reverselist（head->next）很奇怪。

但是画一个三个结点链表反转的示意图就知道：

 

可以参考力扣讲解：