Estruturas de Dados Dinâmicas em Java

E

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 >(
 
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
 
Edu115 disse:
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 >(
Clicar para expandir...

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.
 
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!
 
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.
 
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 p, q;
      for (p = head; (q = p.getNext()) != null; p = q)
        /* 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 = head, q = null, next = head.getNext();
    if (next == null) {
      head = null;
      return p;
    }
    while ((next = p.getNext()) != null) {
      q = p;
      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 = head, q = null;
    while ((q = p.getNext()) != null) {
      if (node.equals(q)) {
        p.setNext(q.getNext());
        return;
      }
      p = 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 = i;
    } // Constructor

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

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

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

    public boolean equals(Object o) { // For comparison
      if (this == o)
        return true;
      if (!(o instanceof LinkableInteger))
        return false;
      if (((LinkableInteger) o).i == 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(); l != null; l = l.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.
 
Inicie sessão ou registe-se para poder participar.
Back
Topo