精华内容
下载资源
问答
  • 利用栈判断字符串回文
    2021-03-20 11:31:35

    手写栈:

    ​
    #include<iostream>
    #include<cstring>
    using namespace std;
    //搞一个栈结构体 
    struct stack{
    	int data[1000]; 
    	int top;
    };
    int main()
    {
    	//定义栈,初始化栈顶 
    	stack s;
    	s.top=0;
    	//定义并初始化需要判断的字符串 
    	char str[1000];
    	cin>>str;
    	//拿到字符串长度,并找到字符串中点 
    	int len=strlen(str);
    	int mid=len/2-1;
    	int i;
    	//循环将字符串前把那部分的值全部压入栈中 
    	for(i=0;i<=mid;i++)
    	{
    		s.data[++s.top]=str[i];
    	}//因为当字符串为偶数时,mid+1就是后半段字符串,但是为奇数时,mid+2才是后半段字符串 
    	if(len%2==1)
    	{
    		i++;
    	}
    	//开始循环依次出栈跟后续字符串比较即可 
    	while(s.top!=0)
    	{
    		if(s.data[s.top--]!=str[i++])
    		{
    			break;
    		}
    	}
    	//如果没有比较到结尾,证明字符串不是回文 
    	if(s.top==0)
    	{
    		cout<<"YES";
    	}
    	else
    	{
    		cout<<"NO";
    	}
    	return 0;
    }
    
    ​

    STL容器:

    #include<iostream>
    #include<stack>
    #include<cstring>
    using namespace std;
    int main()
    {
    	stack<int >s;
    	char str[1000];
    	cin>>str;
    	int len=strlen(str);
    	int mid=len/2-1;
    	int i;
    	for(i=0;i<=mid;i++)
    	{
    		s.push(str[i]);
    	}
    	if(len%2==1)
    	{
    		i++;
    	}
    	while(!s.empty())
    	{
    		if(s.top()!=str[i++])
    		{
    			break;
    		}
    		s.pop();
    	}
    	if(s.empty())
    	{
    		cout<<"YES";
    	}
    	else
    	{
    		cout<<"NO";
    	}
    	return 0;
    } 

     

    更多相关内容
  • 利用栈实现字符串回文算法(JAVA)

    千次阅读 2020-09-07 16:35:31
    问题 给定一个由多个a和b组成的字符串数组,字符串中有一个特殊的字符X,位于字符串的正中间,例如(aaaabbbbXabaabbbb),如何判定该字符串是否回文 ... * 判断字符串是否是回文 */ public int isPalindrom

    问题

    给定一个由多个a和b组成的字符串数组,字符串中有一个特殊的字符X,位于字符串的正中间,例如(aaaabbbbXabaabbbb),如何判定该字符串是否回文

    简单算法

    定义两个下标分别指向字符串的头和尾,每次比较两个下标位置的值是否相等,如果不相等,那么输入的
    字符串不是回文,如果相等,左边的下表加1,右边的下表减1,重复上述步骤直至两个下标都指向字符串的正中间或者确定字符串不是回文

        /**
         * 判断字符串是否是回文
         */
        public int isPalindrome(String inputStr) {
            int i = 0;
            int j = inputStr.length();
            char[] chars = inputStr.toCharArray();
            while (i < j && chars[i] == chars[j]) {
                i++;
                j--;
            }
            if (i < j) {
                System.out.println("Not a Palindrome");
                return 0;
            } else {
                System.out.println("Palindrome");
                return 1;
            }
        }
    

    利用栈判断是否回文

    1.遍历字符数组,
    2.在遍历过程中将经过的每个字符(X以前的字符)入栈
    3.对于链表的后一半,把每个元素与栈顶元素比较,如果相等,执行一次出栈操作,并且移动到下一个元素继续比较
    4.如果比较时出现不相等,那么输入的字符串不是回文
    5.继续这个过程,直至栈空或者字符串不是回文

        /**
         * 利用栈判断字符回文
         */
        public boolean isPalindromeWithStack(String inputStr) {
            char[] inputChar = inputStr.toCharArray();
            LinkedListStack s = new LinkedListStack();
            int i = 0;
            while (inputChar[i] != 'X') {
                s.push(inputChar[i]);
                i++;
            }
            i++;
            while (i < inputChar.length) {
                if (s.isEmpty())
                    return false;
                if (inputChar[i] != s.pop()) {
                    return false;
                }
                i++;
            }
            //将来
            return true;
        }
    
    展开全文
  • 本文实例讲述了JS使用栈判断给定字符串是否是回文算法。分享给大家供大家参考,具体如下: /*使用栈stack类的实现*/ function stack() { this.dataStore = [];//保存栈内元素,初始化为一个空数组 this.top = 0;/...
  • #ifndef stack__h #define stack__h #include <stdio.h> #include <stdlib.h> typedef char T;... // 表的当前位置 int max; // 表的最大长度 }; Stack* Stack_Create(int maxlen); //.
    
    #ifndef stack__h
    #define stack__h
    
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef char T; // 数据元素的数据类型
    
    struct Stack{
        T* data;   // 数据元素存储空间的开始地址
        int top;   // 栈表的当前位置
        int max;   // 栈表的最大长度
    };
    
    
    Stack* Stack_Create(int maxlen);
    // 创建栈
    
    void Stack_Free(Stack* stk);
    // 释放栈
    
    void Stack_MakeEmpty(Stack* stk);
    // 置为空栈
    
    bool Stack_IsEmpty(Stack* stk);
    // 判断栈是否空
    
    bool Stack_IsFull(Stack* stk);
    // 判断栈是否满
    
    T Stack_Top(Stack* stk);
    // 获取当前栈顶元素 
    
    T Stack_Push(Stack* stk, T e);
    // 将元素e压入栈顶
    // 返回栈顶点元素
    
    T Stack_Pop(Stack* stk);
    // 将栈顶元素出栈
    // 返回栈顶元素
    
    void Stack_Print(Stack* stk);
    // 打印栈顶到栈低的元素
    
    void Palindrome(T* str, int len);
    //  利用stack栈判断字符串是否为回文串
    //  输入参数:字符串序列,字符串长度
    //  若是回文串输出YES,否则输出NO,末尾换行
    
    #endif /* stack__h */
    
    
    
    #include <iostream>
    #include <cstring>
    #include "stack_.h"
    
    int main(int argc, const char * argv[]) {
        // insert code here...
        // std::cout << "Hello, World!\n";
        int len;
        T* str;
        scanf("%d", &len);
        str = (T*)malloc(sizeof(T)*len);
        scanf("%s", str);
        Palindrome(str, len);
        return 0;
    }
    
    
    
    #include "stack_.h"
    
    
    Stack* Stack_Create(int maxlen)
    // 创建栈
    {
        Stack* stk = (Stack*)malloc(sizeof(Stack));
        stk->data = (T*)malloc(sizeof(T)*maxlen);
        stk->max = maxlen;
        stk->top = -1;
        return stk;
    }
    
    void Stack_Free(Stack* stk)
    // 释放栈
    {
        free(stk->data);
        free(stk);
    }
    
    void Stack_MakeEmpty(Stack* stk)
    // 置为空栈
    {
        stk->top = -1;
    }
    
    bool Stack_IsEmpty(Stack* stk)
    // 判断栈是否空
    {
        return -1 == stk->top;
    }
    
    bool Stack_IsFull(Stack* stk)
    // 判断栈是否满
    {
        return stk->top == stk->max-1;
    }
    
    T Stack_Top(Stack* stk)
    // 获取当前栈顶元素
    {
        return stk->data[stk->top];
    }
    
    T Stack_Push(Stack* stk, T e)
    // 将元素e压入栈顶
    // 返回栈顶点元素
    {
        if(Stack_IsFull(stk)) {
            printf("Stack_IsFull(): stack full error when push element to the stack!\n");
            Stack_Free(stk);
            exit(0);
        }
        else{
            stk->top += 1;
            stk->data[stk->top] = e;
            return Stack_Top(stk);
        }
    }
    
    T Stack_Pop(Stack* stk)
    // 将栈顶元素出栈
    // 返回栈顶元素
    {
        if(Stack_IsEmpty(stk)) {
            printf("Stack_IsEmpty(): stack empty error when pop element of the stack top!\n");
            Stack_Free(stk);
            exit(0);
        }
        else{
            T topE = Stack_Top(stk);
            stk->top -= 1;
            return topE;
        }
    }
    
    void Stack_Print(Stack* stk)
    // 打印栈顶到栈低的元素
    {
        if (Stack_IsEmpty(stk)) {
            printf("The stack is empty.\n");
            return;
        }
        
        //printf("The stack contains: ");
        for (int i=stk->top; i>=0; i--) {
            printf("%d", stk->data[i]);
        }
        printf("\n");
        
    }
    
    void Palindrome(T* str, int len)
    //  利用stack栈判断字符串是否为回文串
    //  输入参数:字符串序列,字符串长度
    //  若是回文串输出YES,否则输出NO,末尾换行
    {
       
        if(len==1){
        	printf("YES\n");
    	}else{
    		Stack*s=Stack_Create(105);
    		if(len%2!=0){
    			for(int i=len/2;i<len;i++){
    				str[i]=str[i+1];
    			}
    		    for(int i=0;i<len-1;i++){
    		    	char st=Stack_Top(s);
    		    	if(st==str[i]){
    		    		Stack_Pop(s);
    				}else{
    					Stack_Push(s,str[i]);
    				}
    			}
    			if(Stack_IsEmpty(s)){
    				printf("YES\n");
    			}else{
    				printf("NO\n");
    			}
    		}else{
    		    for(int i=0;i<len;i++){
    		    	char st=Stack_Top(s);
    		    	if(st==str[i]){
    		    		Stack_Pop(s);
    				}else{
    					Stack_Push(s,str[i]);
    				}
    			}
    			if(Stack_IsEmpty(s)){
    				printf("YES\n");
    			}else{
    				printf("NO\n");
    			}
    		}
    			
    	}
        
    }
    
    展开全文
  • 问题给定一个由多个a和b组成的字符串数组,...如果不相等,那么输入的字符串不是回文,如果相等,左边的下表加1,右边的下表减1,重复上述步骤直至两个下标都指向字符串的正中间或者确定字符串不是回文/*** 判断字符...

    问题

    给定一个由多个a和b组成的字符串数组,字符串中有一个特殊的字符x,位于字符串的正中间,例如(aaaabbbbxabaabbbb),如何判定该字符串是否回文

    简单算法

    定义两个下标分别指向字符串的头和尾,每次比较两个下标位置的值是否相等,如果不相等,那么输入的

    字符串不是回文,如果相等,左边的下表加1,右边的下表减1,重复上述步骤直至两个下标都指向字符串的正中间或者确定字符串不是回文

    /**

    * 判断字符串是否是回文

    */

    public int ispalindrome(string inputstr) {

    int i = 0;

    int j = inputstr.length();

    char[] chars = inputstr.tochararray();

    while (i < j && chars[i] == chars[j]) {

    i++;

    j--;

    }

    if (i < j) {

    system.out.println("not a palindrome");

    return 0;

    } else {

    system.out.println("palindrome");

    return 1;

    }

    }

    利用栈判断是否回文

    1.遍历字符数组,

    2.在遍历过程中将经过的每个字符(x以前的字符)入栈

    3.对于链表的后一半,把每个元素与栈顶元素比较,如果相等,执行一次出栈操作,并且移动到下一个元素继续比较

    4.如果比较时出现不相等,那么输入的字符串不是回文

    5.继续这个过程,直至栈空或者字符串不是回文

    /**

    * 利用栈判断字符回文

    */

    public boolean ispalindromewithstack(string inputstr) {

    char[] inputchar = inputstr.tochararray();

    linkedliststack s = new linkedliststack();

    int i = 0;

    while (inputchar[i] != 'x') {

    s.push(inputchar[i]);

    i++;

    }

    i++;

    while (i < inputchar.length) {

    if (s.isempty())

    return false;

    if (inputchar[i] != s.pop()) {

    return false;

    }

    i++;

    }

    //将来

    return true;

    }

    java判断是否为回文字符串

    题目描述

    输入一段字符串序列,字符串可能包括字母,数字,标点符号等类型字符,在判断该字符序列是否为回文时,只需判断字母和数字类型,其它类型自动忽略。

    如:“a man, a plan, a canal: panama” 是一段回文字符串

    “race a car”则不是回文字符串

    实现方法

    从字符串的两端逐个进行比较,若遇到非字母或数字字符则将索引值加一或减一,如果两端字符不同,直接返回false,直到索引值在中间相遇也没有返回false则证明该字符串是回文字符串。

    public static boolean ispalindrome(string str){

    if(str.equals(""))

    return true;

    str = str.tolowercase();//将字符串的所有大写字母转小写

    int start = 0, end = str.length() - 1;

    //从字符两端分别逐个对比字符,不同则直接返回false

    while (start < end){

    //过滤掉非字母和数字字符

    while (!(str.charat(start) >= 'a' && str.charat(start) <= 'z' || str.charat(start) >= '0' && str.charat(start) <= '9'))

    start++;

    //过滤掉非字母和数字字符

    while (!(str.charat(end) >= 'a' && str.charat(end) <= 'z' || str.charat(end) >= '0' && str.charat(end) <= '9'))

    end--;

    //若字符不同,则直接返回false

    if(str.charat(start) != str.charat(end))

    return false;

    start++;

    end--;

    }

    return true;

    }

    编程判断字符串是否为回文 判断一个字符串是否是回文,例如单词‘level'

    #include

    #include

    int main()

    {

    char a[100]= {0};

    int i = 0;

    int len = 0;

    printf("please input character string:\n");

    gets(a);

    len = strlen(a); //计算输入字符串的长度;

    for(i = 0; i < (len / 2); i++) //只需要判断前一半(len/2)长度就好了

    {

    if(a[i] != a[len - 1 - i]) //判断是否为回文数;

    {

    printf("不是回文数\n");

    return 0;

    }

    }

    printf("是回文数\n");

    return 0;

    }

    到此这篇关于java中利用栈实现字符串回文算法的文章就介绍到这了,更多相关字符串回文算法内容请搜索萬仟网以前的文章或继续浏览下面的相关文章希望大家以后多多支持萬仟网!

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • @【数据结构】( 判断字符串回文) 用来实现一个表达式中的‘(’,‘[‘,’)’,’]’,’{‘,’}’是否匹配 #include<stdio.h> #include<stdlib.h> #include<iostream> #define MAXN 100 ...
  • C语言利用栈判断字符串是否为回文

    万次阅读 多人点赞 2017-11-12 09:31:01
    #include #include #define OK 1 #define ERROR 0 typedef char ElemType; typedef int Status; typedef struct Stack1 { ElemType data; struct Stack1 *next;...//初始化一个 Status Init(SqlSta
  • namespace _004_和队列实例_判断字符串是否为回文{ class Program { static void Main(string[] args) { string str = Console.ReadLine(); Stack&lt;char&gt; stack = new Stack&...
  • C语言使用判断回文字符串

    千次阅读 2020-07-07 20:01:59
    #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char str[100]; gets(str); int mid; int len = strlen(str);...//定义 int top = 0;//定义
  • Java判断字符串回文的代码实例

    千次阅读 2021-02-28 07:47:42
    首先,回文是指类似于“12345”,“abcdcba”的形式,即正念和反念都是一样的字符串判断字符串是否是回文,这边介绍2种办法1、将字符串翻转,判断翻转后的字符串和原字符串是否相等public static void main(String[]...
  • } } 利用栈判断给定的字符串是否是回文串 int ispalindrome(char str[]){ Stack S; char c; InitStack(&S); int length = strlen(str); for (int i = 0; i ; ++i) Push(&S, str[i]); for (int i = 0; i ; ++i) { ...
  • 字符串前一半入栈,然后,中元素和字符串后一半进行比较。即将第一个出栈元素和后一半串中第一个字符比较,若相等,则再出栈一个元素与后一个字符比较,……,直至空,结论为字符序列是回文。在出栈元素与串中...
  • 数据结构 —— 利用栈实现回文判断

    万次阅读 2018-10-21 22:10:00
    一、先理解什么是、什么是回文 的性质:先进后出或后进先出的特性,的实现也很简单,只需要一个一维数组和一个指向栈顶的变量top就...检查回文字符串的一个方法就是用。   二、算法实现的两个代码 #in...
  • 实现回文字符串判断

    千次阅读 多人点赞 2020-05-14 16:42:46
    实现回文字符串判断 是一种后进先出的数据结构,它只能在一段进行插入和删除操作。 例如一个字符串"12321",像这种 ,无论正读反读均相同的字符序列,就叫做回文字符串。 首先,我们需要读取这行字符串,并求...
  • 判断字符串是否为回文(C语言 顺序

    千次阅读 多人点赞 2019-10-08 22:37:16
    首先我们需要确定思路,如何用判断字符串是否为回文。 1.是先进后出 2.回文是指正读反读均相同的字符序列 从这两点很容易就可以联想到一个方法,我们先将字符串全部存进去中,再将它全部出栈,进行对比,...
  • public class stackTest { public static void main(String[] args) { // System.out.println(detect("hello"));... //判断字符串是否为回文 public static boolean detect(String s){ //初始化 MySt
  • 栈判断字符串是否为回文字符串

    千次阅读 2018-11-05 19:22:55
    #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define max 100 typedef struct{  char data[max];  int top;...s)//的创建 {  s=(Stack*)malloc(sizeof(Stack));  ...
  • 判断字符串是否回文字符串
  • 栈判断是否是回文

    千次阅读 2020-05-17 20:54:04
    栈判断是否是回文 栈:仅在表尾进行插入和删除操作的线性表。先进后出。 用例: 1.“上海自来水来自海上” 2.“1234321” 3.“123321” 4.“112233” 5.“123332” 思路:直接入栈一半的元素,若字符串...
  • 系列文章目录 ...使用栈判断一个字符串是否回文 二、c++代码 1.顺序栈 代码如下: #include<iostream> using namespace std; #define MaxSize 100 typedef char datatype; typedef struct {
  • //数据结构定义 #include<stdio.h> #include<stdlib.h> #include<string.h> #define FULL 10000 #define MAX 10000 struct elem { char d; struct elem *next; }; struct stack { ...
  • 33:判断字符串是否为回文 描述 输入一个字符串,输出该字符串是否回文回文是指顺读和倒读都一样的字符串。 输入 输入为一行字符串(字符串中没有空白字符,字符串长度不超过100)。 输出 如果字符串是回文,输出...
  • 利用栈判断一个字符串是否是回文 【问题描述】编写一个程序,判断一个字符串是否为回文;(顺读和倒读都一样的字符串称为回文)。 【输入形式】长度小于100的任意字符串 【输出形式】如果输入字符串回文,则输出...
  • java模拟实现回文串判断,适合新手学习!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,618
精华内容 1,447
热门标签
关键字:

利用栈判断字符串回文