「java最长回文串」java最长回文子串
本篇文章给大家谈谈java最长回文串，以及java最长回文子串对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、JAVA练习题，编写一程序输出一个字符串中的所有回文串，求大神解答~
- 2、java代码如何编写代码找出一下字符串最长的回文数。求解
- 3、JAVA回文数求解释，一下是代码和问题。
- 4、【java字符串处理】现在给你一个字符串S，请你计算S中有多少连续子串是回文串。
- 5、Java 判断回文字符串有多少和其中的最大字符
- 6、java 编写一个方法,找出一个字符串中最长的回文子串
JAVA练习题，编写一程序输出一个字符串中的所有回文串，求大神解答~
基本思路：1、递归。字符串掐头去尾然后再进行下一级判断。这样会有重复，并且计算复杂度是指数级增长。 2、简单循环。从2-[字符串长度]的字符串逐个获得判断。
这里就用第二种方法了~~
#include iostream
#include cstdio
#include cstring
void outputString(char*, int);
char* partString(char*, int, int);
char* revString(char*, int);
bool isReversible(char*, int);
bool strEqual(char*, char*, int);
int main() {
using namespace std;
char* str;
cout "Confirm the length of the string : ";
int len = 0;
cin len;
if(len = 0) return 0;
cout endl "The string please =O= : ";
str = new char[len + 1];
cin.get();
cin.getline(str, len);
cout endl "The String : " str;
cout endl "Now outputting ... " endl;
outputString(str, strlen(str));
cout endl "Done, press any key to quit..." endl;
system("pause");
}
void outputString(char* str, int len) {
for(int i = 2; i len - 1; i++) {
for(int j = 0; j len - i; j++) {
char* str2 = partString(str, j, i);
if(isReversible(str2, i))
std::cout str2 std::endl;
delete[] str2;
}
}
}
char* partString(char* str, int index, int len) {
char* str2 = new char[len + 1];
for(int i = index; i index + len; i++)
str2[i - index] = str[i];
str2[len] = '\0';
return str2;
}
bool isReversible(char* str, int len) { //确认一个字符串是否是回文串。
char *str1, *str2;
if(len % 2 == 0) {
str1 = partString(str, 0, len/2);
str2 = revString(partString(str, len/2, len/2), len/2);
} else {
str1 = partString(str, 0, len/2);
str2 = revString(partString(str, len/2 + 1, len/2), len/2);
}
bool b = strEqual(str1, str2, len/2);
delete[] str1, str2;
return b;
}
char* revString(char* str, int len) { //返回一个前后颠倒的字符串。
char* str2 = new char[len + 1];
for(int i = 0; i len; i++) {
str2[len - i - 1] = str[i];
}
str2[len] = '\0';
return str2;
}
bool strEqual(char* str1, char* str2, int len) { //确认两个字符串是否相等。
for(int i = 0; i len; i++)
if(str1[i] != str2[i]) return false;
return true;
}
表示要改写成java难度应该不大 咱写的那么认真还测试编译通过了就采纳了吧~QwQ
java代码如何编写代码找出一下字符串最长的回文数。求解
弄个string数组对象 加载进来所有字符串 然后比较 字符串的。length（） ， length返回int型 数据 比较大小 把最大的找出来 然后输出出来 就搞定了
JAVA回文数求解释，一下是代码和问题。
str = input.nextLine().trim(); //从键盘或者其他什么地方输入的，取得字符串，并且去掉前后空格 c = str.toCharArray(); //把字符串转化成字符数组 for(int i = c.length -1; i = 0 ; i--){ //从尾到头遍历数组 tmp +=c[i]; //将字符组成字符串 }
采纳哦
【java字符串处理】现在给你一个字符串S，请你计算S中有多少连续子串是回文串。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class test
{
public static void main(String[] args) throws IOException
{
System.out.print("输入圆盘的个数：");
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str=br.readLine();
int m=Integer.parseInt(str);
System.out.println("移动步骤:");
hanoi(m,'A','B','C');
}
Java 判断回文字符串有多少和其中的最大字符
二、代码部分
1、全局变量
1 static String hws = "";
2 static int num = 0;
3 static String[] hw;
2、创建数组用于保存回文
复制代码
1 /**
2 * 创建数组保存所有的回文
3 *
4 * @return 返回一个String类型的数组
5 */
6 public static String[] createHw() {
7 return new String[num];
8 }
复制代码
3、将hws字符串更改为空字符
1 /**
2 * 将hws字符串更改为空字符
3 */
4 public static void hwsClose() {
5 hws = "";
6 }
4、判断该字符串中存在的回文的数量
复制代码
1 /**
2 * 判断该字符串中存在的回文的数量
3 *
4 * @param c
5 * 数组c ，c是用户输入的字符串转换为单个字符组成的数组
6 * @return
7 */
8
9 public static int judgeNumber(char[] c) {
10 for (int i = 0; i c.length - 1; i++) {
11 if (c[i] == c[i + 1]) {
12 num++;
13 }
14 }
15 return num;
16 }
复制代码
5、第一次判断字符串中前后的数是否存在相同
复制代码
1 /**
2 * 第一次判断字符串中前后的数是否存在相同
3 *
4 * @param c
5 * 数组c ，c是用户输入的字符串转换为单个字符组成的数组
6 */
7
8 public static void judge(char[] c) {
9 judgeNumber(c);
10 if (num != 0) {
11 hw = createHw();
12 for (int i = 0; i c.length - 1; i++) {
13 if (c[i] == c[i + 1]) {
14 hws = hws + c[i];
15 judge2(c, i, i + 1);
16 hw[--num] = hws;
17 hwsClose();
18 }
19 }
20 } else {
21 System.out.println("该字符串没有回文");
22 }
23 }
复制代码
6、进行二次判断以当前相同的字符为起点，分别以前下标向前和该后下标向后进行比较()
复制代码
1 /**
2 * 进行二次判断以当前相同的字符为起点，分别以前下标向前和该后下标向后进行比较()
3 *
4 * @param c
5 * 数组c ，c是用户输入的字符串转换为单个字符组成的数组
6 * @param i
7 * 数组前一个下标，该下标和后一个进行比较并且相同
8 * @param k
9 * 数组后一个下标，该下标和前一个进行比较并且相同
10 */
11
12 public static void judge2(char[] c, int i, int k) {
13 if (i - 1 = 0 k + 1 c.length) {
14 if (c[i - 1] == c[k + 1]) {
15 hws = hws + c[i - 1];
16 judge2(c, i - 1, k + 1);
17 }
18 }
19 }
复制代码
7、输出所得的回文
复制代码
1 /**
2 * 获取所得的回文
3 *
4 * @param c
5 * 数组c ，c是用户输入的字符串转换为单个字符组成的数组
6 */
7
8 public static void outPalindrome(char[] c) {
9 judge(c);
10 if (hw!=null) {
11 for (int i = 0; i hw.length; i++) {
12 System.out.println(reverse(hw[i])+hw[i]);
13 }
14 } else {
15 System.out.println("没有回文2");
16 }
17 }
复制代码
8、将最长的回文输出
复制代码
1 /**
2 * 将最长的回文输出
3 *
4 */
5
6 public static void longestPalindromes() {
7 String longest = null;
8 if (hw!=null) {
9 if (hw.length == 1) {
10 System.out.println(reverse(hw[0])+hw[0]);
11 } else {
12 for (int i = 0; i hw.length - 1; i++) {
13 for (int j = 0; j hw.length - 1 - i; j++) {
14 if (hw[j].length() hw[j + 1].length()) {
15 longest = hw[j + 1];
16 hw[j + 1] = hw[j];
17 hw[j] = longest;
18 }
19 }
20 }
21 for (int i = 0; i hw.length - 1; i++) {
22 if (hw[hw.length - 1].length() == hw[hw.length - i - 1].length()) {
23 System.out.println(reverse(hw[hw.length - i - 1])+hw[hw.length - i - 1]);
24 }
25 }
26 }
27 } else {
28 System.out.println("没有回文3");
29 }
30 }
java 编写一个方法,找出一个字符串中最长的回文子串
Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import java.util.ArrayList;
import java.util.List;
public class Palindrome {
/* 找出一个字符串中最长的回文子串
* 从字符串中第i个字符开始的所有非空回文子串的个数, 记作为Ci. 此方法的复杂度为
* O(C1 + C2 + ... + Cn)
* 当字符串中任意两个非空回文子串的起始位置不同时, C1 = C2 = ... = Cn = 1, 复杂度为O(N);
* 当字符串所有字符均为同一字符时, Ci = n - i, 此时复杂度为O(N*N);
* 在多数情况下, 此方法的复杂度远低于O(N*N).
*/
public ListString getLongestPalindrome(String theString) {
int strLen = theString.length();
ListString results = new ArrayListString(strLen);
if (strLen == 0) {
return results;
}
// 从第i个位置开始的所有回文子串的结束位置.
int[] endIndice = new int[strLen + 1];
// endIndice中有效数据的长度.
int numberOfPalindromes = 1;
// 最长回文子串的长度. 对于非空串至少可以找到长度为1的回文子串.
int maxLen = 1;
results.add(theString.substring(strLen - 1));
// 计算从第i个位置开始的所有回文子串. 这样的子串分为三种:
// 1. 在从第i+1个位置开始的回文子串的基础上, 在两端加上相同的字符;
// 2. 长度为1的回文子串;
// 3. 空串.
for (int i = strLen - 2; i = 0; i--) {
int j = 0, k = 0;
while (j numberOfPalindromes) {
if (theString.charAt(i) == theString.charAt(endIndice[j])) {
endIndice[k] = endIndice[j] + 1;
int newLength = endIndice[k] - i;
if (newLength = maxLen) {
if (newLength maxLen) {
maxLen = newLength;
results.clear();
}
results.add(theString.substring(i, endIndice[k]));
}
if (endIndice[k] strLen) {
k++;
}
}
j++;
}
// 加入长度为1的子串
endIndice[k++] = i + 1;
if (maxLen == 1) {
results.add(theString.substring(i, i + 1));
}
// 加入空串
endIndice[k++] = i;
numberOfPalindromes = k;
}
return results;
}
public static void main(String[] args) {
Palindrome p = new Palindrome();
printList(p.getLongestPalindrome("gabcecbaefd"));
printList(p.getLongestPalindrome("bbcbaefccfg"));
printList(p.getLongestPalindrome("aaaaaaaaaaa"));
printList(p.getLongestPalindrome("abcdefghijk"));
printList(p.getLongestPalindrome("abcdeeddejk"));
printList(p.getLongestPalindrome(""));
}
public static void printList(List? extends Object list) {
System.out.println("**************************");
System.out.println(list.size() + " result(s):");
for (Object o : list) {
System.out.println(o);
}
}
}
java最长回文串的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java最长回文子串、java最长回文串的信息别忘了在本站进行查找喔。