Material: pilhas, filas e listas dinâmicas!

Programação Java
#1

Oi galera…
Procurei muito na net, mas nao encontrei!
Alguem sabe de algum site que tenha algo bem
basico sobre implementação de pilhas, filas e listas dinâmicas.

Pois os negocios de ponteiros são muito complicados, nem o professor
plantando bananeira na sala, o povo entende!

Se alguem puder me ajudar,
desde ja agradeço!

#2

Vc quer o material em java ou c++?

Pelo que vc falou no enunciano eu creio que seja c++( ponteiro ) java é ( referencia )

Não é tao basico assim mas me ajudou muito, principalmente com java.
http://www.dcc.ufmg.br/algoritmos-java/transparencias.php Vai em ESTRUTURAS DE DADOS CAPITULO 3

#3

jalmat, geralmente sites de grandes universidades possuem um material disponibilizado.Quando precisei, eu “bisbilhotei” na PUC-RIO e na UFRJ e achei coisa boa por lá.Aqui mesmo tem material interessante sobre a classe Stack do Java com muitos exemplos.Veja:
http://www.guj.com.br/posts/list/69472.java

Se pesquisar, vai encontrar bastante material de listas e filas por aqui também.

#4

Caro amigo jalmat eu tenho classes de pilha, fila e lista talves possa ajudar:

Pilha:

[code]public class PilhaSimples {

private Object [] vetor;
private int ultimo = -1;

public PilhaSimples() {
    vetor = new Object [100];
    ultimo = -1;
}
public PilhaSimples(int capacidade){
    vetor = new Object [capacidade];
    ultimo = -1;
}
public boolean isEmpty(){
    return ultimo == -1;
}
public int size(){
    return ultimo+ 1;
}
public void push(Object obj){
    if(ultimo < vetor.length - 1){
    ultimo ++ ;
    vetor[ultimo]=obj;
    }
    else{
    System.out.println("A pilha esta cheia");
    }
}
public Object top(){
    if(ultimo >= 0){
    return vetor[ultimo];       
    }
    return null;
}

public Object pop(){
if(ultimo >=0){
Object x = vetor[ultimo];
vetor[ultimo]=null;
ultimo–;
return x;
}
return null;
}
public void imprimir(){
for(int i = ultimo; i>=0;i–){

     System.out.println(vetor [i]);
 }

}
public PilhaSimples getPilha(){
PilhaSimples aux = new PilhaSimples();
for(int i=0; i<=ultimo;i++ ){
aux.push(vetor[i]);
}
return aux;
}

}

Fila:

public class FilaSimples {

private Object [] vet;
private int ultim = -1;
private int primeiro = 0;

public FilaSimples(){
    vet = new Object [100];
    ultim = -1;
}
public FilaSimples(int cap ){
    vet = new Object [cap];
    ultim = -1;
}
public int size(){
    return ultim+ 1;
}
public boolean isEmpty(){
    return ultim == -1 ;
}
public void enqueue(Object elemento){
    if(ultim < vet.length-1){
        ultim ++;
    vet [ultim] = elemento;
    }
    else {
        System.out.println("A pilha esta cheia");
    }   
}
public Object dequeue(){
    
    if(!isEmpty()){
        Object saida = vet[0];
        for (int i =0; i< ultim ;i++ ){
            vet[i] = vet[i+1];
        }
        vet[ultim --] = null;
        return saida;
    }
    return null;
}
public Object front(){
    if(isEmpty ()){
        System.out.println("Fila vazia");
        return null;
    }
    else{
        return vet[0];
    }
}

}

Lista:

public class ListaSimples {

private No primeiro = new No ();
private No ultimo = new No ();
private int contador = 0;

public ListaSimples(){
    primeiro = null;
}
public boolean isEmpty(){
    return (primeiro == null);
}
public int size(){
    return contador;
}
public void insertFirst(Object elemento){        
    No novo = new No (elemento);
    
    if(isEmpty()){
        primeiro = ultimo = novo;
    }
    else{
        novo.setProximo(primeiro);
        primeiro = novo;
    }
    contador ++;
}
public void insertLast(Object elemento){
    No novo = new No(elemento);
    
    if(isEmpty()){
        primeiro = ultimo = novo;
    }
    else{
        ultimo.setProximo(novo);
        ultimo = novo;
    }
    contador ++;
}
public Object first(){
    return primeiro.getElemento();
}
public Object last(){
    return ultimo.getElemento();
}
public Object removeFirst(){
    Object aux;
    if(isEmpty()){
        System.out.println("A Lista Vazia");
        return null;
    }
    else{
    aux = primeiro.getElemento();
    if(primeiro.equals(ultimo)){
        primeiro = ultimo = null;
    }else{
    primeiro = primeiro.getProximo();
    }
    contador --;
    return aux;
    }
}
public Object removeLast(){
    if(isEmpty()){
        System.out.println("A lista Vazia");
        return null;
    }
    else{
        Object temp = ultimo.getElemento();
        if(ultimo.equals(primeiro)){
            primeiro = ultimo = null;
        }
        else{
            No aux;
            aux = primeiro.getProximo();
                while(aux.getProximo()!= ultimo){
                    aux = aux.getProximo();
                }
            ultimo = aux;
        }
        contador --;
        return temp;
    }
}
public void imprimir(){
    if(isEmpty()){
        System.out.println("A lista esta vazia");
    }
    else{
        No aux = primeiro;
        while(aux != null){
            System.out.print(aux.getElemento().toString() + ", ");
            aux = aux.getProximo();
        }
    }
}
    private void imprimirC(No aux){
    if(aux ==  null){
        return;
    }
    else{
        //System.out.print(aux.getElemento().toString() + ", ");
        imprimirC(aux.getProximo());
        System.out.print(aux.getElemento().toString() + ", ");
    }
}

public void imprimirC(){
    imprimirC(primeiro);
}

public static void main(String a[]){
    ListaSimples l = new ListaSimples();
    for(int i = 0; i < 20; i++){
        l.insertLast(i);
    }
    l.imprimir();
    System.out.println();
    l.imprimirC();
}
public Object getElemento(int index){
    No aux = primeiro;
    if(index >= size()){
        System.out.println("Indice incorreto");
        return null;
    }
    else{
        for(int i=0; i < index; i++){
            aux = aux.getProximo();
        }
        return aux.getElemento();
    }

[color=blue][/color][b] public No getNo(int indice){
No aux = primeiro;
if(indice > size()){
System.out.println(“Indice incorreto”);
return null;
}
else{
for(int i=0; i<= size(); i++){
aux = aux.getProximo();
}
return aux;
}
}
public int getIndexElemento(Object o){
No aux = primeiro;
for(int i =0;i <= size();i++){
if(aux.getElemento().equals(o)){
return i;
}
aux = aux.getProximo();
}
return -1;
}
public void inserirElemento(int index, Object o){
No aux = primeiro;
No pos = new No();
pos.setElemento(o);
if(index == 0){
insertFirst(o);
}
if(index == size()){
insertLast(o);
}
else{
for(int i= 0; i < index; i++){
aux = aux.getProximo();
}
No auxpos = new No();
auxpos = aux.getProximo();
aux.setProximo(pos);
pos.setProximo(auxpos);
contador ++;
}
}
public ListaSimples getListaInvertida(){
ListaSimples aux = new ListaSimples();
for(int i = size();i >0;i–){
aux.insertLast(getElemento(i));
}
return aux;
}
public Object removerElemento(int index){
Object ret = null;
if(index >= 0 && index < size()){
if(index == 0) removeFirst();
else if(index == size()-1)removeLast();
else{
ret = getElemento(index);
No ant = getNo(index -1);
No prox = getNo(index +1);
ant.setProximo(prox);
}
}
return ret;
}
}[/code]

Tai amigo espero que isso te ajude !!

#5