力扣344、541、54、151、28、232、 225-java刷题笔记

最新推荐文章于 2024-11-07 23:24:07 发布

富江！

最新推荐文章于 2024-11-07 23:24:07 发布

阅读量869

点赞数 13

文章标签： leetcode 笔记算法

本文链接：https://blog.csdn.net/qq_45014958/article/details/136353972

版权

一、344. 反转字符串

1.1题目

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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.2 思路分析

使用双指针，定义左指针与右指针，从字符串两边向中间遍历。

1.3 代码实现

class Solution {
    public void reverseString(char[] s) {
        // 使用双指针，左指针与右指针
        int left = 0;
        int right = s.length-1;
        char temp ;
        while(left <= right){
            temp = s[right];
            s[right] = s[left];
            s[left] =temp;
            left ++;
            right --; 
        }
    }
}

二、541. 反转字符串 II

2.1题目

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

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

示例 1：

输入：s = "abcdefg", k = 2
输出："bacdfeg"

示例 2：

输入：s = "abcd", k = 2
输出："bacd"

2.2思路分析

对字符串进行2k2k的去遍历，不要固定思维每次遍历1个元素，这样每次的i都是开始反转的起始元素，但此时仍需要判断结束元素的位置，正常情况下应该是i+k,而当i+k大于数组长度时，此时数组就越界了，因此此时应该取结束时候的位置为数组的长度。刚好满足题设条件：如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

2.3代码实现

class Solution {
    public String reverseStr(String s, int k) {
        // 计算字符串的长度
        int length = s.length();
        int left = 0;
        int right;
        char temp;

        char[] s1 = s.toCharArray();
        // 计算需要反转几次
        int num ;
        // 对字符串的长度做判断
        //  定义循环对字符串进行遍历 2k2k的去遍历
 
        for(int i = 0 ; i < length ; i += 2*k){
            // 定义每次需要反转时的初始位置
            int start = i;
            // 定义每次需要反转时的结束位置 应该是i+k 但是要判断i+k是否会数组越界
            int end = Math.min(i+k,length)-1;
            swap(s1,start,end);    
        }
        return new String(s1);

    }
     public void swap(char [] arr, int left , int right ){
            while(left <= right){
                char temp;
                temp = arr[right];
                arr[right] = arr[left];
                arr[left] = temp;
                left++;
                right--;
            }
        }
    
}

三、54. 替换数字（第八期模拟笔试）

3.1题目

题目描述

给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。例如，对于输入字符串 "a1b2c3"，函数应该将其转换为 "anumberbnumbercnumber"。

输入描述

输入一个字符串 s,s 仅包含小写字母和数字字符。

输出描述

打印一个新的字符串，其中每个数字字符都被替换为了number

输入示例

a1b2c3

输出示例

anumberbnumbercnumber

3.2思路分析

定义一个新变量（记得不要定义数组）放置返回的结果。

3.3代码实现

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (Character.isDigit(s.charAt(i))) {
                sb.append("number");
            }else sb.append(s.charAt(i));
        }
        System.out.println(sb);
    }

四、151反转字符串中的单词

4.1题目

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

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

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

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

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

4.2思路分析

首先去除待翻转字符串的首尾部空字符，然后对整个字符串进行反转，最后再对字符串中的所有单词进行反转。

注：1、注意使用StringBulider包装类，这样可以实现直接修改字符，并且可以使用setCharAt（）方法直接设置字符串的值，这样就不用将字符串转换成字符数组在操作，减少代码执行时间。

2、String、StringBuffer、StringBulider的异同点

相同点：底层都是通过char数组实现的

不同点：String对象一旦创建就不能被修改（在常量池中开辟一个固定空间存放），如果需要修改，会在内存空间重新开辟一个新的空间来存储修改后的对象，而StringBulider和 StringBuffer对象的值是可以被修改的；

StringBuffer和StringBulider的扩容机制为将原始数据容量扩大一倍在＋2；

StringBuffer几乎几乎所有的方法都是用了synchronized来实现线程同步，因此在多线程的情况下系统可以保证数据同步，其线程安全，但效率低，StringBuilder没有实现同步，线程不安全，单数其效率高。因此为保证线程安全，在多线程的情况下，应该使用StringBuffer。

4.3代码实现

class Solution {
    public String reverseWords(String s) {
        //首先去除首尾字符串
        StringBuilder s1 = removespace(s);
        // 接着反转整个字符串
         reverseAll(s1,0,s1.length()-1);
        // 对每个单词进行反转
         reverEachWord(s1);
         return s1.toString();
    }
    public StringBuilder removespace(String s){
        int start = 0;
        int end = s.length()-1;
        // 使用循环判断删除首尾部空字符
        while (s.charAt(start) == ' ') start++;
        while (s.charAt(end) == ' ' ) end--;
        // 定义一个字符对象用于存放删除后的结果
        StringBuilder newString = new StringBuilder();
        //将s中的字符放入字符对象中
        while(start <= end){
            char c = s.charAt(start);
            // 防止连续添加空串，本轮循环开始字符不为空或者上轮循环得到字符串结尾不为空
            if(c!=' ' || newString.charAt(newString.length()-1)!=' '){
                newString.append(c); 
            }
             start++;
        }
        return newString;

    }
    public void reverseAll(StringBuilder s,int slow,int fast){
        while(slow < fast){
            char temp = s.charAt(slow);
            s.setCharAt(slow,s.charAt(fast));
            s.setCharAt(fast,temp);
            fast --;
            slow ++;
        }
    }
    public void reverEachWord(StringBuilder s){
        // 定义字母开始点
        int start = 0;
         // 定义字母结束点
        int end = 1;
       while(start < s.length()){
            while(end < s.length() && s.charAt(end) !=' ') {
            end++;
        }
        reverseAll(s,start,end-1);
         start = end+1;
         end = start+1;
        
       }

    }
}

五、28找出字符串中第一个匹配的下标

5.1题目

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

1 <= haystack.length, needle.length <= 104
haystack 和 needle 仅由小写英文字符组成

5.2思路分析

方法一：双重循环求解

双重循环遍历两个数组，外层循环控制模式串每次遍历的起始位置，内层循环控制匹配串的与模式串逐个字符进行匹配，除此之外，我们可以将外层循环的循环变量视为一个模式串与匹配串是否可以完全匹配的标准，即当循环变量的值与匹配串的长度相等时，此时为完全匹配。注意外层循环的循环结束条件为模式串减去匹配串加一，因为当剩余字符串的长度小于匹配串的长度时此时就不用再匹配了，除此之外外层循环的结束条件也须注意，应该将循环变量与字符串的比较放到模式串与匹配串匹配的前面，否则会出现数组越界。

方法二：KMP算法

算法详解

5.3代码实现

方法一：双重循环求解

class Solution {
    public int strStr(String haystack, String needle) {
        int length1 = haystack.length();
        int length2 = needle.length();
         char[] s1 = haystack.toCharArray();
         char [] s2= needle.toCharArray();
         int start;
         int j;

         
        //  定义i为模式串的初始位置因此i的结束位置应该为length1-length2
        for(int i = 0 ;i <= length1-length2;i++ ){
            start = i;
            j = 0;
            while(j < length2 && s1[i+j] == s2[j]  ){
                j++;
            }
            if(j == length2){
                return start;
            }else{
                continue;
            }
        }
        return -1;

    }
}

方法二KMP算法

class Solution {
    public void getNext(int[] next, String s){
        int j = -1;
        next[0] = j;
        for (int i = 1; i < s.length(); i++){
            while(j >= 0 && s.charAt(i) != s.charAt(j+1)){
                j=next[j];
            }

            if(s.charAt(i) == s.charAt(j+1)){
                j++;
            }
            next[i] = j;
        }
    }
    public int strStr(String haystack, String needle) {
        if(needle.length()==0){
            return 0;
        }

        int[] next = new int[needle.length()];
        getNext(next, needle);
        int j = -1;
        for(int i = 0; i < haystack.length(); i++){
            while(j>=0 && haystack.charAt(i) != needle.charAt(j+1)){
                j = next[j];
            }
            if(haystack.charAt(i) == needle.charAt(j+1)){
                j++;
            }
            if(j == needle.length()-1){
                return (i-needle.length()+1);
            }
        }

        return -1;
    }
}

六、用栈实现队列

6.1题目

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

1 <= x <= 9
最多调用 100 次 push、pop、peek 和 empty
假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

6.2思路分析

队列先入先出，栈先入后出

用两个栈（一个出栈一个入栈）来模拟队列

6.3代码实现

class MyQueue {
    // 定义出栈和入栈
    Stack <Integer> StackIn;
    Stack <Integer> StackOut;

    public MyQueue() {
    StackIn = new Stack<>();//定义入栈
    StackOut = new Stack<> ();//定义出栈
    }
    
    public void push(int x) {
        StackIn.push(x);
    }
    // 该pop方法模拟的是队列的pop方法而不是栈的pop方法
    public int pop() {
        //先将入栈中值放入到出栈中在进行出队列
    stackInToOut();
    return StackOut.pop();
    }
    // 查询栈或者队列的首个元素
    public int peek() {
        stackInToOut();
        return StackOut.peek();

    }
    // 判断队列是否为空
    public boolean empty() {
        return StackIn.isEmpty() && StackOut.isEmpty();

    }
    // 如果stackout为空，则将stackin的中数值放入到stackout中
    public void stackInToOut(){
    // 如果出栈不为空则直接返回(不用向其中添加数字了)
    if(!StackOut.isEmpty()) return;
    while(!StackIn.isEmpty()){
        StackOut.push(StackIn.pop());
    }
    }
}

/**
 * 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用队列实现栈

7.1题目

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

7.2思路分析

方法一用两个队列来模拟栈

方法二用一个队列来模拟栈

7.3代码实现

方法一两个队列来模拟栈

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;
    public MyStack() {
        // 队列是使用linkedlist生成的
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();

    }
    
    public void push(int x) {
        // 先将数值放在辅助队列中
        queue2.offer(x);
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        Queue<Integer> queueTemp;//定义中间变量
        queueTemp = queue1;
        queue1 = queue2;
        queue2 = queueTemp;

    }
    
    public int pop() {
        return queue1.poll();

    }
    
    public int top() {
        return queue1.peek();

    }
    
    public boolean empty() {
        return queue1.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();
 */

方法二一个队列来实现栈

class MyStack {
    Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();

    }
    
    public void push(int x) {
        queue.offer(x);
        int size = queue.size();
        while(size -- > 1){
            queue.offer(queue.poll());
        }

    }
    
    public int pop() {
        return queue.poll();

    }
    
    public int top() {
        return queue.peek();

    }
    
    public boolean empty() {
        return queue.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();
 */