2016-08-04 49 views
0

Erst kürzlich zu kopieren, ich bin die Algorithmen 4. learing, wenn ich komme, um das Problem zu lösen, dasseinen Konstruktor Verwenden Sie einen Stapel

einen neuen Konstruktor erstellen für die verknüpfte Liste Implementierung von Stapel. java, so dass Stack t = new Stack (s) sich auf eine neue und unabhängige Kopie des Stack s bezieht. Hier

ist die Stack.java

import java.util.Iterator; 
import java.util.NoSuchElementException; 
public class Stack<Item> implements Iterable<Item> { 
private Node<Item> first;  // top of stack 
private int n;    // size of the stack 
private static class Node<Item> { 
    private Item item; 
    private Node<Item> next; 
} 

/** 
* Initializes an empty stack. 
*/ 
public Stack() { 
    first = null; 
    n = 0; 
} 
public boolean isEmpty() { 
    return first == null; 
} 
public int size() { 
    return n; 
} 
public void push(Item item) { 
    Node<Item> oldfirst = first; 
    first = new Node<Item>(); 
    first.item = item; 
    first.next = oldfirst; 
    n++; 
} 
    public Item pop() { 
    if (isEmpty()) throw new NoSuchElementException("Stack underflow"); 
    Item item = first.item;  // save item to return 
    first = first.next;   // delete first node 
    n--; 
    return item;     // return the saved item 
} 
private class ListIterator<Item> implements Iterator<Item> { 
    private Node<Item> current; 

    public ListIterator(Node<Item> first) { 
     current = first; 
    } 
public boolean hasNext() { 
     return current != null; 
    } 

    public void remove() { 
     throw new UnsupportedOperationException(); 
    } 

    public Item next() { 
     if (!hasNext()) throw new NoSuchElementException(); 
     Item item = current.item; 
     current = current.next; 
     return item; 
    } 
} 

Die Antwort von rekursive Lösung ist, dass eine Kopie Konstruktor für eine verknüpfte Liste erstellen zu einem bestimmten Knoten starten und verwenden diese zu erstellen der neue Stapel.

Node(Node x) { 
item = x.item; 
if (x.next != null) next = new Node(x.next); 
} 

public Stack(Stack<Item> s) { first = new Node(s.first); } 

Aber was macht mich verwirrt ist, wie kann ich den oben stehenden Code zum Stack.java als Konstruktor kombinieren, wie kann ich den Knoten umgehen? um einen neuen Klasse-Knoten zu erstellen? Könnte mir jemand helfen?

+2

Sie beachten Sie, dass 'Node' eine private Klasse in' Stack' ist. Sie müssen einfach den Kopierkonstruktor hinzufügen. – RealSkeptic

+2

Was meinst du * "um einen neuen Klassenknoten zu erstellen" *? Sie haben bereits eine 'Node'-Klasse, fügen Sie einfach den neuen Node copy-constructor hinzu (und fügen Sie den no-arg-Konstruktor hinzu, da Sie ihn nicht mehr kostenlos erhalten). – Andreas

+0

Sie könnten für Klonen gehen, tiefe Kopie – JavaHopper

Antwort

0

Sie müssen keinen neuen Klassenknoten erstellen. Der Knoten ist der gleiche für den alten Stapel und den neuen Stapel "t".

Derzeit haben Sie einen Konstruktor in Ihrer Stack Klasse public Stack(). Sie müssen einen anderen Stack erstellen, der einen Stack akzeptiert, wie Sie es in Ihrem Beispiel getan haben und der dann eine Methode aufruft, die die alten Elemente (rekursiv oder iterativ) in den neuen Stack kopiert. Es klingt wie Hausaufgaben, also glaube ich nicht, dass ein Code angemessen ist (ich bin mir nicht sicher, welche Regeln in dieser Hinsicht gelten).

0

Hier ist der Code-Fragment I hava

mein Problem gelöst
private class Node{ 
    Item item; 
    Node next; 
    Node() { }       //default constructor Node 
    Node(Node x){ 
     item=x.item; 
     if(x.next!=null) next=new Node(x.next);  
    } 
} 
public Stack(){      //default constructor Stack 
    first=null; 
    N=0;   
} 

public Stack(Stack<Item> s) {first=new Node(s.first); } 
+0

Das ist falsch! Sie versuchen, den gleichen Stapel mit zwei verschiedenen Köpfen zu beziehen – JavaHopper