1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Estruturas de Dados Dinâmicas em Java

Discussão em 'Programação' iniciada por Edu115, 22 de Janeiro de 2007. (Respostas: 5; Visualizações: 1743)

  1. Edu115

    Edu115 Power Member

    Existem? É um bocado confuso, porque não há apontadores em Java. Tenho que criar uma classe que "imite" as listas?

    É que isto de limitar as estruturas de dados a x valores é um bocado chato...


    Baaah i miss C >(
     
  2. Pure_Water

    Pure_Water Power Member

    Estruturas de Dados Dinâmicas como assim? Keres fazer uma lista sem limite de tamanho?

    podes usar a class java.util.ArrayList,

    queres criar uma lista de Doubles por exemplo e que n sabes qual o limite que precisas, fazes:

    ArrayList<Double> lista = new ArrayList<Double> ();

    depois é só ires fazendo lista.add as cenas k keres la ir metendo, e ela vai aumentando ou diminuindo de tamanho consoante o que necessitas :P
     
  3. souto

    souto To fold or to FOLD?

    you miss C... hm, depois de usares java para estruturas dinâmicas não vais querer outra coisa.

    os apontadores em java existem, mas chamam-se referências, e a gestão destas é totalmente automática e transparente ao utilizador.

    portanto, adeus malloc(). procura na net por listas simplesmente ligadas (ou single linked lists) e vais ver que é mesmo fácil definires uma lista ligada. o mesmo se passa com árvores, tabelas de dispersão, etc.

    cumprimentos.
     
  4. Edu115

    Edu115 Power Member

    Giro!

    O mal é que põem-nos a fazer validações todas xpto com um conhecimento mínimo da linguagem...
    E pronto, um gaijo tem que se desenrascar sozinho.

    Obrigadíssimo a ambos!
     
  5. guilherme

    guilherme Power Member

    n te rales q n és o unico, tal como o souto disse procura por linkedlist, isso é mt simples de fazer,
    crias 1 classe singleLinkedList que leva nos, e crias 1 classe node, basicamente cada no vai apontar para outro e assim sucessivamente, quando o elemento é o ultimo aponta para null, que tal como o souto disse sao referencias.
     
  6. MadOnion

    MadOnion Folding Member

    Single LinkedList, Double LinkedList, HashTable, Map e Tree. Pure_Water as aulas de AED estão a fazer-te falta.

    No entanto cá vai um exemplo de uma Lista simples ligada:
    PHP:
    /*
     * Copyright (c) 2000 David Flanagan.  All rights reserved.
     * This code is from the book Java Examples in a Nutshell, 2nd Edition.
     * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
     * You may study, use, and modify it for any non-commercial purpose.
     * You may distribute it non-commercially as long as you retain this notice.
     * For a commercial use license, or to purchase the book (recommended),
     * visit http://www.davidflanagan.com/javaexamples2.
     */

    /**
     * This class implements a linked list that can contain any type of object that
     * implements the nested Linkable interface. Note that the methods are all
     * synchronized, so that it can safely be used by multiple threads at the same
     * time.
     */
    public class LinkedList {
      
    /**
       * This interface defines the methods required by any object that can be
       * linked into a linked list.
       */
      
    public interface Linkable {
        public 
    Linkable getNext(); // Returns the next element in the list

        
    public void setNext(Linkable node); // Sets the next element in the list
      
    }

      
    // This class has a default constructor: public LinkedList() {}

      /** This is the only field of the class. It holds the head of the list */
      
    Linkable head;

      
    /** Return the first node in the list */
      
    public synchronized Linkable getHead() {
        return 
    head;
      }

      
    /** Insert a node at the beginning of the list */
      
    public synchronized void insertAtHead(Linkable node) {
        
    node.setNext(head);
        
    head node;
      }

      
    /** Insert a node at the end of the list */
      
    public synchronized void insertAtTail(Linkable node) {
        if (
    head == null)
          
    head node;
        else {
          
    Linkable pq;
          for (
    head; (p.getNext()) != nullq)
            
    /* no body */;
          
    p.setNext(node);
        }
      }

      
    /** Remove and return the node at the head of the list */
      
    public synchronized Linkable removeFromHead() {
        
    Linkable node head;
        if (
    node != null) {
          
    head node.getNext();
          
    node.setNext(null);
        }
        return 
    node;
      }

      
    /** Remove and return the node at the end of the list */
      
    public synchronized Linkable removeFromTail() {
        if (
    head == null)
          return 
    null;
        
    Linkable p headnullnext head.getNext();
        if (
    next == null) {
          
    head null;
          return 
    p;
        }
        while ((
    next p.getNext()) != null) {
          
    p;
          
    next;
        }
        
    q.setNext(null);
        return 
    p;
      }

      
    /**
       * Remove a node matching the specified node from the list. Use equals()
       * instead of == to test for a matched node.
       */
      
    public synchronized void remove(Linkable node) {
        if (
    head == null)
          return;
        if (
    node.equals(head)) {
          
    head head.getNext();
          return;
        }
        
    Linkable p headnull;
        while ((
    p.getNext()) != null) {
          if (
    node.equals(q)) {
            
    p.setNext(q.getNext());
            return;
          }
          
    q;
        }
      }

      
    /**
       * This is a test class that implements the Linkable interface
       */
      
    static class LinkableInteger implements Linkable {
        
    int i// The data contained in the node

        
    Linkable next// A reference to the next node in the list

        
    public LinkableInteger(int i) {
          
    this.i;
        } 
    // Constructor

        
    public Linkable getNext() {
          return 
    next;
        } 
    // Part of Linkable

        
    public void setNext(Linkable node) {
          
    next node;
        } 
    // Linkable

        
    public String toString() {
          return 
    "";
        } 
    // For easy printing

        
    public boolean equals(Object o) { // For comparison
          
    if (this == o)
            return 
    true;
          if (!(
    instanceof LinkableInteger))
            return 
    false;
          if (((
    LinkableIntegero).== this.i)
            return 
    true;
          return 
    false;
        }
      }

      
    /**
       * The test program. Insert some nodes, remove some nodes, then print
       * out all elements in the list. It should print out the numbers 4, 6,
       * 3, 1, and 5
       */
      
    public static void main(String[] args) {
        
    LinkedList ll = new LinkedList(); // Create a list
        
    ll.insertAtHead(new LinkableInteger(1)); // Insert some stuff
        
    ll.insertAtHead(new LinkableInteger(2));
        
    ll.insertAtHead(new LinkableInteger(3));
        
    ll.insertAtHead(new LinkableInteger(4));
        
    ll.insertAtTail(new LinkableInteger(5));
        
    ll.insertAtTail(new LinkableInteger(6));
        
    System.out.println(ll.removeFromHead()); // Remove and print a node
        
    System.out.println(ll.removeFromTail()); // Remove and print again
        
    ll.remove(new LinkableInteger(2)); // Remove another one

        // Now print out the contents of the list.
        
    for (Linkable l ll.getHead(); != nulll.getNext())
          
    System.out.println(l);
      }

    }
    Creditos:

    É só procurar na net informação com os dados que o guilherme disse, ou eu disse no inicio do post.
     

Partilhar esta Página