función print () que imprime el contenido de cada elemento de su lista
Básicamente, estoy tratando de escribir una declaración de impresión que me permita imprimir los elementos por línea como println como salida cuando ejecuto driver.java. Y por mi vida no puedo entender cómo hacerlo. Cualquier ayuda será apreciada.
aquí está el driver.java
public class Driver {
public static void main(String args[]){
LList<String> s_list = new LList<String>();
s_list.insert("New York, 8.4M");
s_list.insert("Los Angeles 3.8M");
s_list.insert("Chicago, 2.7M");
s_list.insert("Houston, 2.1M");
s_list.insert("Philadelphia, 1.55M");
s_list.insert("Phoenix, 1.51M");
s_list.append("San Antonio, 1.4M");
s_list.append("San Diego, 1.35M");
s_list.append("Dallas, 1.25M");
s_list.append("San Jose, 0.998M");
s_list.append("Austin, 0.88M");
s_list.append("Indianapolis, 0.84M");
s_list.append("Jacksonville, 0.84M");
s_list.append("San Francisco, 0.83M");
s_list.append("Columbus, 0.82M");
s_list.append("Charlotte, 0.79M");
s_list.print();
s_list.moveToPos(3);
s_list.remove();
s_list.print();
s_list.moveToEnd();
s_list.remove();
s_list.print();
s_list.moveToStart();
s_list.remove();
s_list.remove();
s_list.print();
s_list.clear();
s_list.print();
}
}
y tengo un archivo java llamado LList.java
donde estoy tratando de escribir un método de impresión donde imprimirá () la función que imprime el contenido de cada elemento de su lista; imprime un elemento por línea.
public void print {
}
Entonces, ¿cómo imprimiré los elementos en la línea "s_list" por línea como salida?
Cualquier ayuda es apreciada.
ACTUALIZACIÓN: voy a publicar Llist.java, list.java y link.java aquí
Llist.java
/** Linked list implementation */
class LList<E> implements List<E> {
private Link<E> head; // Pointer to list header
private Link<E> tail; // Pointer to last element
protected Link<E> curr; // Access to current element
private int cnt; // Size of list
/** Constructors */
LList(int size) { this(); } // Constructor -- Ignore size
LList() {
curr = tail = head = new Link<E>(null); // Create header
cnt = 0;
}
/** Remove all elements */
public void clear() {
head.setNext(null); // Drop access to links
curr = tail = head = new Link<E>(null); // Create header
cnt = 0;
}
/** Insert "it" at current position */
public void insert(E it) {
curr.setNext(new Link<E>(it, curr.next()));
if (tail == curr) tail = curr.next(); // New tail
cnt++;
}
/** Append "it" to list */
public void append(E it) {
tail = tail.setNext(new Link<E>(it, null));
cnt++;
}
/** Remove and return current element */
public E remove() {
if (curr.next() == null) return null; // Nothing to remove
E it = curr.next().element(); // Remember value
if (tail == curr.next()) tail = curr; // Removed last
curr.setNext(curr.next().next()); // Remove from list
cnt--; // Decrement count
return it; // Return value
}
/** Set curr at list start */
public void moveToStart()
{ curr = head; }
/** Set curr at list end */
public void moveToEnd()
{ curr = tail; }
/** Move curr one step left; no change if now at front */
public void prev() {
if (curr == head) return; // No previous element
Link<E> temp = head;
// March down list until we find the previous element
while (temp.next() != curr) temp = temp.next();
curr = temp;
}
/** Move curr one step right; no change if now at end */
public void next()
{ if (curr != tail) curr = curr.next(); }
/** @return List length */
public int length() { return cnt; }
/** @return The position of the current element */
public int currPos() {
Link<E> temp = head;
int i;
for (i=0; curr != temp; i++)
temp = temp.next();
return i;
}
/** Move down list to "pos" position */
public void moveToPos(int pos) {
assert (pos>=0) && (pos<=cnt) : "Position out of range";
curr = head;
for(int i=0; i<pos; i++) curr = curr.next();
}
/** @return Current element value */
public E getValue() {
if(curr.next() == null) return null;
return curr.next().element();
}
public void print()
{
}
}
List.java
/** List ADT */
public interface List<E> {
/** Remove all contents from the list, so it is once again
empty. Client is responsible for reclaiming storage
used by the list elements. */
public void clear();
/** Insert an element at the current location. The client
must ensure that the list�s capacity is not exceeded.
@param item The element to be inserted. */
public void insert(E item);
/** Append an element at the end of the list. The client
must ensure that the list�s capacity is not exceeded.
@param item The element to be appended. */
public void append(E item);
/** Remove and return the current element.
@return The element that was removed. */
public E remove();
/** Set the current position to the start of the list */
public void moveToStart();
/** Set the current position to the end of the list */
public void moveToEnd();
/** Move the current position one step left. No change
if already at beginning. */
public void prev();
/** Move the current position one step right. No change
if already at end. */
public void next();
/** @return The number of elements in the list. */
public int length();
/** @return The position of the current element. */
public int currPos();
/** Set current position.
@param pos The position to make current. */
public void moveToPos(int pos);
/** @return The current element. */
public E getValue();
}
Link.java
/** Singly linked list node */
class Link<E> {
private E element; // Value for this node
private Link<E> next; // Pointer to next node in list
// Constructors
Link(E it, Link<E> nextval)
{ element = it; next = nextval; }
Link(Link<E> nextval) { next = nextval; }
Link<E> next() { return next; } // Return next field
Link<E> setNext(Link<E> nextval) // Set next field
{ return next = nextval; } // Return element field
E element() { return element; } // Set element field
E setElement(E it) { return element = it; }
}