Solved

LinkedList implements the Collections interface?

Posted on 2004-08-08
13
571 Views
Last Modified: 2013-11-23
Hello
i want to my LinkedList class implements Collection interface but need help on that
any suggestion/help.

this is the LinkedList class

/**
*  Linked list implementation
*/

public class LinkedList
{
      protected Node firstNode = null;
      
      /**
      *  Returns true if list is empty
      */
      
      public boolean isEmpty()
      {
            return firstNode==null;
      }
      
      /**
      *  Adds a new node to the front of the list
      *  @param o object to add
      */
      
      public void add(Object o)
      {
            Node node = new Node(o, firstNode);
            firstNode = node;
      }

      /**
      *  Adds an object to list at specified index
      */
      
      public void add(Object o, int index)
      {
            if (index==0)
            {
                  // add as first node
                  
                  add(o);
            }
            else
            {
                  // find node before it in list
                  
                  Node prev = get(index-1);
                  if (prev!=null)
                  {
                        // and insert new node
                        
                        prev.setNext(new Node(o, prev.getNext()));
                  }
            }
      }
      
      /**
      *  Removes an indexed element from the list
      *  @param index index of node to remove
      */
      
      public Object remove(int index)
      {
            Object result = null;
            
            // find node in list
            // also need to remember previous node so we can update it's next pointer
            
            Node prev = null;
            Node node = firstNode;
            for (int i=0; node!=null && i<index; i++)
            {
                  prev = node;
                  node = node.getNext();
            }
            if (node!=null)
            {                  
                  // remove element from list
                  
                  if (prev==null)
                  {
                        // remove first node
                        
                        firstNode = node.getNext();
                  }
                  else
                  {
                        // remove node
                        
                        prev.setNext(node.getNext());
                  }
                  
                  result = node.getData();
                  node.setNext(null);
                  
            }
            return result;
      }
      
      /**
      *  Returns node at a specified index
      */
      
      protected Node get(int index)
      {
            Node node = firstNode;
            for (int i=0; node!=null && i<index; i++)
            {
                  node = node.getNext();
            }
            return node;
      }

      /**
      *  Returns a string representation of the elements in the list
      */
      
      public String toString()
      {
            StringBuffer result = new StringBuffer();
            result.append("");
            Node next = firstNode;
            while (next!=null)
            {
                  result.append(next);
                  next = next.getNext();
                  if (next!=null)
                  {
                        result.append("");
                  }
            }
            result.append("");
            return result.toString();
      }
}
0
Comment
Question by:anosTekbot
13 Comments
 
LVL 35

Accepted Solution

by:
girionis earned 168 total points
ID: 11745909
Just add an "implements Collection" to your LinkedList definition:

public class LinkedList implements Collection

and you will also need to implement *all* method in the Collection interface. But there is already a LinkedList implementation, any specific reason you want to have your own one?

0
 

Author Comment

by:anosTekbot
ID: 11745943
there is no specific reason but there is a good reason that  i want to learn before the school  in fall ; )
practicing problems is a good way to waste time instead watching TV  : )

I know just need to add implements Collection, but did not know how i would change my LinkedList class : ))
0
 

Author Comment

by:anosTekbot
ID: 11745971
also iam gona implements Iterator  later after the collection
0
 
LVL 1

Expert Comment

by:wolfc
ID: 11746388
Oh oh, I'm unable to resist the urge....

Aaarghhhh, nope, couldn't resist.
0
 
LVL 1

Expert Comment

by:wolfc
ID: 11746390
/*
 * @(#)LinkedList.java      1.46 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.util;

/**
 * Linked list implementation of the <tt>List</tt> interface.  Implements all
 * optional list operations, and permits all elements (including
 * <tt>null</tt>).  In addition to implementing the <tt>List</tt> interface,
 * the <tt>LinkedList</tt> class provides uniformly named methods to
 * <tt>get</tt>, <tt>remove</tt> and <tt>insert</tt> an element at the
 * beginning and end of the list.  These operations allow linked lists to be
 * used as a stack, queue, or double-ended queue (deque).<p>
 *
 * All of the stack/queue/deque operations could be easily recast in terms of
 * the standard list operations.  They're included here primarily for
 * convenience, though they may run slightly faster than the equivalent List
 * operations.<p>
 *
 * All of the operations perform as could be expected for a doubly-linked
 * list.  Operations that index into the list will traverse the list from
 * the begining or the end, whichever is closer to the specified index.<p>
 *
 * <b>Note that this implementation is not synchronized.</b> If multiple
 * threads access a list concurrently, and at least one of the threads
 * modifies the list structurally, it <i>must</i> be synchronized
 * externally.  (A structural modification is any operation that adds or
 * deletes one or more elements; merely setting the value of an element is not
 * a structural modification.)  This is typically accomplished by
 * synchronizing on some object that naturally encapsulates the list.  If no
 * such object exists, the list should be "wrapped" using the
 * Collections.synchronizedList method.  This is best done at creation time,
 * to prevent accidental unsynchronized access to the list: <pre>
 *     List list = Collections.synchronizedList(new LinkedList(...));
 * </pre><p>
 *
 * The iterators returned by the this class's <tt>iterator</tt> and
 * <tt>listIterator</tt> methods are <i>fail-fast</i>: if the list is
 * structurally modified at any time after the iterator is created, in any way
 * except through the Iterator's own <tt>remove</tt> or <tt>add</tt> methods,
 * the iterator will throw a <tt>ConcurrentModificationException</tt>.  Thus,
 * in the face of concurrent modification, the iterator fails quickly and
 * cleanly, rather than risking arbitrary, non-deterministic behavior at an
 * undetermined time in the future.
 *
 * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
 * as it is, generally speaking, impossible to make any hard guarantees in the
 * presence of unsynchronized concurrent modification.  Fail-fast iterators
 * throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
 * Therefore, it would be wrong to write a program that depended on this
 * exception for its correctness:   <i>the fail-fast behavior of iterators
 * should be used only to detect bugs.</i><p>
 *
 * This class is a member of the
 * <a href="{@docRoot}/../guide/collections/index.html">
 * Java Collections Framework</a>.
 *
 * @author  Josh Bloch
 * @version 1.46, 01/23/03
 * @see          List
 * @see          ArrayList
 * @see          Vector
 * @see          Collections#synchronizedList(List)
 * @since 1.2
 */

public class LinkedList extends AbstractSequentialList
                    implements List, Cloneable, java.io.Serializable
{
    private transient Entry header = new Entry(null, null, null);
    private transient int size = 0;

    /**
     * Constructs an empty list.
     */
    public LinkedList() {
        header.next = header.previous = header;
    }

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param  c the collection whose elements are to be placed into this list.
     * @throws NullPointerException if the specified collection is null.
     */
     public LinkedList(Collection c) {
       this();
       addAll(c);
     }

    /**
     * Returns the first element in this list.
     *
     * @return the first element in this list.
     * @throws    NoSuchElementException if this list is empty.
     */
    public Object getFirst() {
      if (size==0)
          throw new NoSuchElementException();

      return header.next.element;
    }

    /**
     * Returns the last element in this list.
     *
     * @return the last element in this list.
     * @throws    NoSuchElementException if this list is empty.
     */
    public Object getLast()  {
      if (size==0)
          throw new NoSuchElementException();

      return header.previous.element;
    }

    /**
     * Removes and returns the first element from this list.
     *
     * @return the first element from this list.
     * @throws    NoSuchElementException if this list is empty.
     */
    public Object removeFirst() {
      Object first = header.next.element;
      remove(header.next);
      return first;
    }

    /**
     * Removes and returns the last element from this list.
     *
     * @return the last element from this list.
     * @throws    NoSuchElementException if this list is empty.
     */
    public Object removeLast() {
      Object last = header.previous.element;
      remove(header.previous);
      return last;
    }

    /**
     * Inserts the given element at the beginning of this list.
     *
     * @param o the element to be inserted at the beginning of this list.
     */
    public void addFirst(Object o) {
      addBefore(o, header.next);
    }

    /**
     * Appends the given element to the end of this list.  (Identical in
     * function to the <tt>add</tt> method; included only for consistency.)
     *
     * @param o the element to be inserted at the end of this list.
     */
    public void addLast(Object o) {
      addBefore(o, header);
    }

    /**
     * Returns <tt>true</tt> if this list contains the specified element.
     * More formally, returns <tt>true</tt> if and only if this list contains
     * at least one element <tt>e</tt> such that <tt>(o==null ? e==null
     * : o.equals(e))</tt>.
     *
     * @param o element whose presence in this list is to be tested.
     * @return <tt>true</tt> if this list contains the specified element.
     */
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

    /**
     * Returns the number of elements in this list.
     *
     * @return the number of elements in this list.
     */
    public int size() {
      return size;
    }

    /**
     * Appends the specified element to the end of this list.
     *
     * @param o element to be appended to this list.
     * @return <tt>true</tt> (as per the general contract of
     * <tt>Collection.add</tt>).
     */
    public boolean add(Object o) {
      addBefore(o, header);
        return true;
    }

    /**
     * Removes the first occurrence of the specified element in this list.  If
     * the list does not contain the element, it is unchanged.  More formally,
     * removes the element with the lowest index <tt>i</tt> such that
     * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt> (if such an
     * element exists).
     *
     * @param o element to be removed from this list, if present.
     * @return <tt>true</tt> if the list contained the specified element.
     */
    public boolean remove(Object o) {
        if (o==null) {
            for (Entry e = header.next; e != header; e = e.next) {
                if (e.element==null) {
                    remove(e);
                    return true;
                }
            }
        } else {
            for (Entry e = header.next; e != header; e = e.next) {
                if (o.equals(e.element)) {
                    remove(e);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Appends all of the elements in the specified collection to the end of
     * this list, in the order that they are returned by the specified
     * collection's iterator.  The behavior of this operation is undefined if
     * the specified collection is modified while the operation is in
     * progress.  (This implies that the behavior of this call is undefined if
     * the specified Collection is this list, and this list is nonempty.)
     *
     * @param c the elements to be inserted into this list.
     * @return <tt>true</tt> if this list changed as a result of the call.
     * @throws NullPointerException if the specified collection is null.
     */
    public boolean addAll(Collection c) {
        return addAll(size, c);
    }

    /**
     * Inserts all of the elements in the specified collection into this
     * list, starting at the specified position.  Shifts the element
     * currently at that position (if any) and any subsequent elements to
     * the right (increases their indices).  The new elements will appear
     * in the list in the order that they are returned by the
     * specified collection's iterator.
     *
     * @param index index at which to insert first element
     *                from the specified collection.
     * @param c elements to be inserted into this list.
     * @return <tt>true</tt> if this list changed as a result of the call.
     * @throws IndexOutOfBoundsException if the specified index is out of
     *            range (<tt>index &lt; 0 || index &gt; size()</tt>).
     * @throws NullPointerException if the specified collection is null.
     */
    public boolean addAll(int index, Collection c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew==0)
            return false;
      modCount++;

        Entry successor = (index==size ? header : entry(index));
        Entry predecessor = successor.previous;
      for (int i=0; i<numNew; i++) {
            Entry e = new Entry(a[i], successor, predecessor);
            predecessor.next = e;
            predecessor = e;
        }
        successor.previous = predecessor;

        size += numNew;
        return true;
    }

    /**
     * Removes all of the elements from this list.
     */
    public void clear() {
      modCount++;
        header.next = header.previous = header;
      size = 0;
    }


    // Positional Access Operations

    /**
     * Returns the element at the specified position in this list.
     *
     * @param index index of element to return.
     * @return the element at the specified position in this list.
     *
     * @throws IndexOutOfBoundsException if the specified index is is out of
     * range (<tt>index &lt; 0 || index &gt;= size()</tt>).
     */
    public Object get(int index) {
        return entry(index).element;
    }

    /**
     * Replaces the element at the specified position in this list with the
     * specified element.
     *
     * @param index index of element to replace.
     * @param element element to be stored at the specified position.
     * @return the element previously at the specified position.
     * @throws IndexOutOfBoundsException if the specified index is out of
     *              range (<tt>index &lt; 0 || index &gt;= size()</tt>).
     */
    public Object set(int index, Object element) {
        Entry e = entry(index);
        Object oldVal = e.element;
        e.element = element;
        return oldVal;
    }

    /**
     * Inserts the specified element at the specified position in this list.
     * Shifts the element currently at that position (if any) and any
     * subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted.
     * @param element element to be inserted.
     *
     * @throws IndexOutOfBoundsException if the specified index is out of
     *              range (<tt>index &lt; 0 || index &gt; size()</tt>).
     */
    public void add(int index, Object element) {
        addBefore(element, (index==size ? header : entry(index)));
    }

    /**
     * Removes the element at the specified position in this list.  Shifts any
     * subsequent elements to the left (subtracts one from their indices).
     * Returns the element that was removed from the list.
     *
     * @param index the index of the element to removed.
     * @return the element previously at the specified position.
     *
     * @throws IndexOutOfBoundsException if the specified index is out of
     *               range (<tt>index &lt; 0 || index &gt;= size()</tt>).
     */
    public Object remove(int index) {
        Entry e = entry(index);
        remove(e);
        return e.element;
    }

    /**
     * Return the indexed entry.
     */
    private Entry entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
    }


    // Search Operations

    /**
     * Returns the index in this list of the first occurrence of the
     * specified element, or -1 if the List does not contain this
     * element.  More formally, returns the lowest index i such that
     * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, or -1 if
     * there is no such index.
     *
     * @param o element to search for.
     * @return the index in this list of the first occurrence of the
     *              specified element, or -1 if the list does not contain this
     *              element.
     */
    public int indexOf(Object o) {
        int index = 0;
        if (o==null) {
            for (Entry e = header.next; e != header; e = e.next) {
                if (e.element==null)
                    return index;
                index++;
            }
        } else {
            for (Entry e = header.next; e != header; e = e.next) {
                if (o.equals(e.element))
                    return index;
                index++;
            }
        }
        return -1;
    }

    /**
     * Returns the index in this list of the last occurrence of the
     * specified element, or -1 if the list does not contain this
     * element.  More formally, returns the highest index i such that
     * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, or -1 if
     * there is no such index.
     *
     * @param o element to search for.
     * @return the index in this list of the last occurrence of the
     *              specified element, or -1 if the list does not contain this
     *              element.
     */
    public int lastIndexOf(Object o) {
        int index = size;
        if (o==null) {
            for (Entry e = header.previous; e != header; e = e.previous) {
                index--;
                if (e.element==null)
                    return index;
            }
        } else {
            for (Entry e = header.previous; e != header; e = e.previous) {
                index--;
                if (o.equals(e.element))
                    return index;
            }
        }
        return -1;
    }

    /**
     * Returns a list-iterator of the elements in this list (in proper
     * sequence), starting at the specified position in the list.
     * Obeys the general contract of <tt>List.listIterator(int)</tt>.<p>
     *
     * The list-iterator is <i>fail-fast</i>: if the list is structurally
     * modified at any time after the Iterator is created, in any way except
     * through the list-iterator's own <tt>remove</tt> or <tt>add</tt>
     * methods, the list-iterator will throw a
     * <tt>ConcurrentModificationException</tt>.  Thus, in the face of
     * concurrent modification, the iterator fails quickly and cleanly, rather
     * than risking arbitrary, non-deterministic behavior at an undetermined
     * time in the future.
     *
     * @param index index of first element to be returned from the
     *                list-iterator (by a call to <tt>next</tt>).
     * @return a ListIterator of the elements in this list (in proper
     *              sequence), starting at the specified position in the list.
     * @throws    IndexOutOfBoundsException if index is out of range
     *              (<tt>index &lt; 0 || index &gt; size()</tt>).
     * @see List#listIterator(int)
     */
    public ListIterator listIterator(int index) {
      return new ListItr(index);
    }

    private class ListItr implements ListIterator {
      private Entry lastReturned = header;
      private Entry next;
      private int nextIndex;
      private int expectedModCount = modCount;

      ListItr(int index) {
          if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                        ", Size: "+size);
          if (index < (size >> 1)) {
            next = header.next;
            for (nextIndex=0; nextIndex<index; nextIndex++)
                next = next.next;
          } else {
            next = header;
            for (nextIndex=size; nextIndex>index; nextIndex--)
                next = next.previous;
          }
      }

      public boolean hasNext() {
          return nextIndex != size;
      }

      public Object next() {
          checkForComodification();
          if (nextIndex == size)
            throw new NoSuchElementException();

          lastReturned = next;
          next = next.next;
          nextIndex++;
          return lastReturned.element;
      }

      public boolean hasPrevious() {
          return nextIndex != 0;
      }

      public Object previous() {
          if (nextIndex == 0)
            throw new NoSuchElementException();

          lastReturned = next = next.previous;
          nextIndex--;
          checkForComodification();
          return lastReturned.element;
      }

      public int nextIndex() {
          return nextIndex;
      }

      public int previousIndex() {
          return nextIndex-1;
      }

      public void remove() {
            checkForComodification();
            try {
                LinkedList.this.remove(lastReturned);
            } catch (NoSuchElementException e) {
                throw new IllegalStateException();
            }
          if (next==lastReturned)
                next = lastReturned.next;
            else
            nextIndex--;
          lastReturned = header;
          expectedModCount++;
      }

      public void set(Object o) {
          if (lastReturned == header)
            throw new IllegalStateException();
          checkForComodification();
          lastReturned.element = o;
      }

      public void add(Object o) {
          checkForComodification();
          lastReturned = header;
          addBefore(o, next);
          nextIndex++;
          expectedModCount++;
      }

      final void checkForComodification() {
          if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
      }
    }

    private static class Entry {
      Object element;
      Entry next;
      Entry previous;

      Entry(Object element, Entry next, Entry previous) {
          this.element = element;
          this.next = next;
          this.previous = previous;
      }
    }

    private Entry addBefore(Object o, Entry e) {
      Entry newEntry = new Entry(o, e, e.previous);
      newEntry.previous.next = newEntry;
      newEntry.next.previous = newEntry;
      size++;
      modCount++;
      return newEntry;
    }

    private void remove(Entry e) {
      if (e == header)
          throw new NoSuchElementException();

      e.previous.next = e.next;
      e.next.previous = e.previous;
      size--;
      modCount++;
    }

    /**
     * Returns a shallow copy of this <tt>LinkedList</tt>. (The elements
     * themselves are not cloned.)
     *
     * @return a shallow copy of this <tt>LinkedList</tt> instance.
     */
    public Object clone() {
        LinkedList clone = null;
      try {
          clone = (LinkedList)super.clone();
      } catch (CloneNotSupportedException e) {
          throw new InternalError();
      }

        // Put clone into "virgin" state
        clone.header = new Entry(null, null, null);
        clone.header.next = clone.header.previous = clone.header;
        clone.size = 0;
        clone.modCount = 0;

        // Initialize clone with our elements
        for (Entry e = header.next; e != header; e = e.next)
            clone.add(e.element);

        return clone;
    }

    /**
     * Returns an array containing all of the elements in this list
     * in the correct order.
     *
     * @return an array containing all of the elements in this list
     *              in the correct order.
     */
    public Object[] toArray() {
      Object[] result = new Object[size];
        int i = 0;
        for (Entry e = header.next; e != header; e = e.next)
            result[i++] = e.element;
      return result;
    }

    /**
     * Returns an array containing all of the elements in this list in
     * the correct order; the runtime type of the returned array is that of
     * the specified array.  If the list fits in the specified array, it
     * is returned therein.  Otherwise, a new array is allocated with the
     * runtime type of the specified array and the size of this list.<p>
     *
     * If the list fits in the specified array with room to spare
     * (i.e., the array has more elements than the list),
     * the element in the array immediately following the end of the
     * collection is set to null.  This is useful in determining the length
     * of the list <i>only</i> if the caller knows that the list
     * does not contain any null elements.
     *
     * @param a the array into which the elements of the list are to
     *            be stored, if it is big enough; otherwise, a new array of the
     *             same runtime type is allocated for this purpose.
     * @return an array containing the elements of the list.
     * @throws ArrayStoreException if the runtime type of a is not a
     *         supertype of the runtime type of every element in this list.
     * @throws NullPointerException if the specified array is null.
     */
    public Object[] toArray(Object a[]) {
        if (a.length < size)
            a = (Object[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        for (Entry e = header.next; e != header; e = e.next)
            a[i++] = e.element;

        if (a.length > size)
            a[size] = null;

        return a;
    }

    private static final long serialVersionUID = 876323262645176354L;

    /**
     * Save the state of this <tt>LinkedList</tt> instance to a stream (that
     * is, serialize it).
     *
     * @serialData The size of the list (the number of elements it
     *               contains) is emitted (int), followed by all of its
     * elements (each an Object) in the proper order.  
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
      // Write out any hidden serialization magic
      s.defaultWriteObject();

        // Write out size
        s.writeInt(size);

      // Write out all elements in the proper order.
        for (Entry e = header.next; e != header; e = e.next)
            s.writeObject(e.element);
    }

    /**
     * Reconstitute this <tt>LinkedList</tt> instance from a stream (that is
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
      // Read in any hidden serialization magic
      s.defaultReadObject();

        // Read in size
        int size = s.readInt();

        // Initialize header
        header = new Entry(null, null, null);
        header.next = header.previous = header;

      // Read in all elements in the proper order.
      for (int i=0; i<size; i++)
            add(s.readObject());
    }
}
0
Why You Should Analyze Threat Actor TTPs

After years of analyzing threat actor behavior, it’s become clear that at any given time there are specific tactics, techniques, and procedures (TTPs) that are particularly prevalent. By analyzing and understanding these TTPs, you can dramatically enhance your security program.

 
LVL 30

Expert Comment

by:GrandSchtroumpf
ID: 11748726
wolfc, you forgot to also post the source for AbstractSequentialList
:°)
0
 
LVL 92

Assisted Solution

by:objects
objects earned 166 total points
ID: 11748909
you need to implement all the following methods (if not already implemented):

 boolean add(Object o)
          Ensures that this collection contains the specified element (optional operation).
 boolean addAll(Collection c)
          Adds all of the elements in the specified collection to this collection (optional operation).
 void clear()
          Removes all of the elements from this collection (optional operation).
 boolean contains(Object o)
          Returns true if this collection contains the specified element.
 boolean containsAll(Collection c)
          Returns true if this collection contains all of the elements in the specified collection.
 boolean equals(Object o)
          Compares the specified object with this collection for equality.
 int hashCode()
          Returns the hash code value for this collection.
 boolean isEmpty()
          Returns true if this collection contains no elements.
 Iterator iterator()
          Returns an iterator over the elements in this collection.
 boolean remove(Object o)
          Removes a single instance of the specified element from this collection, if it is present (optional operation).
 boolean removeAll(Collection c)
          Removes all this collection's elements that are also contained in the specified collection (optional operation).
 boolean retainAll(Collection c)
          Retains only the elements in this collection that are contained in the specified collection (optional operation).
 int size()
          Returns the number of elements in this collection.
 Object[] toArray()
          Returns an array containing all of the elements in this collection.
 Object[] toArray(Object[] a)
          Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.
0
 

Author Comment

by:anosTekbot
ID: 11749022
oh .. that does not look easy
thanks objects and wolfc
0
 
LVL 37

Assisted Solution

by:zzynx
zzynx earned 166 total points
ID: 11751583
Hi anosTekbot,

 nothing against your plans about trying to implement your own LinkendList implementation,
 but to avoid problems, probably better not call it LinkedList as java's one. Call it e.g. MyLinkedList.

PS. I posted the code for java's LinkedList (as wolfc did) already in one of your previous questions
0
 

Expert Comment

by:tgcomp
ID: 13259865
Hi all;
I need a method that could find a position to insert in a linked list application program. (java).
Public IntNode findPositionToInsert(int i){
IntNode tmpCursor = head;
IntNode tmpPrecursor = null;

Any suggestion, please, it would appreciate.

tgcomp
0
 
LVL 17

Expert Comment

by:rstaveley
ID: 13261517
0

Featured Post

How to run any project with ease

Manage projects of all sizes how you want. Great for personal to-do lists, project milestones, team priorities and launch plans.
- Combine task lists, docs, spreadsheets, and chat in one
- View and edit from mobile/offline
- Cut down on emails

Join & Write a Comment

Suggested Solutions

Title # Comments Views Activity
network + 7 73
computer science syllabus 3 53
where is session ID cache stored 1 40
wordmultiple challenge 12 93
Java had always been an easily readable and understandable language.  Some relatively recent changes in the language seem to be changing this pretty fast, and anyone that had not seen any Java code for the last 5 years will possibly have issues unde…
Introduction Java can be integrated with native programs using an interface called JNI(Java Native Interface). Native programs are programs which can directly run on the processor. JNI is simply a naming and calling convention so that the JVM (Java…
Viewers will learn about if statements in Java and their use The if statement: The condition required to create an if statement: Variations of if statements: An example using if statements:
This theoretical tutorial explains exceptions, reasons for exceptions, different categories of exception and exception hierarchy.

744 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

11 Experts available now in Live!

Get 1:1 Help Now