回文算法复杂度

‘壹’ C++回文数的问题~\(≧▽≦)/~啦啦啦

#include<iostream>
#include<cstdio>
usingnamespacestd;
voidmain()
{
	charstr[10000];
	charb[10000];
	boolflag=true;
	inti,j,m;
	m=0;
	i=j=0;
	gets(str);//读入字符串
	for(i=0;i<strlen(str);i++)
	{
		if(str[i]>='A'&&str[i]<='Z')
		{
			b[j]=str[i]+32;//赋值用=号
			j++;
			m+=1;
		}
		else
			if(str[i]>='a'&&str[i]<='z')
			{
				b[j]=str[i];//赋值用=号
				j++;
				m+=1;
			}
			
	}
	for(j=0;j<m;j++)
	{
		if(b[j]!=b[m-1-j])
		{flag=false;}
	}
	if(!flag)
	{	cout<<"N";}
	else
	{cout<<"Y";}
}

‘贰’ 如何判断一个字符串是不是回文串 时间复杂度o 空间复杂度o

对于单链表来说，判断回文最简单的方法就是遍历链表，将链表中的元素复制到数组中，然后对数组进行判断是否是回文数组，但是这不符合O(1)的空间复杂度。

由于空间复杂度的要求，需要就地操作链表，不能开辟多余的空间来进行处理，因此引入快慢指针来进行操作。

快慢指针： slow 和 fast，每次slow指针前进一步，fast指针前进两步，当遇到指针为空时说明遍历链表完成，此时也就可以找到链表的中心位置。

注意，由于链表的长度可能是奇数也可能是偶数，因此应该做一个判断。

找到链表的中心后，把链表的后半部分进行就地逆转，就地逆转是采用头插法即可。

后半部分逆转完成后，将链表的前半部分和后半部分一次比较，即可判断是否是回文。

实现代码如下：

链表类定义：

class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
}

}

链表就地反转：

public static ListNode reverseList(ListNode head){
ListNode ptr = head, ptr2 = head;
ListNode fast = head.next;
while(fast!=null){

//头插法
ptr = fast.next;
fast.next = head;
head = fast;
fast = ptr;
}

//反转完成后将原头指针的next设置为null
ptr2.next = null;
return head;
}

判断链表是否是回文：

1 public static boolean isPalindrome(ListNode head){
2 if(head==null || head.next==null){
3 return true;
4 }
5 //建立快慢指针，寻找链表中心
6 ListNode slow = head;
7 ListNode fast = head;
8 while(fast!=null && fast.next!=null){
9 slow = slow.next;
10 fast = fast.next.next;
11 }
12
13 if(fast == null){
14 //偶数个元素(进行链表反转)
15 ListNode ptr = slow, ptr2 = slow;
16 ListNode fast1 = slow.next;
17 while(fast1!=null){
18 ptr = fast1.next;
19 fast1.next = slow;
20 slow = fast1;
21 fast1 = ptr;
22 }
23 ptr2.next = null;
24 }else{
25 //奇数个元素(进行链表反转)
26 ListNode ptr = slow.next,ptr2 = slow.next;
27 ListNode fast1 = slow.next.next;
28 while(fast1 != null){
29 ptr = fast1.next;
30 fast1.next = slow.next;
31 slow.next = fast1;
32 fast1 = ptr;
33 }
34 ptr2.next = null;
35 slow = slow.next;
36 }
37
38 while(slow!=null){
39 if(head.val!=slow.val)
40 return false;
41 slow = slow.next;
42 head = head.next;
43 }
44 return true;
45 }
46
47 }

‘叁’ 设计算法，判断该字符串的前n个字符组成的是否为回文，且使算法时间复杂度最小。 （注：123321）

public class test {
public void fun(String str , Integer target){
String rString = str.substring(0, target);
Integer length = rString.length();
char[] c = str.substring(0 , target).toCharArray();
int flag = 0;
if((length >= target) && (target%2 == 0)){
for(int i = 0 ; i < length/2 ; i++){
if(c[i] != c[length-i-1]){
++flag;
System.out.println("不是回文");
break;
}
}
if(flag == 0){
System.out.println("是回文");
}
}else{
System.out.println("指定的参数不符合规范,应该为偶数");
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new test().fun("abcdeedcbaaaa", 10);
}

}

‘肆’ 回文数的回文数算法

随意找一个十进制的数，把它倒过来成另一个数，再把这两个数相加，得一个和数，这是第一步;然后把这个和数倒过来，与原来的和数相加，又得到一个新的和数，这是第二步。照此方法，一步步接续往下算，直到出现一个“回文数”为n。例如:28+82=110,110+011=121，两步就得出了一个“回文数”。如果接着算下去，还会得到更多的“回文数”。这个过程称为“196算法”。

‘伍’ 利用Stack类和Queue类实现判断一个字符是否为回文的算法。所谓回文就是正读和反读都相同的序列

双端队列，读入后左右两边出队进行比较，如果有不同返回假，最后队列中只有一个元素或空时返回真。时间复杂度O(n/2)。代码是爪机所以没法码了。

‘陆’ C语言回文算法

我前几天刚好做过类似题，这里才3位数比较简单，已经调试并运行过了，绝对准确！
main()
{
int
n,i,a[5];
for(i=10;i<=200;i++)/*回文数至少为两位数，即大于9*/
{
if(i/100>=1)/*三位数得情况*/
{
a[0]=i/100;/*百位数*/
a[1]=i%100/10;
a[2]=i%10;
if(a[0]==a[2])printf("\n%d",i);
}
else
/*两位数得情况*/
{
a[0]=i/10;
a[1]=i%10;
if(a[0]==a[1])printf("\n%d",i);
}
}
}

‘柒’ 关于回文算法

这个函数不对奇偶长度的字符串都通用的 我给你稍微改了下 空都补上了
int IsHuiWen(char *s)
{
SeqStack T; // 定义一个顺序栈T
char t;
Init Stack(T); //初始化栈
l=strlen(s); //变量l的值为字符串长度
for(i=0;i <= l/2;i++) Push(&T,s[i]); //i<=l/2和后面的push 作用就是把字符串前半截压入栈结构
while(!EmptyStock(&T))
{
t=Pop(&T); //让元素出栈并且赋给t 用来和后面的字符比较
if(t != s[l-i]) //如果中间的2个字符不相同就返回0
{return 0;}
--i; //如果第一次比较相同就比较第二次 从中间向两边比较直到栈为空
} // 这个后面的while是多余的 没用
return 1;//比较完后都不返回0就是回文 返回1
}

‘捌’ 这是100000000内求回文素数的算法，谁能帮忙优化下~

//回文
int palindromic( unsigned long dat )
{
unsigned char buf[20]; //64位2进制最长20位10进制
int i,len;
//10进制取出
len = 0;
while( dat > 0 && len < sizeof(buf) )
{
buf[ len++ ] = dat % 10;
dat /= 10;
}
//判断回文
i = 0;
while( i < len )
if( buf[ i++ ] != buf[ --len ] )
return 0;
return 1;
}

//质数(素数)
int prime( unsigned long dat )
{
unsigned long k;
if( !(dat & 0x01 ) && dat != 2 ) //偶数非质数(2例外)
return 0;
for( k=3; k < dat/2; k+=2 ) //因子为偶的情况已经在上一句程序剔除
{
if( !(dat % k ))
return 0;
}
return 1; //质数
}

int main()
{
unsigned long i;
for(i=1; i<9999999; ++i)
if( prime(i) )
if( palindromic(i) )
printf("%d,", i);
}

‘玖’ pascal 回文数问题

先把符号保存好，要连位置也要保存。再求s1的倒序s2，求s1与s2的lcs，而此时的lcs即是回文数了，求的同时要用标记数组做好标记。输出时结合先前保存好的字符输出就行了。时间复杂度是O(n^2)，要看你的除去符号之后的长度了。

‘拾’ 什么是回文数算法

回文数算法 c语言和java语言实现回文数算法的区别
问题:
将所有回文数从小到大排列,求第N个回文数。
一个正数如果顺着和反过来都是一样的(如13431,反过来也是...