算法与数据结构-字符串 讲解与java代码实现

最新推荐文章于 2022-04-21 21:58:51 发布
最新推荐文章于 2022-04-21 21:58:51 发布
阅读量480 收藏 2
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bury_/article/details/79225669
版权

1.基础

这里写图片描述
这里写图片描述
这里写图片描述这里写图片描述这里写图片描述这里写图片描述这里写图片描述这里写图片描述这里写图片描述这里写图片描述这里写图片描述

2.例题

1. 拓扑结构相同子树练习题

这里写图片描述这里写图片描述这里写图片描述
KMP算法及示例讲解：http://blog.csdn.net/bury_/article/details/79199228

import java.util.*;
//拓扑结构相同的子树判断，要求时间复杂度为O(n)
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class IdenticalTree {
    public boolean chkIdentical(TreeNode A, TreeNode B) {
        //采用先序遍历的方法遍历并序列化树，有值则打印val!，空值则打印#!
        String Astr=serilizeTree(A);
        String Bstr=serilizeTree(B);
        int len=Astr.length();
        int lenP=Bstr.length();
        char[] Aarray=Astr.toCharArray();
        char[] Barray=Bstr.toCharArray();

       //KMP算法计算序列化后的A是否包含B
       //遍历长度为m的字符串，时间复杂度O(m)
        return KMP(Aarray,Barray);
    }
    //str是待检测字符串，ptr是搜索的模式子串
    public boolean KMP(char[] str,char[] ptr){
        //计算模式子串的next数组
        int[] next=cal_next(ptr);

        int slen=str.length;
        int plen=ptr.length;//子串的长度
        int k=-1;
        for(int i=0;i<slen;i++){
            while(k>-1&&ptr[k+1]!=str[i]){
                k=next[k];
            }
            if(ptr[k+1]==str[i]){
                k=k+1;
            }
            if(k==(plen-1)){
                //return i-lenp+1;
                return true;
            }
        }
        return false;
    }
    public String serilizeTree(TreeNode A){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(A);
        String result=new String();
        TreeNode cur;
        while(!stack.isEmpty()){
            cur=stack.pop();
            if(cur==null){
                result+="#!";
            }else{
                result+=cur.val+"!";
                stack.push(cur.right);
                   stack.push(cur.left);
            }
        }
        return result;
    }

    public int[] cal_next(char[] s){
        int len=s.length;
        int[] next=new int[len];
        next[0]=-1;
        int k=-1;//k表示s[0,k]字符串的最长前缀等于最长后缀时的最长前缀长度减去1
        //遍历长度为n的子串，时间复杂度O(n)
        for(int q=1;q<=(len-1);q++){
            //如果下一个不同，那么k就变成next[k]，注意next[k]是小于k的，无论k取任何值。
            while(k>-1&&s[k+1]!=s[q]){
                k=next[k];//往前回溯
            }
            if(s[k+1]==s[q]){
                k=k+1;
            }
            //这个是把算的k的值（就是相同的最大前缀或最大后缀的长度减去1）赋给next[q]
            next[q]=k;
        }
        return next;
    }
}

2.变形词判断

这里写图片描述这里写图片描述

import java.util.*;
//变形词判断
public class Transform {
    public boolean chkTransform(String A, int lena, String B, int lenb) {
        if(A==null||B==null||A.length()!=B.length()){
            return false;
        }
        //对A建立哈希数组
        int[] map=new int[256];//0-255是ASCII码对应的十进制编码
        int lenA=A.length();
        int lenB=B.length();
        char[] Aarray=A.toCharArray();
        char[] Barray=B.toCharArray();
        for(int i=0;i<lenA;i++){
            map[Aarray[i]]++;
        }
        //遍历B查询A的哈希数组，看是否对应
        for(int i=0;i<lenB;i++){
            if(map[Barray[i]]--==0){
                return false;
            }
        }
        return true;
    }
}

3.两串旋转练习题

如果对于一个字符串A，将A的前面任意一部分挪到后边去形成的字符串称为A的旋转词。比如A=”12345”,A的旋转词有”12345”,”23451”,”34512”,”45123”和”51234”。对于两个字符串A和B，请判断A和B是否互为旋转词。
给定两个字符串A和B及他们的长度lena，lenb，请返回一个bool值，代表他们是否互为旋转词。
测试样例：
“cdab”,4,”abcd”,4
返回：true

import java.util.*;
public class Rotation {
    public boolean chkRotation(String A, int lena, String B, int lenb) {
        char[] Aarray=(A+A).toCharArray();
        int[] next=cal_next(B);
        char[] Barray=B.toCharArray();
        int len=Aarray.length;
        int lenB=B.length();
        //使用KMP算法计算B是否包含在A+A中
        int k=-1;
        for(int i=0;i<len;i++){
            while(k>-1&&Barray[k+1]!=Aarray[i]){
                k=next[k];
            }
            if(Barray[k+1]==Aarray[i]){
                k=k+1;
            }
            if(k==(lenB-1)){
                //return i-lenp+1;
                return true;
            }
        }
        return false;
    }
    //计算next数组
     public int[] cal_next(String str){
        char[] s=str.toCharArray();
        int len=str.length();
        int[] next=new int[len];
        next[0]=-1;
        int k=-1;
        for(int q=1;q<=(len-1);q++){
            //如果下一个不同，那么k就变成next[k]，注意next[k]是小于k的，无论k取任何值。
            while(k>-1&&s[k+1]!=s[q]){
                k=next[k];//往前回溯
            }
            if(s[k+1]==s[q]){
                k=k+1;
            }
            //这个是把算的k的值（就是相同的最大前缀和最大后缀长）赋给next[q]
            next[q]=k;
        }
        return next;
    }
}

4.字符串逆序

这里写图片描述这里写图片描述

方法一：使用split函数分离出单词

import java.util.*;
//字符串逆序
public class Reverse {
    public String reverseSentence(String A, int n) {
        String reverseA=reverse(A);
        String[] words=reverseA.split(" ");
        int len=words.length;
        String result=new String();
        for(int i=0;i<len;i++){
            result+=reverse(words[i]);
             if(i<len-1){
                result+=" ";
            }
        }
        return result;
    }
    //调整字符串为逆序
    public String reverse(String s){
        char[] a=s.toCharArray();
        int len=a.length;
        int left=0,right=len-1;
        while(left<right){
            char temp=a[left];
            a[left]=a[right];
            a[right]=temp;

            left++;
            right--;
        }
        return String.valueOf(a);
    }
}

方法二：自动判断单词

import java.util.*;
//字符串逆序
public class Reverse {
    public String reverseSentence(String A, int n) {
        char[] a=A.toCharArray();
        rotateWord(a);
        return String.valueOf(a);
    }
    public void rotateWord(char[] a){
        //整个字符串进行逆序
        reverse(a,0,a.length-1);
        //对单词再进行逆序
        int left=-1,right=-1;//left指向单词的第一个，right指向单词最后一个
        int len=a.length;
        for(int i=0;i<len;i++){
            if(a[i]!=' '){
                left=i==0||a[i-1]==' '?i:left;
                right=i==len-1||a[i+1]==' '?i:right;
            }
            //left和right分别指向了单词的第一个和最后一个时
            if(left!=-1&&right!=-1){
                reverse(a,left,right);
                left=-1;
                right=-1;
            }
        }
    }
    //调整字符串为逆序
    public void reverse(char[] a,int start,int end){
        while(start<end){
            char temp=a[start];
            a[start]=a[end];
            a[end]=temp;

            start++;
            end--;
        }
    }
}

5.字符串移位

这里写图片描述
这里写图片描述

import java.util.*;
//原地字符串移位练习
public class Translation {
    public String stringTranslation(String A, int n, int len) {
        char[] a=A.toCharArray();
        //将字符串0-(len-1)部分逆序
        reverse(a,0,len-1);
        //将字符串len到最后的部分逆序
        reverse(a,len,a.length-1);
        //将整个字符串逆序
        reverse(a,0,a.length-1);

        return String.valueOf(a);
    }
    //局部逆序操作
    public void reverse(char[] a,int start,int end){
        while(start<end){
            char temp=a[start];
            a[start]=a[end];
            a[end]=temp;

            start++;
            end--;
        }
    }
}

6. 拼接最小字典序练习题

对于一个给定的字符串数组，请找到一种拼接顺序，使所有小字符串拼接成的大字符串是所有可能的拼接中字典序最小的。

给定一个字符串数组strs，同时给定它的大小，请返回拼接成的串。

测试样例：
[“abc”,”de”],2
“abcde”
这里写图片描述
这里写图片描述
这里写图片描述

import java.util.*;
//拼接最小字典序列
public class Prior {

    public String findSmallest(String[] strs, int n) {
        Arrays.sort(strs,new Comparator<String>(){
            @Override
            public int compare(String a,String b){
                return (a+b).compareTo(b+a);
            }
        });
        String result=new String();

        for(int i=0;i<n;i++){
            result+=strs[i];
        }
        return result;
    }
}

7. 空格替换

这里写图片描述
这里写图片描述

import java.util.*;
//字符串空格替换
public class Replacement {
    public String replaceSpace(String iniString, int length) {
        //首先遍历字符串找到空格的数量以确定替换后的总长度
        int space=0;
        char[] s=iniString.toCharArray();
        for(int i=0;i<length;i++){
            if(s[i]==' '){
                space++;
            }
        }
        int total=length+2*space;//替换后的字符个数
        char[] result=new char[total];
        //将字符依次拷贝到后面的空间，遇到空格时替换为%20
        for(int i=length-1,index=total-1;i>=0&&index>=0;i--,index--){
            if(s[i]!=' '){
                result[index]=s[i];
            }else{
                result[index--]='0';
                result[index--]='2';
                result[index]='%';
            }
        }

        return String.valueOf(result);
    }
}

直接使用StringBuilder

import java.util.*;
//字符串空格替换
public class Replacement {
    public String replaceSpace(String iniString, int length) {
        //将字符依次拷贝到后面的空间，遇到空格时替换为%20
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<length;i++){
            char c=iniString.charAt(i);
            if(c==' '){
                sb.append("%20");
            }else{
                   sb.append(c);
            }
        }

        return sb.toString();

    }
}

8.合法括号判断

这里写图片描述

import java.util.*;
//合法括号串判断
public class Parenthesis {
    public boolean chkParenthesis(String A, int n) {
        int num=0;
        Stack<String> stack=new Stack<String>();
        for(int i=0;i<n;i++){
            char c=A.charAt(i);
           if(c=='('){
               stack.push("(");
               continue;
           }
           if(c==')'){
               if(stack.isEmpty()==true||stack.pop()!="("){
                   return false;
               }

           }
        }
        return stack.isEmpty();
    }
}

9.最长无重复子串

这里写图片描述
这里写图片描述
这里写图片描述这里写图片描述这里写图片描述

import java.util.*;
//最长无重复子串长度计算
public class DistinctSubstring {
    public int longestSubstring(String A, int n) {
        //哈希表map记录每种字符最近出现的位置
        //pre记录当前字符的上一个字符串结尾的情况下，最长无重复字符子串的起始位置-1
        int[] map=new int[256];
        for(int i=0;i<256;i++){
            map[i]=-1;
        }
        int max=0,pre=-1,temp=0;
        for(int i=0;i<n;i++){
            pre=Math.max(pre,map[A.charAt(i)]);
            temp=i-pre;
            max=Math.max(max,temp);
            map[A.charAt(i)]=i;
        }
       return max;
    }
}

3.JAVA实现tips

*     String的长度用length()
* “ ”双引号表示空字符串，‘ ’单引号表示空字符
* 字符数组转换成String，String.valueOf(char[] ch)
* compareTo()方法 http://www.runoob.com/java/number-compareto.html
* StringBuilder() 增加字符串append("XXX") 
* StringBuilder转换为String类型 toString()
* String获取字符元素 s.charAt(index)
慕森
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构——串(学习笔记)
weixin_45993282的博客
07-21 1081
串 定义 串：即字符串 由零个或多个字符组成的有限序列（空格也是字符） Java、C–双引号 python–单引号 子串：串中任意个连续的字符组成的子序列，空串也是一个子串 空串：长度为0。只有空格的串不是空串 串是一种特殊的线性表，数据元素之间呈线性关系 与线性表的区别： 线性表的数据对象不限，串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等） 线性表的基本操作对象是某一个元素，串的基本操作对象是子串 基本操作 赋值操作：StrAssign(&T,chars) 把
2021数据结构与算法面试题
08-14
数据结构与算法是计算机科学的基础，对于...以上知识点是数据结构与算法面试题中常见的部分，每个主题下都可能有深入的理论讲解和实践题目，对于准备面试的开发者来说，全面掌握这些内容将大大提升在面试中的竞争力。
java串_数据结构(java)之串
weixin_34928522的博客
02-15 539
1.串的逻辑结构a)定义：由0到多个字符组成的有限序列，使数据元素为单个字符的特殊线性表，串中连续的子序列叫子串，子串的位置为字串的第一个字符在串中的位置b)串的抽象数据类型i.数据元素：字符ii.数据结构：线性关系，除第一个字符外每个字符都有前驱，除最后一个字符外，每个字符都有后继iii.数据操作：求串长，串连接，串比较，求子串，串定位，串附加，穿插入，传删除2.Java中的String类a)存...
Java 中 String 类的实现详解 及其 数据结构图
mujing11的博客
07-20 1215
字符串构造举例 public class egString{ public static void main(String[] args){ //使用空参构造 String str1 = new String(); System.out.println(str1);//空白字符串 //根据字符数组创建字符串 char[] charArray = { 'A', 'B', 'C'}; String str2 = new String(charArray); System.out
数据结构之串代码实现
山山而川~
04-09 2346
一 、串的概念 字符串简称串，是一种特殊的线性表，它的数据元素仅由一个字符组成。 二 、串的定义 串(String)是由零个或多个字符组成的有限序列，又称字符串。其中s是串名,用双引号括起来的字符序列为串值，但引号本身并不属于串的内容。ai(1<=i<=n)是一个任意字符,它称为串的元素,是构成串的基本单位，i是它在整个串中的序号；n为串的长度,表示串中所包含的字符个数。 三 、串...
JAVA数据结构——串
qq_37857921的博客
01-19 2522
串： 什么是串？把若干单独个体连接在一起就是一个串。在数据结构中，我们使用的无论是顺序表或者是链表，都是讲个体链接在一起的方法，所以我们利用前面学习的知识，将个体连接在一起实现串的模式匹配(字串在主串中查找的过程)，后面将介绍一种简单的子串查找算法BF算法(Brute-Force算法)和KMP算法。 1. 串的概念 字符串简称串,是一种特殊的线性表,它的数据元素仅由一个字符组成。 2. 串的...
Java 实例 - 字符串反转源代码-详细教程.zip
08-07
通过实践这些例子，你可以深入学习Java的内存管理、字符串操作以及基本数据结构和算法，这些都是Java程序员必备的基础知识。 本教程的详细代码和解释都包含在"Java 实例 - 字符串反转源代码-详细教程.rar"文件中，...
java数据结构和算法实现.zip
最新发布
06-17
这个zip文件的“ljg_resource1”可能包含了以上数据结构和算法的Java实现，通过学习和实践这些代码，你可以加深对数据结构和算法的理解，提升编程技能，为解决实际问题打下坚实基础。同时，理解并熟练运用这些知识...
深入理解系列之JAVA数据结构（5）——String
站在人文与技术的交汇点
04-17 5677
String类型是Java编程中最为常见的数据结构（没有之一），与之相关联的还有StringBuilder和StringBuffer。其中String类型是不可变的；后者均是可变的字符串，但是StringBuilder是线程不安全的，StringBuffer线程安全；所以三者的效率排名为：StringBuilder&gt;String&gt;StringBuffer。另外，为了优化字符串的使...
5Java学习笔记之数据结构——字符串String
tianyaleixiaowu的专栏
03-29 3990
字符串这个非常非常常用的数据结构，平时用的最多，但它到底是怎么工作的，可能没多少人去关心过。下面就来谈谈这个String到底有什么特殊的。 String s1 = "abc"; String s2 = "abc"; String s3 = "ab" + "c"; String s4 = new String("abc"); 判断上面s1,s2,s3,s4是否相等，用== 答案是：s1=
java数据结构之字符串
a1451516的博客
03-18 174
字符串 反转字符串 class Solution { public void reverseString(char[] s) { int n =s.length; for( int left=0,right=n-1;left<right;left++,right--){ char temp = s[right]; s[right]=s[left]; s[left]=temp; } } } 反转字符串2 cla
数据结构与算法---复习：顺序表字符串的KMP算法实现
weixin_43990171的博客
07-20 271
数据结构与算法—复习：顺序表字符串的KMP算法实现 首先感叹一下KMP算法中求解next数组的算法之精妙： int* findNext(PSeqString s){ int* next = (int*)malloc(sizeof(s->n)); //分配适合大小的next数组空间 int i = 0 , k = -1; //初始化开始的值 next[0] = -1; //next[0] 一定是 -1 有些地方写的是 0 while(i < s->n -
Java数据结构之 字符串的模式匹配
huijerry的博客
05-13 4263
一. BF算法BF算法又称暴力匹配算法，比较方法：BF算法的思想就是将主串S的第一个字符与子串T的第一个字符进行匹配，若相等，则继续比较S的第二个字符和 T的第二个字符；若不相等，则比较S的第二个字符和T的第一个字符，依次比较下去，直到得出最后的匹配结果。接下来是代码实现public static int BF(String str,String sub,int pos){ if(pos &l...
数据结构-串详解（字符串）（类C语言版）
秃了也弱了
04-21 2006
串的概念 串（String）——由零个或多个任意字符组成的有限序列。 空串用∅表示。 概念 子串：串中任意个连续字符组成的子序列称为该串的子串。 主串：包含子串的串相应地称为主串。 字符位置：字符在序列中的序号为该字符在串中的位置。 子串位置：子串第一个字符在主串中的位置。 空格串：由一个或多个空格组成的串，与空串不同。 实例 字符串a、b、c、d a='BEI' b='JING' c='BEIJING' d='BEI JING' 它们的长度分别是：3、4、7、...
数据结构之串的知识
weixin_52356220的博客
03-17 287
1.朴素的模式匹配算法 将主串的每一个字符作为子串的开头进行匹配，若不相同即不匹配，则将重新匹配子串的下一个字符。 此时我们假设将主串S和要匹配的子串T的长度存在S[0]和T[0]中，实现代码如下： /*返回子串T在主串S中第pos个字符之后的位置，若不存在，则函数的返回值为0*/ /*T非空，则1<=pos<=StrLength(s)。*/ int index(String S,String T,int pos) { int i = pos;/*i用于当pos不为1时，从主串的当前位置下标开
java中substring的用法
weixin_34375251的博客
04-22 450
str＝str.substring(int beginIndex);截取掉str从首字母起长度为beginIndex的字符串，将剩余字符串赋值给str； str＝str.substring(int beginIndex，int endIndex);截取str中从beginIndex开始至endIndex结束时的字符串，并将其赋值给str;这是一个很常见的函数，他的所用 trim()是去掉...
几种常见的数据结构的java实现
wlyrain2011的博客
04-06 3094
常见的数据结构有  栈  队列  链表  二叉树  栈 ：先进先出 队列：先进后出 对数据结构的操作常见的有  增 删 改 查 下面分别介绍这几种数据结构的实现方式: 1)栈   Stack 栈可以用数组实现也可以用列表实现，两种方式均有top变量来标识栈顶，maxSize来标识栈的最大容量，栈的常见方法为push  pop  peek  isEmpty  isFull（通过top
数据结构 串 代码 java_数据结构（java版） 刘小晶
weixin_42502896的博客
02-28 165
【实例简介】数据结构(java版)课件及代码 刘小晶数据结构(java版)课件及代码 刘小晶数据结构(java版)课件及代码 刘小晶【实例截图】【核心代码】数据结构(java版)刘小晶`-- 数据结构(java版) 刘小晶|-- PPT| |-- 第5章 树与二叉树(java版).ppt| |-- 第6章 图(Java版).ppt| |-- 第7章 排序(Java版).ppt|...
数据结构之数组和字符串的反转java实现
青松之竹_Java博客
01-15 2812
采用java实现数组和字符串的反转
数据与算法课件：5 字符串.pdf
06-26
数据与算法课件：5 字符串.pdf

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值