Doubly Linked Lists

1
Doubly Linked Lists

2
Doubly Linked Lists

• One powerful variation of a linked list is the
  doubly linked list. The doubly linked list
  structure is one in which each node has a pointer
  to both its successor and its predecessor.

head
tail
3
Doubly Linked Lists

• struct Node
• char element
• Node prev
• Node next
• Node(const char echar(),
• Node pNULL, Node nNULL)
• element(e), prev(p), next(n)

4
Sentinel Nodes

• As always, implementation of a data structure
  is up to the individual. However, one way of
  implementing a double linked list is to create
  sentinel nodes at the beginning and end of the
  list.
• Pointers to the sentinel nodes can be stored in a
  data structure as data members
• Advantage Not necessary to treat the front or
  rear differently when inserting or removing

5
Empty Double Linked List

• head new Node
• tail new Node
• head-gtnext tail
• tail-gtprev head
• sz 0

6
Deque - Double-Ended Queues

• A Deque (pronounced deck) is a data structure
  in which items may be added to or deleted from
  the head or the tail. They are also known as
  doubly-ended queues.
• The Deque is typically implemented with a linked
  list, providing easy access to the front and the
  back of the list, although a dynamic array could
  also be used for this.

7
Deque - Double-Ended Queues

• The deque data structure typically has the
  following features
• How are the data related?
• Sequentially
• Operations
• insertFirst - inserts an element at the front of
  a deque
• insertLast - inserts an element at the rear of a
  deque
• removeFirst - removes an element from the front
  of a deque
• removeLast - removes an element from the rear of
  a deque
• (Note that the previous 2 functions did not
  return and data values)
• First - returns a reference to the element at the
  front
• last - returns a reference to the element at the
  rear
• size, isEmpty

8
Deque Advantages

• Removing a node from the rear of a singly linked
  list was inefficient because we had to find the
  next-to-last by searching from the head
• The deque is implemented with a doubly linked
  list. Therefore, now, removing from the rear is
  not a problem.

9
Algorithm insertFirst()

• //Create a new node t
• //Make t-gtprev point to node head
• //Make t-gtnext point to node head-gtnext (i.e.,
  u)
• Node t new Node(e,head,head-gtnext)
• //Put the address of t into head-gtnexts prev
  pointer
• //Put the address of t into heads next pointer
• head-gtnext-gtprev t
• head-gtnext t

10
Algorithm insertFirst()
Node t new Node(e,head,head-gtnext) head-gtnext-
gtprev t head-gtnext t sz
11
Algorithm removeLast()

• //Save the address of the last node as old
• Node old tail-gtprev
• //Make old-gtprev-gtnext point to node tail
• old-gtprev-gtnext tail
• //Make tail-gtprev point to node old-gtprev
• tail-gtprev old-gtprev
• //Delete old
• delete old-

12
Algorithm removeLast()
Node old tail-gtprev old-gtprev-gtnext
tail tail-gtprev old-gtprev delete old
//Recover the memory sz--