字符串双指针——面试必刷TOP101

最新推荐文章于 2023-01-20 09:15:31 发布
最新推荐文章于 2023-01-20 09:15:31 发布
阅读量97 收藏 1
点赞数
分类专栏： 题目记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xmm18323188267Ella/article/details/124586985
版权

字符串/双指针

BM22 比较版本号

import java.util.*;

public class Solution {

    public int compare (String v1, String v2) {
        int m=v1.length(),n=v2.length();
        int i=0,j=0;
        while(i<m || j<n){
            int a=0;
            while(i<m && v1.charAt(i)!='.'){
                a=a*10+v1.charAt(i)-'0';
                i++;
            }
            int b=0;
            while(j<n && v2.charAt(j)!='.'){
                b=b*10+v2.charAt(j)-'0';
                j++;
            }
            if(a!=b) return a>b?1:-1;
            i++;
            j++;
        }
        return 0;
    }
}

BM83 字符串变形

import java.util.*;

public class Solution {
    public String trans(String s, int n) {
        String[] sa = s.split(" ", -1);//spilt的第二个参数imit设为-1可以让字符串最后的空格不被省略。
        StringBuilder sb = new StringBuilder();
        for (int i = sa.length - 1; i >= 0; i--) {
            sb.append(handle(sa[i])).append(" ");
        }
        return sb.substring(0,sb.length() - 1);
    }
    private String handle(String s){
        StringBuilder sb= new StringBuilder();
        for(char c:s.toCharArray()){
            if(Character.isLowerCase(c)) sb.append(Character.toUpperCase(c));
            else if(Character.isUpperCase(c)) sb.append(Character.toLowerCase(c));
        }
        return sb.toString();
    }
}

BM84 最长公共前缀

import java.util.*;

public class Solution {

    public String longestCommonPrefix (String[] strs) {
        if(strs.length==0) return "";
        String res=strs[0];
        for(String s:strs){
            while(!s.startsWith(res)){
                if(res.length()==0) return "";
                res=res.substring(0,res.length()-1);
            }
        }
        return res;
    }
}

BM85 验证IP地址

import java.util.*;

public class Solution {

    public String solve(String IP) {
        if(IP.indexOf(':') == -1){
          return validateIPv4(IP);
        }
        else if(IP.indexOf('.') == -1){
          return validateIPv6(IP);
        }
        else return "Neither";
      }
    /*
    split() 方法根据匹配给定的正则表达式来拆分字符串。
    注意： . 和 $和 | 和 * 等转义字符，必须得加 \\。
    注意：多个分隔符，可以用 | 作为连字符。
    */
    
//IPv4 地址由4组10进制数来表示，其范围为 0 - 255，每组长度1-3， 用(".")分割。比如，172.16.254.1
//同时，IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。
      public String validateIPv4(String IP) {
        String[] nums = IP.split("\\.",-1);
        if(nums.length!=4) return "Neither";
        for (String x : nums) {
          if (x.length() == 0 || x.length() > 3) return "Neither";
          if (x.charAt(0) == '0' && x.length() != 1) return "Neither";
          for (char c : x.toCharArray()){ 
                if (c < '0' || c > '9') return "Neither";
          }
          if (Integer.parseInt(x) > 255) return "Neither";
        }
        return "IPv4";
      }
//IPv6 地址由8组16进制的数字来表示，每组表示 16 比特，每组长度1-4。这些组数字通过 (":")分割
//不能出现 (::) 、(:0000:0000:)的情况。(:0:0:)是对的
      public String validateIPv6(String IP) {
        String[] nums = IP.split(":",-1);
        if(nums.length!=8) return "Neither";
        String hexdigits = "0123456789abcdefABCDEF";
        for (String x : nums) {
          if (x.length() == 0 || x.length() > 4) return "Neither";
          for (Character c : x.toCharArray()) {
            if (hexdigits.indexOf(c) == -1) return "Neither";
          }
        }
        return "IPv6";
      }
}

BM86 大数加法

import java.util.*;

public class Solution {
    public String solve(String num1, String num2) {
        StringBuilder res = new StringBuilder();
        int i = num1.length() - 1, j = num2.length() - 1, carry = 0;
        while(i >= 0 || j >= 0 || carry != 0){
            int n1 = i >= 0 ? num1.charAt(i) - '0' : 0;
            int n2 = j >= 0 ? num2.charAt(j) - '0' : 0;
            int tmp = n1 + n2 + carry;
            carry = tmp / 10;
            res.append(tmp % 10);
            i--; 
            j--;
        }
        return res.reverse().toString();
    }
}
/*
import java.math.BigInteger;
public class Solution {
    public String solveByJava(String s, String t){
        BigInteger num1 = new BigInteger(s);
        BigInteger num2 = new BigInteger(t);
        return num1.add(num2).toString();
    }
}
*/

BM49 表达式求值

import java.util.*;

public class Solution {
    public int solve (String s) {
        Stack<Integer> stack = new Stack<>();//初始化栈
        int num= 0;//默认数字
        char sign = '+';//默认的第一个数字前的运算符为 + 
        char[] arr = s.toCharArray();//字符串转化字符数组
        for(int i = 0;i<s.length();i++){//对字符数组每个元素遍历
            char c = arr[i];
            
            if (c == ' ') continue;
            
            if(c == '('){//是否为左括号
                int j = i + 1;
                int counterPar = 1;//默认是1对括号
                while(counterPar > 0){//统计是否存在括号嵌套的情况
                    if(arr[j] == '(') counterPar++;
                    else if(arr[j] == ')')counterPar--;
                    //向后直到找到右括号
                    j++;
                }
                //遇到左括号递归求这个括号里面表达式的值
                //就是求左括号 到 右括号 之间 表达式的 值,返回值为 number,下面接着进栈
                num  = solve(s.substring(i + 1,j - 1));
                //下一次就要从 j 开始，因为后面还有一个 i ++;
                i = j - 1;
            }
            if(c >= '0' && c <= '9') num = num * 10 + c - '0';
            //if(Character.isDigit(c)) num = num * 10 + c - '0';//是否为数字，是数字就求完整的数字值，每次循环都进这个分支，直到出现运算符
           
            //if( ! Character.isDigit(c) || i == s.length() - 1){
            if (c < '0' || c > '9'|| i == s.length() - 1){//不是数字 或者 为最后一个字符
                if(sign == '+') stack.push(num);//是 + 先把 数字 压栈，等会全部数字出栈之和即为所求
                else if(sign == '-') stack.push( -1 * num);//是 - 压栈该数字的相反数
                else if(sign == '*') stack.push(stack.pop() * num);//是 * ，弹栈算出结果，在压栈
                else if(sign == '/') stack.push(stack.pop() / num);//是 / ，弹栈算出结果，在压栈
                num = 0; //每次结束，数字恢复默认值
               // 遇到运算符时或者到表达式末尾时，就去计算上一个运算符并把计算结果push进栈，然后保存新的运算符
                //运算符为 当前压栈数字 前面近邻的那个
                sign = c;
                //如果是负数 在 表达式的最前面 ，会先压栈 +0，然后在记录当前 负号，开始接下来的数字
            }
        }
        int sum = 0;        //结果
        while(!stack.isEmpty()){
            sum += stack.pop();
        }
        return sum;
    }
}

BM88 判断是否为回文字符串

import java.util.*;

public class Solution {

    public boolean judge (String str) {
        int i=0,j=str.length()-1;
        while(i<=j){
            if(str.charAt(i)!=str.charAt(j)) return false;
            i++;
            j--;
        }
        return true;
    }
}

BM91 反转字符串

import java.util.*;

public class Solution {

    public String solve (String str) {
        char[] arr=str.toCharArray();
        int i=0,j=arr.length-1;
        while(i<j){
            char tmp=arr[i];
            arr[i]=arr[j];
            arr[j]=tmp;
            i++;
            j--;
        }
        return new String(arr);
    }
}

BM90 最小覆盖子串

import java.util.*;

public class Solution {

    public String minWindow(String s, String t) {
        if (s == null || s.length() == 0 || t == null || t.length() == 0) return "";
        int[] need = new int[128];
        for (int i = 0; i < t.length(); i++) need[t.charAt(i)]++;
        int l = 0, r = 0, res = Integer.MAX_VALUE, count = t.length(), start = 0;
        while (r < s.length()) {
            if (need[s.charAt(r)] > 0) count--;
            need[s.charAt(r)]--;
            if (count == 0) {
                while (l < r && need[s.charAt(l)] < 0) {
                    need[s.charAt(l)]++;
                    l++;
                }
                if (r - l + 1 < res) {
                    res = r - l + 1;
                    start = l;
                }
                need[s.charAt(l)]++;
                l++;
                count++;
            }
            r++;
        }
        return res == Integer.MAX_VALUE ? "" : s.substring(start, start + res);
    }
}

BM87 合并两个有序的数组

import java.util.*;
public class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1, j = n - 1, k = m + n - 1;
        while (j >= 0) {
            if (i < 0 || nums2[j] > nums1[i]) nums1[k--] = nums2[j--];
            else nums1[k--] = nums1[i--];
        }
    }
}

BM89 合并区间

import java.util.*;

/**
 * Definition for a{n interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    ArrayList<Interval> res = new ArrayList<Interval>();
    public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
        Collections.sort(intervals, (v1,v2) ->v1.start - v2.start);
        int i = -1;
        for(Interval interval :intervals){
            if(i == - 1 ||interval.start >res.get(i).end){
                res.add(interval);
                i++;
            }else res.get(i).end = Math.max(interval.end, res.get(i).end);
        }
        return res;
    }


    /*
    int[][] res=new int[intervals.length][2];
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(v1,v2)->v1[0]-v2[0]);
        int i=-1;
        for(int[] interval:intervals){
            if(i==-1||interval[0]>res[i][1]) res[++i]=interval;
            else res[i][1]=Math.max(res[i][1],interval[1]);
        }
        return Arrays.copyOf(res,i+1);
    }
    */
}

BM92 最长无重复子数组(子数组是连续的)

import java.util.*;

public class Solution {

    public int maxLength (int[] arr) {
        Map<Integer, Integer> map = new HashMap<>();
        int i = -1, res = 0;
        for(int j = 0; j < arr.length; j++) {
            if(map.containsKey(arr[j]))
                i = Math.max(i, map.get(arr[j])); // 更新左指针 i
            map.put(arr[j], j); // 哈希表记录
            res = Math.max(res, j - i); // 更新结果
        }
        return res;
    }
}

BM93 盛水最多的容器

import java.util.*;

public class Solution {

     public int maxArea(int[] height) {
        int i=0,j=height.length-1;
        int res=0;
        while(i<j){
            if(height[i]<height[j]){
                res=Math.max(res,(j-i)*height[i]);//值小的指针向内移动
                i++;
            }
            else{
                res=Math.max(res,(j-i)*height[j]);//值小的指针向内移动
                j--;
            } 
            /*
            res=height[i]<height[j]?
                Math.max(res,(j-i)*height[i++]):
                Math.max(res,(j-i)*height[j--]);
            */
        }
        return res;
    }
}

BM94 接雨水问题

import java.util.*;

public class Solution {

    public long maxWater(int[] height) {
        int n=height.length;
        long sum = 0;
        int[] max_left = new int[n];
        int[] max_right = new int[n];   
        for (int i = 1; i <= n-2; i++) {
            max_left[i] = Math.max(max_left[i - 1], height[i - 1]);//第 i 列左边最高的墙，不包括自身的
         }
        for (int i = n-2; i >= 1; i--) {
            max_right[i] = Math.max(max_right[i + 1], height[i + 1]);//第 i 列右边最高的墙，不包括自身的
        }
        for (int i = 1; i <= n-2; i++) {
            int min = Math.min(max_left[i], max_right[i]);
            if (min > height[i]) sum = sum + (min - height[i]);
            //求第 i 列左右两边最高的墙。找出较矮的一端，减去当前列的高度
        }
        return sum;
    }
}
yy的旅行日志
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
(双指针，KMP)实现字符串定位
小游
11-25 304
本文档为个人博客文档系统的备份版本、作者：小游、作者博客：点击访问 我的解法 像我这种菜鸡就喜欢用暴力的方法来求解，我这个方法实际上就是一个字符串一个字符串的比对，如果相同就进入循环一个一个字符串进行比对，如果比对完全匹配就返回匹配结果反之。 func strStr(haystack string, needle string) int { if needle == "" { return 0 } // 字符串比对开始位置 t := 0 // 开始遍历haystack f.
利用双指针方法求解字符串相关问题
qq_31997185的博客
09-16 234
1. 删除数组中指定元素。两个指针从数组第一个元素开始，快指针用于遍历数组，当遇到非删除元素时，将值放于慢指针位置，满指针指向下一个位置。当遇到删除元素时，慢指针不变，快指针继续向后遍历。慢指针之前的值即为需要保留的元素。 class Solution: def delEle(self, list_str, k): # write code here if not list_str: return 0 p, q = -1,
堆栈队列排序——面试必刷TOP101
yy的旅行日志的博客
05-05 107
堆栈队列排序——面试必刷TOP101
LC0283-移动零--LC026-删除排序数组中的重复项--LC027-移除元素{双指针解决}
qq_44236958的博客
12-06 155
283. 移动零 https://leetcode-cn.com/problems/move-zeroes/ 双指针法 设置快慢指针 j慢指针表示 非零数的前一个下标 慢指针 i表示是不是非零数字 快指针 public static void moveZeroes1(int[] nums) { int j = 0; for (int i = 0; i < nums.length; i++) { if (nums[i] != 0) {
双指针以及字符串的操作
qq_54136026的博客
10-31 347
文章目录 二、数组元素进行向后移动n个位置双指针以及数组移动和找出数组中只出现一次的数字 二、数组元素进行向后移动n个位置 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据...
c语言面试题之双指针反转字符串.zip
03-29
在C语言面试中，双指针技术是一种常用且重要的技巧，尤其在处理字符串操作时。双指针法的核心思想是利用两个或多个指针在数组或字符串中的移动来实现特定的功能，例如查找、排序或变换数据。在这个"反转字符串"的...
c语言面试题之双指针反转字符串中的单词III.zip
最新发布
03-29
在C语言面试中，双指针技术是一种常用且高效的解决策略，尤其在处理字符串和数组问题时。本面试题的核心是使用双指针技巧来反转字符串中的单词，这是一个常见的编程挑战，旨在考察候选人的逻辑思维和对C语言基础知识...
c语言面试题之双指针反转字符串中的元音字母.zip
03-29
在C语言面试中，双指针技术是一种常用且重要的编程技巧，它可以帮助我们高效地解决很多问题，如字符串处理、数组排序等。本题目的核心是利用双指针来反转字符串中的元音字母，这是一种独特而有趣的算法挑战。元音...
java-leetcode面试题解双指针之第344题反转字符串.zip
03-25
在面试中，这道题目不仅能展示你对双指针的理解，还能考察到你对字符串操作的熟练程度。同时，它也是一个很好的练习，可以帮助你加深对数组操作和基本数据结构的掌握。通过不断练习LeetCode上的题目，你可以提升自己...
总结C/C++面试中可能会碰到的字符串指针题
08-31
在C/C++编程中，字符串处理是至关重要的部分，尤其在面试中，字符串指针题经常作为考察程序员基础技能和思维能力的手段。本篇文章主要针对C/C++面试中可能出现的字符串指针题目进行深入解析。 首先，让我们回顾一下...
栈、队列、基础排序
JUST_lOVE_LE的博客
09-11 187
知识点 stacks and queues 选择排序 插入排序 希尔排序 Stacks and queues 栈是在先进后出,push和pop的操作在同一端(LIFO,last in first out) 队列是先进先出,操作在两端(FIFO, first in first out) 通常栈跟队列都是用数组实现的,数组空时最好要减少数组的长度,通常缩小为四分一,数组满时扩容,扩充一倍。一般是根据需要再建个数组(扩容或缩小长度都应该是已知的了),然后再把值赋进去就可以了。 排序 Java中实现排序
字符串中的变位词之双指针
qq_43164662的博客
02-26 97
双指针可以行成固定窗口、滑动窗口、快慢指针等等，针对数组问题包括字符串问题很有效。
Leetcode 刷题 -- 双指针字符串
只不停的博客
02-18 223
用双指针方法解决字符串问题，是比较常见的一种处理方式； 344.反转字符串 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。 示例 1： 输入：[“h”,“e”,“l”,“l”,“o”] 输...
反转字符串——双指针
PanDawson的博客
11-27 534
一开始我自己固有的思维是 只用一个“指针” 也就是寻常的for(int i = 0;i<=(length>>2);i++) 但后面提交的时候会出现问题——过度交换了 因为 for(int i = 0 ; i <= (length>>2) ; i++){ temp = s[i]; s[i]...
栈/队列/排序算法
weixin_53715981的博客
07-28 453
文章目录栈定义代码实现队列定义队列代码实现双端队列代码实现排序冒泡排序选择排序 栈 定义 栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。 由于栈数据结构只允许在一端进行操作，因而按照 后进先出（LIFO, Last In First Out）
队列，栈，以及排序算法代码实现
weixin_38312279的博客
10-15 307
队列队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。代码实现：public class Queue{ private Object[] objects; private int size; private int
【数组和字符串】(四) 双指针技巧
闻韶
06-19 285
LeetCode - 探索卡片 - 数组和字符串 - 四 - 双指针技巧
day09 字符串 && 双指针 | 总结
bolinmengling的博客
01-20 1144
day09 字符串 && 双指针 | 总结
双指针算法实现字符串分割单词
git1314的博客
06-06 531
题目描述： 输入一个字符串（只包含空格和字符） 输出： 输出单词，每个单词占一行 C++代码实现 //输出单词，每个单词占一行 #include <bits/stdc++.h> using namespace std; const int N = 1010; int main() { char str[N]; gets(str); int ...
字符串的指针和指向字符串的指针变量
11-28
字符串的指针是指向字符串中某个字符的指针，可以通过指针变量来引用字符串中的字符。指向字符串的指针变量是一个指针变量，它存储了字符串的地址，可以通过该指针变量来访问字符串中的字符。 以下是一个使用指向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值