1 / 43

Linked Data Structures

Learn about linked data structures, singly linked lists, and how to implement them in Java for efficient data management. Develop a deeper understanding of node definitions, adding nodes, and enhancing object-oriented principles.

leef
Download Presentation

Linked Data Structures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Linked Data Structures

  2. Linked lists • Linked data structure = capsules of data (nodes) that are connected via links • (Singly) linked list = linear structure of nodes connected via a single link to the next element • First node is called the head node • Last node is called the tail node

  3. Linked lists

  4. Linked lists • A (link or next) value of null is typically used to represent the end of the list. • An empty list is one that starts with a null value (the head is null).

  5. Integer node definition public class Node { private int mData; Node mNext; //AKA link //next, we need a ctor(s) } What access is this?

  6. Integer node definition public class Node { private int mData; private Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } } Why don’t we have a no-arg ctor? What does an empty list look like?

  7. Add a node to the beginning of the list public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } } public class Main { public static void main ( String args[] ) { Node head = null; Node n = new Node( 13 ); //add at beginning n.mNext = head; head = n; } }

  8. Add another node to the beginning of the list public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } } public class Main { public static void main ( String args[] ) { Node head = null; Node n = new Node( 13 ); //add at beginning n.mNext = head; head = n; n = new Node( 12 ); //add at beginning n.mNext = head; head = n; } } Can you draw a picture of these data structures in memory?

  9. Add a toString method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } }

  10. Add a toString method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData; } } public class Main { public static void main ( String args[] ) { Node head = null; Node n = new Node( 13 ); //add at beginning n.mNext = head; head = n; n = new Node( 12 ); //add at beginning n.mNext = head; head = n; System.out.println( head ); } } Why is this necessary?

  11. Add a toString method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class Main { public static void main ( String args[] ) { Node head = null; Node n = new Node( 13 ); //add at beginning n.mNext = head; head = n; n = new Node( 12 ); //add at beginning n.mNext = head; head = n; System.out.println( head ); } } Something interesting happens! What?

  12. How can we make this more OO? public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class Main { public static void main ( String args[] ) { Node head = null; Node n = new Node( 13 ); //add at beginning n.mNext = head; head = n; n = new Node( 12 ); //add at beginning n.mNext = head; head = n; System.out.println( head ); } }

  13. How can we make this more OO? public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class MyLinkedList { private Node mHead = null; } public class Main { public static void main ( String args[] ) { MyLinkedList mml = new MyLinkedList(); } } //end class Main

  14. Add a toString method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class MyLinkedList { private Node mHead = null; public String toString ( ) { return “” + mHead; } } public class Main { public static void main ( String args[] ) { MyLinkedList mml = new MyLinkedList(); } } //end class Main

  15. Next, let’s add an add method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class MyLinkedList { private Node mHead = null; public void add ( int n ) { … } public void add ( Node n ) { … } public String toString ( ) { return “” + mHead; } }

  16. Next, let’s add an add method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class MyLinkedList { private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } public void add ( Node n ) { … } public String toString ( ) { return “” + mHead; } } Any potential privacy leak?

  17. Next, let’s add an add method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class MyLinkedList { private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } public void add ( Node n ) { n.mNext = mHead; mHead = n; } public String toString ( ) { return “” + mHead; } } Any potential privacy leak?

  18. Next, let’s add an add method public class Node { private int mData; Node mNext; //ctor public Node ( int value ) { mData = value; mNext = null; } //accessor public int getData ( ) { return mData; } public String toString ( ) { return "" + mData + “ ” + mNext; } } public class MyLinkedList { private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } public void add ( Node n ) { n = new Node( n.getData() ); n.mNext = mHead; mHead = n; } public String toString ( ) { return “” + mHead; } } Corrected potential privacy leak.

  19. Precondtion(s) public class MyLinkedList { private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } public void add ( Node n ) { n = new Node( n.getData() ); n.mNext = mHead; mHead = n; } public String toString ( ) { return “” + mHead; } } What precondition is important here?

  20. Analysis of algorithm – computational complexity public class MyLinkedList { private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } public void add ( Node n ) { n = new Node( n.getData() ); n.mNext = mHead; mHead = n; } public String toString ( ) { return “” + mHead; } } Is either add method dependent on the current size of the list?

  21. Add to the tail of the list public class MyLinkedList { private Node mHead = null; public void addTail ( Node n ) { if (mHead==null) { … } else { … } } … }

  22. Add to the tail of the list public class MyLinkedList { private Node mHead = null; public void addTail ( Node n ) { if (mHead==null) { n.mNext = null; mHead = n; } else { … } } … }

  23. Add to the tail of the list public class MyLinkedList { private Node mHead = null; public void addTail ( Node n ) { if (mHead==null) { n.mNext = null; mHead = n; } else { Node temp = mHead; while (temp.mNext!=null) { temp = temp.mNext; } n.mNext = null; temp.mNext = n; } } … } Is the addTail method dependent on the current size of the list? Convert this while-loop to a for-loop.

  24. Linked list • The linked list is so useful that Sun has provided us with one! • See http://java.sun.com/j2se/1.5.0/docs/api/java/util/LinkedList.html • There is also a List interface. • See http://java.sun.com/j2se/1.5.0/docs/api/java/util/List.html

  25. Example of creating a linked list • Other useful functions: • void clear ( ) • Removes all of the elements from this list. • boolean contains ( Object o ) • Returns true if this list contains the specified element. • E get ( int index ) • Returns the element at the specified position in this list.

  26. Example of creating a linked list • Other useful functions: • E remove ( int index ) • Removes the element at the specified position in this list. • boolean remove ( Object o ) • Removes the first occurrence in this list of the specified element. • int size ( ) • Returns the number of elements in this list.

  27. Example of creating a linked list • Other useful functions: • void add ( int index, E element ) • Inserts the specified element at the specified position in this list. • E set ( int index, E element ) • Replaces the element at the specified position in this list with the specified element. • boolean isEmpty ( ) • Returns true if this list contains no elements.

  28. Variations on a theme (different types of lists) • Singly linked • Circular

  29. Variations on a theme (different types of lists) • Doubly linked

  30. Our linked list and an inner class • Often the user doesn’t need to know about the Node class. • Let’s modify MyLinkedList to use an inner class for the Node.

  31. Our linked list and an inner class public class MyLinkedList2 { // - - - - - - - - - private class Node { private int mData; private Node mNext; public Node ( int value ) { //ctor mData = value; mNext = null; } public String toString ( ) { return "" + mData + " " + mNext; } } //end class Node // - - - - - - - - - private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } public void addTail ( int value ) { Node n = new Node( value ); if (mHead==null) { n.mNext = null; mHead = n; } else { Node temp = mHead; while (temp.mNext!=null) { temp = temp.mNext; } n.mNext = null; temp.mNext = n; } } public String toString ( ) { return "" + mHead; } } //end class MyLinkedList2

  32. Our linked list and an inner class public class MyLinkedList2 { // - - - - - - - - - private class Node { private int mData; private Node mNext; public Node ( int value ) { //ctor mData = value; mNext = null; } public String toString ( ) { return "" + mData + " " + mNext; } } //end class Node // - - - - - - - - - private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } … public int removeHead ( ) { ? } … public String toString ( ) { return "" + mHead; } } //end class MyLinkedList2

  33. Our linked list and an inner class public class MyLinkedList2 { // - - - - - - - - - private class Node { private int mData; private Node mNext; public Node ( int value ) { //ctor mData = value; mNext = null; } public String toString ( ) { return "" + mData + " " + mNext; } } //end class Node // - - - - - - - - - private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } … public int removeHead ( ) { int temp = mHead.mData; mHead = mHead.mNext; return temp; } … public String toString ( ) { return "" + mHead; } } //end class MyLinkedList2 But wait! How can we access these private members?

  34. Finally, how can we convert it to a generic? public class MyLinkedList2 { // - - - - - - - - - private class Node { private int mData; private Node mNext; public Node ( int value ) { //ctor mData = value; mNext = null; } public String toString ( ) { return "" + mData + " " + mNext; } } //end class Node // - - - - - - - - - private Node mHead = null; public void add ( int n ) { Node temp = new Node( n ); temp.mNext = mHead; mHead = temp; } public void addTail ( int value ) { Node n = new Node( value ); if (mHead==null) { n.mNext = null; mHead = n; } else { Node temp = mHead; while (temp.mNext!=null) { temp = temp.mNext; } n.mNext = null; temp.mNext = n; } } public String toString ( ) { return "" + mHead; } } //end class MyLinkedList2

  35. Finally, how can we convert it to a generic? public class MyLinkedList3<T> { private class Node<T> { private T mData; private Node<T> mNext; public Node ( T value ) { //ctor mData = value; mNext = null; } public String toString ( ) { return "" + mData + " " + mNext; } } //end class Node private Node<T> mHead = null; public void add ( T n ) { Node<T> temp = new Node<T>( n ); temp.mNext = mHead; mHead = temp; } public void addTail ( T value ) { Node<T> n = new Node<T>( value ); if (mHead==null) { n.mNext = null; mHead = n; } else { Node<T> temp = mHead; while (temp.mNext!=null) { temp = temp.mNext; } n.mNext = null; temp.mNext = n; } } public T removeHead ( ) {T temp = mHead.mData; mHead = mHead.mNext; return temp; } public String toString ( ) { return "" + mHead; }} //end class MyLinkedList3

  36. Using our generic, MyLinkedList3<T> MyLinkedList3<Integer> mml3 = new MyLinkedList3<Integer>(); mml3.add( 192 ); System.out.println( mml3 );

  37. Stack • A stack is a data structure with the major operations of: • push – adds an item to the head • pop – removes an item from the head • isEmpty – true when the stack is empty; false otherwise • A stack is also described as a LIFO (Last In, First Out)

  38. Stack

  39. Queue • A queue is a data structure with the major operations of: • enq (enqueue) – adds an item to the tail • deq (dequeue) – removes an item from the head • isEmpty – true when the queue is empty; false otherwise • A queue is also described as a FIFO (First In, First Out)

  40. Queue

  41. Sets • “A set is a collection of elements in which order and multiplicity are ignored.” • (Note: Bags or multisets may have duplicate elements.) • A simple implementation of sets is a linked list.

  42. Set operations • Add elements – add a new item (an item that does not already exist) into a set • Contains – determine if a target item is a member of the set • Union – return a set that is the union (a new set of items from either set) of two sets • Intersection – return a set that is the intersection (a new set where each item is contained in both sets) of two sets • Given a particular set implementation, can you determine O (big-oh) for each operation?

  43. Additional set operations • An iterator so that every item can be retrieved from a set • Remove an item from the set • Obtain the cardinality (the number of items in the set) of the set • Given a particular set implementation, can you determine O (big-oh) for each operation?

More Related