0

所以我写了一个程序，将堆栈类实现为链表。到目前为止，该程序获取用户输入的任何字符串，并成功地将每个字符放入堆栈（至少我认为是这样）。我需要知道的是如何遍历每个字符并确定字符串是否是回文。有小费吗？

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

主要的：

#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);
    }

}
4

1 回答 1

0

这里有几个指针：

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

希望这可以帮助。

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

于 2013-10-03T04:07:34.113 回答