Implementing lists: linked implementations - PowerPoint PPT Presentation

Loading...

PPT – Implementing lists: linked implementations PowerPoint presentation | free to download - id: 135725-ODdkY



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Implementing lists: linked implementations

Description:

LinkedList methods:append (cont.) Create a new Node containing the element to be appended ... get, append, remove, and add all require linear time on average. ... – PowerPoint PPT presentation

Number of Views:69
Avg rating:3.0/5.0
Slides: 45
Provided by: hyperspace
Learn more at: http://www.wiley.com
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Implementing lists: linked implementations


1
Chapter 22
  • Implementing lists linked implementations

2
This chapter discusses
  • Linked lists
  • lists built through object references.
  • dynamic lists.
  • linked implementations of structures more complex
    than a simple sequence.

3
A linked list implementation
  • If the list is not empty
  • there is a first element
  • there is a last element
  • every element (except the last) has a successor
  • every element (except the first) has a
    predecessor

4
A linked list implementation (cont.)
  • An array structure is built by creating a
    reference to the collection of list elements
    which are stored sequentially in memory.
  • A linked list is built by creating a reference to
    a node of the list that, in turn contains a
    reference to another node of the list, etc.

5
LinkedList class
  • public abstract class LinkedList implements
    Cloneable
  • private class Node
  • /
  • Create a Node containing specified element.
  • /
  • public Node (Object element)
  • this.element element
  • this.next null
  • Object element
  • Node next

6
LinkedList class (cont.)
  • public abstract class LinkedList implements
    Cloneable
  • /
  • Create a Node containing specified element.
  • /
  • protected LinkedList ()
  • size 0
  • first null
  • private int size
  • private Node first

7
LinkedList class (cont.)
8
LinkedList class (cont.)
  • The component next of the last Node always has a
    value of null.
  • For the empty list, the LinkedList component
    first is null.

9
LinkedList methodsget
  • public Object get (int i)
  • Node p first
  • int pos 0
  • while (pos lt i)
  • p p.next
  • pos pos 1
  • return p.element

10
LinkedList methodsget (cont.)
  • The variable p is initialized with a reference to
    the 0-th Node of the list.

11
LinkedList methodsget (cont.)
  • Each iteration of the loop assigns p a reference
    to the next element of the list and increments
    pos.

12
LinkedList methodsget (Cont).
  • Loop invariant p references the Node containing
    the element with index pos.
  • At loop termination
  • pos i
  • p references the Node we are looking for.

13
LinkedList methodsappend
  • First, find the last element of list

14
LinkedList methodsappend (cont.)
  • Create a new Node containing the element to be
    appended
  • Set the old last Nodes next component to
    reference the new Node.
  • public void append (Object obj)
  • if (this.isEmpty())
  • first new Node(obj)
  • else
  • Node p first
  • while (p.next ! null)
  • p p.next
  • p.next new Node(obj)
  • size size 1

15
LinkedList methods remove
  • First, find the Node in front of the one we want
    to delete.

16
LinkedList methods remove (cont.)
  • Take next of the Node before the one to be
    deleted and reference it the same as the next
    field of the Node to be deleted.

17
LinkedList methods remove (cont.)
  • Since p.next is the Node to be deleted, p.next
    cannot be null.
  • Removing the first element of the list is a
    special case.

18
LinkedList methods remove (cont.)
  • public void remove (int i)
  • if (i 0)
  • first first.next
  • else
  • Node p first
  • int pos 0
  • while (pos lt i-1)
  • p p.next
  • pos pos 1
  • p.next p.next.next
  • size size - 1

19
LinkedList methods add
20
LinkedList methods add (cont.)
  • public add (int i, Object obj)
  • Node newElement new Node(obj)
  • if (i 0)
  • newElement.next first
  • first newElement
  • else
  • Node p first
  • int pos 0
  • while (pos lt i-1)
  • p p.next
  • pos pos 1
  • newElement.next p.next
  • p.next newElement
  • size size 1

21
LinkedList methods
  • get, append, remove, and add all require linear
    time on average.
  • Deleting the first element and inserting a new
    first element, are constant time operations.
  • We must be particularly careful of boundary
    cases cases involving
  • the empty list
  • a list with one element
  • the first or last element of a list
  • These may well require explicit handling.

22
LinkedList variations
  • A simple change will make append a constant time
    operation.
  • We keep a reference to both the first and last
    elements in the list.

23
LinkedList variations (cont.)
  • public append (Object obj)
  • Node newElement new Node(obj)
  • if (this.isEmpty())
  • first newElement
  • else
  • last.next newElement
  • last newElement
  • size size 1

24
LinkedList variations (cont.)
  • remove must now check explicitly for the case in
    which the last element is deleted.
  • public void remove (int i)
  • if (size 1)
  • // remove the only element
  • first null
  • last null
  • else if (i 0)
  • // remove the first element
  • first first.next

25
LinkedList variations (cont.)
  • else
  • Node p first
  • int pos 0
  • while (pos lt i-1)
  • p p.next
  • pos pos 1
  • p.next p.next.next
  • if (i size-1)
  • //last element removed
  • last p
  • size size - 1

26
Header nodes
  • One way to eliminate special cases is to employ a
    header node.
  • It contains no element, but is always present at
    the front of the list. i.e. it is referenced by
    first.

27
Header nodes (cont.)
  • private class Header extends Node
  • public Header ()
  • this.element null
  • this.next null
  • The LinkedList constructor creates the header.
  • protected LinkedList ()
  • size 0
  • first new Header()
  • last first

28
Header nodes (cont.)
  • The method append, need not check explicitly for
    the empty list.
  • public append (Object obj)
  • Node newElement new Node(obj)
  • last.next newElement
  • last newElement
  • size size 1

29
Circular lists
  • In a circular list, the last node references the
    first.
  • A circular list may or may not have a header.
  • We can traverse the entire list starting from any
    node.
  • Care must be taken to avoid infinite iterations
    or recursions.

30
Doubly-linked lists
  • Each node contains references to the preceding as
    well as to the following node.

31
Doubly-linked lists (cont.)
  • Three components
  • the list elements
  • references to its two neighboring nodes.
  • public abstract class DoublyLinkedList implements
    Cloneable
  • private int size
  • private Node header
  • private class Node
  • public Node (Object element)
  • this.element element
  • this.next null
  • this.previous null
  • Object element
  • Node next
  • Node previous

32
Doubly-linked lists (cont.)
  • protected DoublyLinkedList ()
  • size 0
  • header new Header()
  • header.next header
  • header.previous header

33
Doubly-linked lists (cont.)
  • Operations are a bit more complicated since we
    have two references in each node, but the
    combination of a circular structure and a header
    eliminates the need for handling most boundary
    cases explicitly.

34
DoublyLinkedList append
  • Set previous of the new node to reference the old
    last node.
  • Set next of the new node to reference the
    header.
  • Set previous of the header to reference the new
    node.
  • Set next component of the old last node to
    reference the new node.

35
DoublyLinkedList append (cont.)
  • public void append (Object obj)
  • Node newElement new Node(obj)
  • Node last header.previous
  • newElement.next header
  • newElement.previous last
  • last.next newElement
  • header.previous newElement
  • size size 1

36
Linked list limitations
  • Accessing elements by index is a linear time
    operation.
  • The get operation is linear. Therefore, any
    operation using the get method will be slower
    than in an array-based implementation.
  • public boolean contains (List list, Object obj)
  • int n list.size()
  • int i 0
  • while (i lt n !obj.equals(list.get(i))
  • i i 1
  • return i lt n

37
Linked list limitations (cont.)
  • This method can be implemented without get.
  • public boolean contains (LinkedList list, Object
    obj)
  • Node p list.first
  • while (p ! null !obj.equals(p.element))
  • p p.next
  • return p ! null

38
Dynamic storage allocation
  • automatic allocation memory space for automatic
    variables is allocated when the method is
    invoked, and reclaimed (deallocated) when the
    method completes.
  • Memory space for array elements is allocated when
    the array is created.
  • For a linked implementation, space required for a
    node is allocated when the node is created.

39
Garbage collection
  • Dynamically allocated space that can no longer be
    accessed is termed garbage.
  • If we create an object and then loose all
    references to the object, the memory space
    occupied by the object becomes garbage.

40
Garbage collection (cont.)
  • The Java run-time system or interpreter
    continuously looks for garbage and reclaims the
    space (garbage collection).
  • Many programming languages do not include garbage
    collection as part of their run-time systems.
  • They require programs to deallocate explicitly
    dynamically allocated space.
  • In an object-oriented environment, it is often
    difficult to know when an object no longer is
    accessible.

41
Garbage collection (cont.)
  • Dangling references are references to space that
    has been reclaimed mistakenly.
  • Such references result in errors that often are
    extremely difficult to track down.

42
Weve covered
  • Linked structures
  • nodes
  • headers
  • Doubly-linked lists
  • Circular lists
  • Time complexities
  • Dynamic storage allocation
  • garbage collection

43
Glossary
44
Glossary (cont.)
About PowerShow.com