代码随想录算法训练营第九天｜232.用栈实现队列、225.用队列实现栈

代码随想录算法训练营第九天｜232.用栈实现队列、225.用队列实现栈

232.用栈实现队列

题目链接

问题简述：将字符串数组反转并存在原数组中。

思考：左右两个指针遍历遍历一遍。

算法思路：将左右指针分别指向数组头和尾，不断将头尾字符交换，直到左右指针相等。

时间复杂度 ：O(n)

空间复杂度 ：O(1)

import java.util.Stack;

class MyQueue {

    Stack<Integer> stackin;
    Stack<Integer> stackout;

    public MyQueue() {
        stackin = new Stack<>();
        stackout = new Stack<>();
    }

    public void push(int x) {
        stackin.push(x);
    }

    public int pop() {
        if (stackout.empty()){
            while (!stackin.empty()){
                stackout.push(stackin.pop());
            }
        }
       return stackout.pop();
    }

    public int peek() {
        if (stackout.empty()){
            while (!stackin.empty()){
                stackout.push(stackin.pop());
            }
        }
        return stackout.peek();
    }

    public boolean empty() {
        if (stackout.empty() && stackin.empty()) return true;
        return false;
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

225.用队列实现栈

题目链接

问题简述：将每2k个字符串中的前k个反转，若剩余不足k个则直接将剩余反转，若剩余大于k小于2k个，则将这k个反转。

思考：java中的字符串String不能改写,只能读取，很多字符的方法都没有，本体选择将字符串存入StringBuilder进程处理。

• String（字符串）：是 Java 中最常用的字符串类型，它是不可变的，一旦创建就不能修改。字符串的字面值可以用双引号引起来，例如：“Hello, World!”。

• StringBuffer（字符串缓冲区）：是一个可变的字符串类型，适用于多线程环境下的字符串操作。它的操作是同步的，可以保证线程安全。StringBuilder 是其非线程安全的版本。

• StringBuilder（字符串生成器）：与 StringBuffer 类似，也是一个可变的字符串类型，但不保证线程安全。在单线程环境下，StringBuilder 的性能比 StringBuffer 更高。

算法思路：依次遍历每个2k，左右指针分别指向2k中的第一个和第k个，翻转前k个字符。如果right指针越界，则right直接指向字符串末尾。

时间复杂度： O(n)

空间复杂度： O(n)

import java.util.LinkedList;
import java.util.Queue;

class MyStack {
    Queue<Integer> queen;
    public MyStack() {
        queen = new LinkedList<>();
    }

    public void push(int x) {
        queen.offer(x);
    }

    public int pop() {
        for (int i = 0; i < queen.size() - 1; i++) {
            queen.offer(queen.poll());
        }
        return queen.poll();
    }

    public int top() {
        for (int i = 0; i < queen.size() - 1; i++) {
            queen.offer(queen.poll());
        }
        int a = queen.peek();
        queen.offer(queen.poll());
        return a;
    }

    public boolean empty() {
        return queen.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

卡码网：54.替换数字

题目链接

问题简述：给定含有小写字母和数字的字符串，将数字变为"number"。

思考：卡码网需要自己写输入输出，Main文件需要创建同名的Main类，然后接口main是程序运行的主函数。

算法思路：创建空的StringBuilder，遍历输入的s，如果为数字就在StringBuilder中加入字符串"number"，如果为字母就直接加入StringBuilder，直到遍历完所有字符。

时间复杂度 O(n)

空间复杂度 O(n)

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
      //输入一个字符串
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
      //创建空的StringBuilder
        StringBuilder newString = new StringBuilder();
      //遍历s，如果为数字就在StringBuilder加入“number”，如果为字母就直接加入StringBuilder
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isDigit(c)) {
                newString.append("number");
            } else {
                newString.append(c);
            }
        }
        System.out.println(newString);
    }
}

51.翻转字符串里的单词

题目链接

问题简述：将字符串里的单词翻转，翻转后单词间存在空格，字符串首位不存在空格。

思考：看似复杂，实则需要注意的点确实很多，要不断考虑不要溢出。总的来说就是找到每个单词的首位，再存入新的字符串。

算法思路：创建指针l和r，不断遍历直到指向单词的末尾，再让l指向单词第一个字母，将l到r的字母加入新字符串，再加入空格后，l和r指向单词的前一个空格，以便于下一次循环。不断循环，直到遍历完字符串。

时间复杂度 O(n)

空间复杂度 O(n)

class Solution {
    public String reverseWords(String s) {
        StringBuilder newString = new StringBuilder();
        //应对单个字母的字符串“a”
        if(s.length() == 1){
            return s;
        }
        int left = s.length() - 1;
        int right = s.length() - 1;
        while (right > 0){
            //如果l和r都指向空格，则同时向左移动，直到不为空格，且不要溢出
            while (right > 0 && s.charAt(right) == ' '){
                right--;
                left--;
            }
            //此时left和right都指向单词的最后一个字母，循环结束时，left指向单词第一个字母，注意不要溢出
            while (left > 0 && s.charAt(left - 1) != ' ') {
                if (left != 0){
                    left--;
                }
            }
            //将l到r的字母加入，因为append是加入左闭右开的数字，所以右面填入r+1
            newString.append(s.substring(left, right + 1));
            //单词之间添加空格
            newString.append(' ');
            //left指向左面的空格
            left--;
            right = left;
        }
        while (newString.charAt(newString.length() - 1) == ' '){
            newString.deleteCharAt(newString.length() - 1);
        }
        return new String(newString);
    }
}

卡码网：55.右旋转字符串

题目链接

问题简述：输入字符串s和数字n，将字符串后n位放到字符串最前面。

思考：之前复习数据结构的时候见过，觉得思想很巧妙。这里没有用StringBuilder自带的reverse()方法，因为reverse和系统方法一样，一般都是左闭右开，好像老是溢出，左右自己写了一个左闭右闭的方法。同时选择字符串数组来更方便的处理。

算法思路：将字符串全部翻转，再翻转前n位，再将剩下的字符翻转。

时间复杂度 O(n)

空间复杂度 O(n)

import java.util.Scanner;

public class main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();  // 消耗换行符
        String s = in.nextLine(); 
        int len = s.length();  //获取字符串长度
      //用数组进行存储
        char[] chars = s.toCharArray();
        reverseString(chars, 0, len - 1);
        reverseString(chars, 0, n - 1);
        reverseString(chars, n, len - 1);
        System.out.println(chars);
    }
    public static void reverseString(char[] s, int left, int right) {
        while (left < right){
            char a = s[left];
            s[left] = s[right];
            s[right] = a;
            left++;
            right--;
        }
        return;
    }
}

感想

字符串不是很熟练，很多自带的方法感觉不是很会，因为没系统的看java基础，比如toString啥的我还没太明白。