daily pastebin goal
8%
SHARE
TWEET

Untitled

a guest Jan 23rd, 2019 74 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <bits/stdc++.h>
  2.  
  3. using namespace std;
  4.  
  5.  
  6. /*
  7. Quando fazermos alguma estrutura dinâmica, isso quer dizer que você tera que utilizar apenas ponteiros,
  8. e Nós, já que cada Nó guarda dados, e cada Nó tem um ponteiro apontando para o proximo Nó, pois para
  9. conseguir acessar outros elementos é necessario fazer isso para não perdermos os outros elementos independentimente
  10. da estrutura que você esteja usando.
  11. */
  12. // O pai aponta pro item topo da pilha.
  13. class No{
  14.     public:
  15.         char item;
  16.         No *proximo;
  17. };
  18.  
  19. class PilhaDinamica{
  20.     public:
  21.         No *topo;
  22.         int pilha_tamanho;
  23.        
  24.         // Construtor
  25.         PilhaDinamica(){
  26.             topo = NULL;
  27.             pilha_tamanho = 0; 
  28.         }
  29.        
  30.         // Verificando se a pilha esta vazia
  31.         bool vazia(){
  32.             if (topo == NULL){
  33.                 return true;
  34.             }
  35.             else
  36.             {
  37.                 return false;
  38.             }
  39.         }
  40.        
  41.         // Verificando o tamanho da pilha
  42.         int tamanho_pilha(){
  43.             No *aux = topo;
  44.             while(aux != NULL){
  45.                 pilha_tamanho++;
  46.                 aux = aux->proximo;
  47.             }
  48.             return pilha_tamanho;
  49.         }
  50.        
  51.         /*
  52.         Esse metodo push você insere elementos a pilha, o primero passo é alocar memoria dinamicamenta,
  53.         em um ponteiro para ter um lugar para se armazenar.
  54.         */
  55.         bool push(char elemento){
  56.             No *no_filho = new No();
  57.            
  58.             if (no_filho == NULL){ // Caso o OS não forneça memoria ele apontara para NULL e retornata false
  59.                 return false;
  60.             }
  61.             else
  62.             {  
  63.                 /*
  64.                 O no_filho tem memoria alocada dinamicamente, postanto sempre que o metodo for chamado, sera criado
  65.                 um local na memoria com esse Nó com seus dados dentro, esse Nó provem de uma class, portanto o mesmo
  66.                 funcionaria com o new já que ele sempre cria um novo endereço para tal objeto, portanto alocando
  67.                 dinamicamente.
  68.                 */
  69.                 no_filho->item = elemento;
  70.                 no_filho->proximo = topo;
  71.                
  72.                 topo = no_filho;
  73.                 return true;
  74.             }
  75.         }
  76.        
  77.         // Metodo pop para retornar e remover o ultimo elemento da pilha,
  78.         // no caso oque esta no topo.
  79.         char pop(){
  80.             No *TEMP;
  81.            
  82.             if (vazia()){
  83.                 return false;
  84.             }
  85.             else
  86.             {
  87.                 char elemento = topo->item;
  88.                 TEMP = topo;
  89.                 topo = topo->proximo;
  90.                 free(TEMP);
  91.                 pilha_tamanho--;
  92.                 return elemento;
  93.             }
  94.         }
  95.        
  96.         // Metodo para verificar o elemento que esta no top da pilha.
  97.         char espiando_topo(){
  98.             if (vazia()){
  99.                 return '0';
  100.             }
  101.             else
  102.             {
  103.                 return topo->item;
  104.             }
  105.            
  106.         }
  107.    
  108. };
  109.  
  110. bool verificando(string elemento){
  111.     PilhaDinamica *referencia_pilhaDinamica = new PilhaDinamica();
  112.    
  113.     int indice_elemento = 0;
  114.    
  115.     while(elemento[indice_elemento]){
  116.        
  117.         if ((elemento[indice_elemento] == '(') || (elemento[indice_elemento] == '[') || (elemento[indice_elemento] == '{')){
  118.             referencia_pilhaDinamica->push(elemento[indice_elemento]);
  119.         }
  120.         else
  121.         {
  122.             if (elemento[indice_elemento] == ')'){
  123.                 if (referencia_pilhaDinamica->espiando_topo() != '('){
  124.                     return false;  
  125.                 }
  126.                 else
  127.                 {
  128.                     referencia_pilhaDinamica->pop();
  129.                 }
  130.                
  131.             }
  132.             else if(elemento[indice_elemento] == '}'){
  133.                 if (referencia_pilhaDinamica->espiando_topo() != '{'){
  134.                     return false;
  135.                 }
  136.                 else
  137.                 {
  138.                     referencia_pilhaDinamica->pop();
  139.                 }
  140.                    
  141.             }
  142.             else if(elemento[indice_elemento] == ']'){
  143.                 if (referencia_pilhaDinamica->espiando_topo() != '['){
  144.                     return false;
  145.                 }
  146.                 else
  147.                 {
  148.                     referencia_pilhaDinamica->pop();
  149.                 }  
  150.             }  
  151.         }
  152.     indice_elemento++;
  153.     }
  154.     return referencia_pilhaDinamica->vazia();
  155. }
  156.  
  157. void resultado(string elemento){
  158.     if (verificando(elemento) == true){
  159.         cout << "\n" << elemento << " <- CORRETO!" <<"\n";
  160.     }
  161.     else
  162.     {
  163.         cout << "\n" << elemento << " <- ERRADO!" <<"\n";
  164.     }
  165. }
  166.  
  167.  
  168. void questao02(string frase){
  169.     PilhaDinamica *pilha = new PilhaDinamica;
  170.  
  171.     bool errado = false;
  172.     for(int i = 0; i < frase.length(); i++){
  173.         pilha->push(frase[i]);
  174.     }
  175.  
  176.     for(int i = 0; i < frase.length(); i++){
  177.         if (pilha->pop() != frase[i])
  178.         {
  179.             errado = true;
  180.             break;
  181.         }
  182.     }
  183.  
  184.     if (errado)
  185.     {
  186.         cout << "Nao é igual ao inverso" << endl;
  187.     }
  188.     else{
  189.         cout << "É igual ao inverso" << endl;
  190.     }
  191. }
  192.  
  193. int main()
  194. {
  195.     /*
  196.     string a = ("{g}[(hj)]k");    
  197.     resultado(a);
  198.    
  199.     string b = ("a + [b + (2*c*d + 2)]");  
  200.     resultado(b);
  201.    
  202.     string c = ("a + b + (2*c*d + 2)]");
  203.     resultado(c);
  204.    
  205.     string d = ("a +( b + 2*c*d + 2)]");
  206.     resultado(d);
  207.    
  208.     string f = ("a +( b + 2*c*d + 2))");
  209.     resultado(f);
  210.    
  211.     string g = ("a + [b + (2*c*d + 2])");
  212.     resultado(g);
  213.    
  214.     string h = ("a + [b + (2*c*d + 2");
  215.     resultado(h);
  216.    
  217.     string i = ("a + b + 2*c*d + 2])");
  218.     resultado(i);
  219.    
  220.     string j = ("a + [b + [2*c*d + 2]]");
  221.     resultado(j);
  222.    
  223.     string l = ("{[a + b] + ({2*c*d} + 2)}");
  224.     resultado(l);
  225.     */
  226.  
  227.    questao02("aina");
  228.  
  229. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top