java — codestacker

you are in: codestacker → codes [RSS] → tag: java [RSS]

estrutura de dados

exercícios sobre pilhas e filas

   1  public class exercicio_pilha_fila {
   2  
   3      int topo = 0;
   4      int maxPilha = 0;
   5      int pilha[] = new int[maxPilha];
   6      int comeco = 0;
   7      int fim = 0;
   8      int total = 0;
   9      int maxFila = 0;
  10      int[] fila = new int[maxFila];
  11      
  12  	// 15/03/2010
  13      // Desenvolva um método para remover uma determinada quantidade de dados
  14   	// em uma pilha estática. Caso nao haja inserida, remova o possivel
  15      public void remove() {
  16          if (topo == 0) {
  17              System.out.println("Pilha Vazia");
  18          } else {
  19              int qtde = Leitura.readInteger();
  20              if (qtde > topo) {
  21                  System.out.println("Quantidade: " + (qtde - topo));
  22                  topo = 0;
  23              } else {
  24                  topo = topo - qtde;
  25              }
  26          }
  27      }
  28  
  29      // 15/03/2010
  30  	// Desenvolva um método que através de uma ED tipo pilha verifique
  31  	// se uma palavra é palíndroma. Ex.: ovo, ama, asa
  32      public void Palavra() {
  33  		if (topo == 0) {
  34  			System.out.println("Lista Vazia");
  35  		} else {
  36  			int cont = topo - 1;
  37  			int aux = 0;
  38  			while ((pilha[aux].equals(pilha[cont])) && (cont > aux)) {
  39  				cont--;
  40  				aux++;
  41  			}
  42  			
  43  			if (aux > cont) {
  44  				System.out.println("Palíndroma");
  45  			} else {
  46  				System.out.println("Não palíndroma");
  47  			}
  48  		}
  49      }
  50  
  51      // 22/03/2010
  52  	// Exemplo do caderno: Insere fila
  53      public void InsereFila() {
  54          if (total == maxFila) {
  55              System.out.println("fila cheia");
  56          } else {
  57              if (fim == maxFila) {
  58                  fim = 0;
  59                  int tes = Leitura.readInteger(" Digite algo::");
  60                  fila[fim] = tes;
  61                  fim++;
  62                  total++;
  63              }
  64          }
  65      }
  66  
  67      // 22/03/2010
  68  	// Exemplo do caderno: Remove fila
  69      public void RemovaFila() {
  70          if (total == 0) {
  71              System.out.println("Fila vazia");
  72          } else {
  73              if (comeco == maxFila) {
  74                  comeco = 0;
  75              }
  76  			comeco++;
  77              total--;
  78          }
  79      }
  80  
  81      // 24/03/2010 
  82  	// Considere 2 estruturas de fila estática. Verifica se 
  83  	// ambas sequências de remoção e quantidade são iguais
  84      public void Verifica_Igualdade() {
  85  		if (total1 != total2) {
  86  			System.out.println("Tamanhos diferentes");
  87  		} else {
  88  			if (com1 != max) {
  89  				int aux1 = com1;
  90  			} else {
  91  				int aux1 = 0;
  92  			}
  93  			
  94  			if (com2 != max) {
  95  				int aux2 = com2;
  96  			} else {
  97  				int aux2 = 0;
  98  			}
  99  			
 100  			int cont = 0;
 101  			while ((cont != total1) && (fila1[aux1] == fila2[aux2])) {
 102  				aux1++;
 103  				aux2++;
 104  				
 105  				if (aux1 == max) {
 106  					aux1 = 0;
 107  				}
 108  				if (aux2 == max) {
 109  					aux2 = 0;
 110  				}
 111  				cont++;
 112  			}
 113  			
 114  			if (cont == total) {
 115  				System.out.println("Filas iguais");
 116  			} else {
 117  				System.out.println("Filas diferentes");
 118  			}
 119  		}
 120      }
 121  
 122      // 24/03/2010 
 123  	// Desenvolva um método para verificar qual posição
 124  	// da fila um determinado valor foi encontrado
 125      public void LocalizaPosicao() {
 126          if (total == 0) {
 127              System.out.println("Fila vazia");
 128          } else {
 129              int valor = Leitura.readInteger("Digite valor a ser localizado: ");
 130              if (comeco == maxFila) {
 131                  int aux = 0;
 132              } else {
 133                  int aux = comeco;
 134                  int cont = 0;
 135                  while ((cont != total) && (valor != fila[aux])) {
 136                      aux++;
 137                      cont++;
 138                      if (aux == maxFila) {
 139                          System.out.println("Não encontrado");
 140                      } else {
 141                          System.out.println("Encontrado:  " + (cont + 1));
 142                      }
 143                  }
 144              }
 145          }
 146      }
 147  
 148      // 24/03/2010     
 149  	// Crie uma ED fila que ao receber a multiplicação dos valores cadastrados
 150  	// em 2 filas estáticas que possuem a mesma quantidade de dados
 151      public void Multiplica() {
 152          int maxFila2 = 0;
 153          int comeco2 = 0;
 154  
 155          if (total == 0) {
 156              System.out.println("fila vazia");
 157          } else {
 158              int[] fila3 = new int[total];
 159              if (comeco == maxFila) {
 160                  int aux = 0;
 161              } else {
 162                  int aux = comeco;
 163              }
 164              if (comeco2 == maxFila2) {
 165                  int aux2 = 0;
 166              } else {
 167                  int aux2 = comeco2;
 168                  int cont = 0;
 169                  while (cont != total) {
 170                      fila3[fim3] = (fila[aux] * fila2[aux2]);
 171                      aux++;
 172                      aux2++;
 173                      fim3++;
 174                      total3++;
 175                      if (aux == maxFila) {
 176                          aux = 0;
 177                      }
 178                      if (aux2 == maxFila) {
 179                          aux2 = 0;
 180                          cont++;
 181                      }
 182                  }
 183              }
 184          }
 185      }
 186  
 187      // Exemplo do caderno
 188  	// Desenvolva um método para apresentar o primeiro e o ultimo elemento da fila.
 189      public void Apresenta() {
 190          if (total == 0) {
 191              System.out.println("Fila vazia");
 192          } else {
 193              System.out.println("Começo: " + fila[comeco] + " último: " + fila[fim - 1]);
 194          }
 195      }
 196  
 197      // 31/03/2010 
 198  	// Remova os elementos de uma pilha e uma fila simultaneamente,
 199  	// enquanto ambos estruturas forem iguais
 200      public void RemovePilhaFila() {
 201          if ((topo == 0) || (total == 0)) {
 202              System.out.println("Fila ou pilha vazias");
 203          } else {
 204              while ((total > 0) && (topo > 0) && (pilha[topo - 1] == fila[comeco])) {
 205                  topo--;
 206                  comeco++;
 207                  total--;
 208  
 209                  if (comeco == maxFila) {
 210                      comeco = 0;
 211                  }
 212              }
 213          }
 214      }
 215  
 216      // 31/03/2010 
 217      // Considere uma agência de viagens, a qual trabalha com
 218   	// fila de espera. Considere o cliente cod 9783. Verifique 
 219  	// em 2 filas, as quais este cliente esta cadastrado, qual
 220  	// apresenta a maior possibilidade de conseguir a passagem
 221      public void Localiza() {
 222  		if (comeco1 == max) {
 223  			int aux1 = 0;
 224  		} else {
 225  			int aux1 = comeco1;
 226  		}
 227  		
 228  		if (comeco2 == max) {
 229  			int aux2 = 0;
 230  		} else {
 231  			int aux2 = comeco2;
 232  		}
 233  		
 234  		int cont1 = 0;
 235  		int cont2 = 0;
 236  		
 237  		while (fila1[aux1] != 9783) {
 238  			cont1++;
 239  			aux1++;
 240  			if (aux1 == max) {
 241  				aux1 = 0;
 242  			}
 243  		}
 244  		
 245  		while (fila2[aux2] != 9783) {
 246  			cont2++;
 247  			aux2++;
 248  			if (aux2 == max) {
 249  				aux2 = 0;
 250  			}
 251  		}
 252  		
 253  		if (cont1 > cont2) {
 254  			System.out.println("Fila 1 menor");
 255  		} else if (cont2 < cont1) {
 256  			System.out.println ("Fila 2 menor");
 257  		} else {
 258  			System.out.println ("Tanto faz");
 259  		}
 260      }
 261  
 262      // 31/03/2010 
 263      // Considere uma pilha a qual foi inserida de forma intermediária valores
 264  	// positivos e negativos altere a ED de forma a possuir somente os 
 265  	// valores positivos. Não há a necessidade de manter a pilha original
 266      public void PilhaPositiva() {
 267          if (topo == 0) {
 268              System.out.println("Pilha esta vazia!!");
 269          } else {
 270  			int PilhaN = new Int[(topo/2) + 1];
 271  			int TopoN = 0;
 272  			
 273  			while (TopoN > 0) {
 274  				if (pilha[topo - 1] > 0) {
 275  					PilhaN[TopoN] = pilha[topo -1];
 276  					TopoN++;
 277  				}
 278  				topo--;
 279  			}
 280  		}
 281      }
 282  
 283  	// Outro semestre
 284      // Desenvolva um método para remover com exceção do 
 285  	// primeiro, todos os outros elementos da fila
 286      public void RestaUm() {
 287          if (total == 0) {
 288              System.out.println("fila vazia");
 289          } else {
 290              total = 1;
 291              comeco = fim - 1;
 292          }
 293      }
 294  
 295      // Outro semestre
 296  	// Crie um método para apresentar todos os dados
 297  	// inseridos em uma fila (do primeiro ao ultimo)
 298      public void ApresentaTodos() {
 299          if (total == 0) {
 300              System.out.println("Fila vazia");
 301          } else {
 302              int aux = comeco;
 303              int cont = 0;
 304  
 305              while (cont != total) {
 306                  if (aux == maxFila) {
 307                      aux = 0;
 308  				}
 309                  System.out.println("Retorno:  " + fila[aux]);
 310                  aux++;
 311                  cont++;
 312              }
 313          }
 314      }
 315  
 316  	// Outro semestre
 317  	// Se pilha e fila são formas de listas por que existem especifidades para ambas?
 318  	// Porque existem situações computacionais que exigem restrições.
 319  	// Ex. Pilha: CTRL + Z, voltar do browser, recurvidade.
 320  	// Ex. Fila: Impressora
 321  
 322      // Outro semestre
 323  	// Desenvolva um método para preencher todas alocacoes vazias 
 324  	// de uma ED tipo pilha com um determinado valor digitado pelo usuário
 325      public void PreencherPilha() {
 326          if (total == maxPilha) {
 327              System.out.println("Pilha vazia");
 328          } else {
 329              int texto = Leitura.readInteger(" Digite algo::");
 330  
 331              while (topo < maxPilha) {
 332                  pilha[topo] = texto;
 333                  topo++;
 334              }
 335          }
 336      }
 337  
 338      // Outro semestre
 339  	// Crie um método para realizar o backup de uma lista ED tipo fila
 340      public void BackupFilaOutro() {
 341          if (total == 0) {
 342              System.out.println("Fila vazia");
 343          } else {
 344              int filaBackup[] = new int[total];
 345              int aux = comeco;
 346              int totalBackup = 0;
 347          	int fimBackup = 0;
 348              
 349  			while (totalBackup != total) {
 350                  filaBackup[totalBackup] = fila[aux];
 351                  totalBackup++;
 352                  aux++;
 353                  fimBackup++;
 354  
 355                  if (aux == maxFila) {
 356                      aux = 0;
 357                  }
 358                  int comecoBackup = 0;
 359              }
 360          }
 361      }
 362  
 363      // Outro semestre
 364  	// Desenvolva um método para apresentar na sequência de remoção
 365  	// todos os dados inseridos em uma ED tipo fila estática
 366      public void apresentaFila() {
 367          if (total == 0) {
 368              System.out.println("Fila vazia");
 369          } else {
 370              int cont = comeco;
 371              int aux = 0;
 372  
 373              while (aux != total) {
 374                  if (cont == maxFila) {
 375                      cont = 0;
 376                      System.out.println("Apresenta Fila" + fila[cont]);
 377                      cont++;
 378                      aux++;
 379                  }
 380              }
 381          }
 382      }
 383  }

public class exercicio_pilha_fila {

    int topo = 0;
    int maxPilha = 0;
    int pilha[] = new int[maxPilha];
    int comeco = 0;
    int fim = 0;
    int total = 0;
    int maxFila = 0;
    int[] fila = new int[maxFila];
    
	// 15/03/2010
    // Desenvolva um método para remover uma determinada quantidade de dados
 	// em uma pilha estática. Caso nao haja inserida, remova o possivel
    public void remove() {
        if (topo == 0) {
            System.out.println("Pilha Vazia");
        } else {
            int qtde = Leitura.readInteger();
            if (qtde > topo) {
                System.out.println("Quantidade: " + (qtde - topo));
                topo = 0;
            } else {
                topo = topo - qtde;
            }
        }
    }

    // 15/03/2010
	// Desenvolva um método que através de uma ED tipo pilha verifique
	// se uma palavra é palíndroma. Ex.: ovo, ama, asa
    public void Palavra() {
		if (topo == 0) {
			System.out.println("Lista Vazia");
		} else {
			int cont = topo - 1;
			int aux = 0;
			while ((pilha[aux].equals(pilha[cont])) && (cont > aux)) {
				cont--;
				aux++;
			}
			
			if (aux > cont) {
				System.out.println("Palíndroma");
			} else {
				System.out.println("Não palíndroma");
			}
		}
    }

    // 22/03/2010
	// Exemplo do caderno: Insere fila
    public void InsereFila() {
        if (total == maxFila) {
            System.out.println("fila cheia");
        } else {
            if (fim == maxFila) {
                fim = 0;
                int tes = Leitura.readInteger(" Digite algo::");
                fila[fim] = tes;
                fim++;
                total++;
            }
        }
    }

    // 22/03/2010
	// Exemplo do caderno: Remove fila
    public void RemovaFila() {
        if (total == 0) {
            System.out.println("Fila vazia");
        } else {
            if (comeco == maxFila) {
                comeco = 0;
            }
			comeco++;
            total--;
        }
    }

    // 24/03/2010 
	// Considere 2 estruturas de fila estática. Verifica se 
	// ambas sequências de remoção e quantidade são iguais
    public void Verifica_Igualdade() {
		if (total1 != total2) {
			System.out.println("Tamanhos diferentes");
		} else {
			if (com1 != max) {
				int aux1 = com1;
			} else {
				int aux1 = 0;
			}
			
			if (com2 != max) {
				int aux2 = com2;
			} else {
				int aux2 = 0;
			}
			
			int cont = 0;
			while ((cont != total1) && (fila1[aux1] == fila2[aux2])) {
				aux1++;
				aux2++;
				
				if (aux1 == max) {
					aux1 = 0;
				}
				if (aux2 == max) {
					aux2 = 0;
				}
				cont++;
			}
			
			if (cont == total) {
				System.out.println("Filas iguais");
			} else {
				System.out.println("Filas diferentes");
			}
		}
    }

    // 24/03/2010 
	// Desenvolva um método para verificar qual posição
	// da fila um determinado valor foi encontrado
    public void LocalizaPosicao() {
        if (total == 0) {
            System.out.println("Fila vazia");
        } else {
            int valor = Leitura.readInteger("Digite valor a ser localizado: ");
            if (comeco == maxFila) {
                int aux = 0;
            } else {
                int aux = comeco;
                int cont = 0;
                while ((cont != total) && (valor != fila[aux])) {
                    aux++;
                    cont++;
                    if (aux == maxFila) {
                        System.out.println("Não encontrado");
                    } else {
                        System.out.println("Encontrado:  " + (cont + 1));
                    }
                }
            }
        }
    }

    // 24/03/2010     
	// Crie uma ED fila que ao receber a multiplicação dos valores cadastrados
	// em 2 filas estáticas que possuem a mesma quantidade de dados
    public void Multiplica() {
        int maxFila2 = 0;
        int comeco2 = 0;

        if (total == 0) {
            System.out.println("fila vazia");
        } else {
            int[] fila3 = new int[total];
            if (comeco == maxFila) {
                int aux = 0;
            } else {
                int aux = comeco;
            }
            if (comeco2 == maxFila2) {
                int aux2 = 0;
            } else {
                int aux2 = comeco2;
                int cont = 0;
                while (cont != total) {
                    fila3[fim3] = (fila[aux] * fila2[aux2]);
                    aux++;
                    aux2++;
                    fim3++;
                    total3++;
                    if (aux == maxFila) {
                        aux = 0;
                    }
                    if (aux2 == maxFila) {
                        aux2 = 0;
                        cont++;
                    }
                }
            }
        }
    }

    // Exemplo do caderno
	// Desenvolva um método para apresentar o primeiro e o ultimo elemento da fila.
    public void Apresenta() {
        if (total == 0) {
            System.out.println("Fila vazia");
        } else {
            System.out.println("Começo: " + fila[comeco] + " último: " + fila[fim - 1]);
        }
    }

    // 31/03/2010 
	// Remova os elementos de uma pilha e uma fila simultaneamente,
	// enquanto ambos estruturas forem iguais
    public void RemovePilhaFila() {
        if ((topo == 0) || (total == 0)) {
            System.out.println("Fila ou pilha vazias");
        } else {
            while ((total > 0) && (topo > 0) && (pilha[topo - 1] == fila[comeco])) {
                topo--;
                comeco++;
                total--;

                if (comeco == maxFila) {
                    comeco = 0;
                }
            }
        }
    }

    // 31/03/2010 
    // Considere uma agência de viagens, a qual trabalha com
 	// fila de espera. Considere o cliente cod 9783. Verifique 
	// em 2 filas, as quais este cliente esta cadastrado, qual
	// apresenta a maior possibilidade de conseguir a passagem
    public void Localiza() {
		if (comeco1 == max) {
			int aux1 = 0;
		} else {
			int aux1 = comeco1;
		}
		
		if (comeco2 == max) {
			int aux2 = 0;
		} else {
			int aux2 = comeco2;
		}
		
		int cont1 = 0;
		int cont2 = 0;
		
		while (fila1[aux1] != 9783) {
			cont1++;
			aux1++;
			if (aux1 == max) {
				aux1 = 0;
			}
		}
		
		while (fila2[aux2] != 9783) {
			cont2++;
			aux2++;
			if (aux2 == max) {
				aux2 = 0;
			}
		}
		
		if (cont1 > cont2) {
			System.out.println("Fila 1 menor");
		} else if (cont2 < cont1) {
			System.out.println ("Fila 2 menor");
		} else {
			System.out.println ("Tanto faz");
		}
    }

    // 31/03/2010 
    // Considere uma pilha a qual foi inserida de forma intermediária valores
	// positivos e negativos altere a ED de forma a possuir somente os 
	// valores positivos. Não há a necessidade de manter a pilha original
    public void PilhaPositiva() {
        if (topo == 0) {
            System.out.println("Pilha esta vazia!!");
        } else {
			int PilhaN = new Int[(topo/2) + 1];
			int TopoN = 0;
			
			while (TopoN > 0) {
				if (pilha[topo - 1] > 0) {
					PilhaN[TopoN] = pilha[topo -1];
					TopoN++;
				}
				topo--;
			}
		}
    }

	// Outro semestre
    // Desenvolva um método para remover com exceção do 
	// primeiro, todos os outros elementos da fila
    public void RestaUm() {
        if (total == 0) {
            System.out.println("fila vazia");
        } else {
            total = 1;
            comeco = fim - 1;
        }
    }

    // Outro semestre
	// Crie um método para apresentar todos os dados
	// inseridos em uma fila (do primeiro ao ultimo)
    public void ApresentaTodos() {
        if (total == 0) {
            System.out.println("Fila vazia");
        } else {
            int aux = comeco;
            int cont = 0;

            while (cont != total) {
                if (aux == maxFila) {
                    aux = 0;
				}
                System.out.println("Retorno:  " + fila[aux]);
                aux++;
                cont++;
            }
        }
    }

	// Outro semestre
	// Se pilha e fila são formas de listas por que existem especifidades para ambas?
	// Porque existem situações computacionais que exigem restrições.
	// Ex. Pilha: CTRL + Z, voltar do browser, recurvidade.
	// Ex. Fila: Impressora

    // Outro semestre
	// Desenvolva um método para preencher todas alocacoes vazias 
	// de uma ED tipo pilha com um determinado valor digitado pelo usuário
    public void PreencherPilha() {
        if (total == maxPilha) {
            System.out.println("Pilha vazia");
        } else {
            int texto = Leitura.readInteger(" Digite algo::");

            while (topo < maxPilha) {
                pilha[topo] = texto;
                topo++;
            }
        }
    }

    // Outro semestre
	// Crie um método para realizar o backup de uma lista ED tipo fila
    public void BackupFilaOutro() {
        if (total == 0) {
            System.out.println("Fila vazia");
        } else {
            int filaBackup[] = new int[total];
            int aux = comeco;
            int totalBackup = 0;
        	int fimBackup = 0;
            
			while (totalBackup != total) {
                filaBackup[totalBackup] = fila[aux];
                totalBackup++;
                aux++;
                fimBackup++;

                if (aux == maxFila) {
                    aux = 0;
                }
                int comecoBackup = 0;
            }
        }
    }

    // Outro semestre
	// Desenvolva um método para apresentar na sequência de remoção
	// todos os dados inseridos em uma ED tipo fila estática
    public void apresentaFila() {
        if (total == 0) {
            System.out.println("Fila vazia");
        } else {
            int cont = comeco;
            int aux = 0;

            while (aux != total) {
                if (cont == maxFila) {
                    cont = 0;
                    System.out.println("Apresenta Fila" + fila[cont]);
                    cont++;
                    aux++;
                }
            }
        }
    }
}

created by anonymous — 06 April 2010 — get a short url — tags: java — embed

transparent jbutton

show/hide lines

   1  Insets noInsets = new Insets(0,0,0,0);
   2  ImageIcon bg = new ImageIcon("bt1.png");
   3  JButton btn = new JButton(bg);
   4  btn.setBounds(0,0,32,32);
   5  btn.setMargin(noInsets);			
   6  btn.setBorder(BorderFactory.createEmptyBorder());
   7  btn.setContentAreaFilled(false);

Insets noInsets = new Insets(0,0,0,0);
ImageIcon bg = new ImageIcon("bt1.png");
JButton btn = new JButton(bg);
btn.setBounds(0,0,32,32);
btn.setMargin(noInsets);			
btn.setBorder(BorderFactory.createEmptyBorder());
btn.setContentAreaFilled(false);

created by leozera — 03 October 2008 — get a short url — tags: java jbutton transparent — embed

codestacker

codestacker is a community to share snippets easily!

Login

Login

you are in: codestacker → codes [RSS] → tag: java [RSS]

estrutura de dados

Send this to a friend

transparent jbutton

Send this to a friend