Question

所以我编写了一个程序，将堆栈类实现为链表。到目前为止，程序接受用户输入的任何字符串，并成功将每个字符串放入堆栈中（至少我认为它确实如此）。我需要知道的是我如何通过每个字符并确定字符串是否是回文。有小费吗？

到目前为止，这是我的代码：

主：

#include <iostream>
#include <cstdlib>
#include <string>
#include "stack.h"

using namespace std;

int main(){
Stack o;
cout << "Enter a string" << endl;
string word;
cin >> word;
o.divide_String(word);

o.Print();

return 0;
}

部首：

#ifndef STACKS_H
#define STACKS_H
#include <string>

using namespace std;

class Stack{
private:

    typedef struct item{    
        char letter;
        item* prev;
    }* itemPtr;
    itemPtr stackPtr;   


public:
    Stack();    
    void Push(char letter); 
    void Pop(); 
    void ReadItem(item* r); 
    void Print();   
    void Stack::divide_String(string s);
    ~Stack();   

};

#endif

功能定义：

#include <cstdlib>
#include <iostream>
#include "stack.h"




using namespace std;

Stack::Stack(){
    stackPtr = NULL;
}

Stack::~Stack(){    
    itemPtr p1;
    itemPtr p2;

    p1 = stackPtr;  
    while(p1 != NULL){   
        p2 = p1;        
        p1 = p1->prev;  
        delete p2;      
    }
}

void Stack::Push(char letter){
    itemPtr n = new item;       
    n->letter = letter;         

    if(stackPtr == NULL){       
        stackPtr = n;           
        stackPtr->prev = NULL;  
    }
    else{                      
        n->prev = stackPtr;
        stackPtr = n;
    }
}

void Stack::Pop(){              
    if(stackPtr == NULL){       
        cout << "There is nothing on the stack." << endl;
    }
    else{       
        itemPtr p = stackPtr;   
        ReadItem(p);            
        stackPtr = stackPtr->prev;  
        p->prev = NULL;         
        delete p;               
    }
}

void Stack::ReadItem(item* r){  
    cout << r->letter;
}

void Stack::Print(){
    itemPtr x = stackPtr;   
    cout << "Current Stack: " << endl;
    while(x != NULL){       
        ReadItem(x);        
        x = x->prev;
        cout << endl;
    }
    cout << endl;
}

void Stack::divide_String(string s){
    for(char &c : s){
        Push(c);
    }

}

Answer 1

以下是一些指示：

这与使用堆栈验证表达式中的括号没有什么不同。
回文中的一半字符应与另一半完全匹配。由于堆栈是LIFO，因此这种比较变得更加容易。
如果字符串中有奇数个字符，您需要考虑会发生什么，因此不会给您一个干净的一半

希望这有帮助。

PS：没有放下任何代码，因为我鼓励你尝试解决问题。有几种不同的方法可以做到。

需要修改堆栈/链接列表程序以确定单词是否是回文

1 个答案: