L.L. Queues & L.L. Traversal

Basic L.L. Queue

Value Next
a pointer
b pointer
… …
g pointer
h nullptr

as a stack, this L.L. would be:

a→b→⋯→ha \rightarrow b \rightarrow \dots \rightarrow h

Pseudo-code:

class Node{
  Type data
  Node * next
}

Enqueue + Dequeue – First Versions

Variables:

Dequeue:

Pseudo-code:

dequeue(){
  temp = front
  val = front->data
  front = front->next
  delete temp
  size = size-1
  return val
}

Diagram:

Value Next
a pointer
b pointer
… …
g pointer
h nullptr

Unqueue

Pseudo-code:

enqueue(x){
  n = new node containing x
  back->next = n
  back = back->next
  size = size+1
}

Diagram:

Value Next
a pointer
b pointer
… …
g pointer
h nullptr pointer
x nullptr

Empty Queue

A stack with a

front→a←back\text{front} \rightarrow a \leftarrow \text{back}

After dequeue

front,back\text{front}, \text{back}

After enqueue(b)

front→b←back\text{front} \rightarrow b \leftarrow \text{back}

Enqueue & Dequeue are different from empty/non-empty queues.

Enqueue

Example 1: Empty queue

front,back\text{front}, \text{back}

Enqueue b

front→b←back\text{front} \rightarrow b \leftarrow \text{back}

Example 2: Starter queue

front→⋯→x←back\text{front} \rightarrow \dots \rightarrow x \leftarrow \text{back}

enqueue b

front→⋯→x→b←back\text{front} \rightarrow \dots \rightarrow x \rightarrow b \leftarrow \text{back}

Pseudo code:

enqueue(x){
  if size > 0{
    back->next = new Node(x)
    back = back->next
  } else {
    back = new Node(x)
    front = back
  }
  size = size+1
}

Dequeue

Pseudo code:

front = front->next
return value

That code has the following effect upon a queue.

front→a→b→c→d←back\text{front} \rightarrow a \rightarrow b \rightarrow c \rightarrow d \leftarrow \text{back}

becomes

front→b→c→d←back\text{front} \rightarrow b \rightarrow c \rightarrow d \leftarrow \text{back}

while returning a.

Example 1:

front→b←back\text{front} \rightarrow b \leftarrow \text{back}

dequeue (b)

front,back\text{front}, \text{back}

Example 2:

front→b→c→d←back\text{front} \rightarrow b \rightarrow c \rightarrow d \leftarrow \text{back}

dequeue

front→c→d←back\text{front} \rightarrow c \rightarrow d \leftarrow \text{back}

Return b

Pseudo code

dequeue(){
  temp = front
  val = front->data
  front = front->next
  delete temp
  size = size-1
  return val
}

Traversing the List

Pseudo code:

displayList(){
  Node * cur = front;
  while(cur!=nullptr){
    output cur->data
    cur = cur->next
  }
}

A diagram which shows the cursor going from c, to d to be (in order from front to back).

Linked List Ends

Transcriber’s note: this is the same as in 06. The left/right arrows denote a double linked list, even though the current set of slides is talking about only singly linked lists.

For [4, 5, 6]:

head↔beginning node↔4↔5↔6↔ending node↔tail \text{head} \leftrightarrow \text{beginning node} \leftrightarrow 4 \leftrightarrow 5 \leftrightarrow 6 \leftrightarrow \text{ending node} \leftrightarrow \text{tail}

versus

head↔4↔5↔6↔tail \text{head} \leftrightarrow 4 \leftrightarrow 5 \leftrightarrow 6 \leftrightarrow \text{tail}

For [5]:

head↔beginning node↔5↔ending node↔tail \text{head} \leftrightarrow \text{beginning node} \leftrightarrow 5 \leftrightarrow \text{ending node} \leftrightarrow \text{tail}

versus

head↔5↔tail\text{head} \leftrightarrow 5 \leftrightarrow \text{tail}

For []:

head↔beginning node↔ending node↔tail\text{head} \leftrightarrow \text{beginning node} \leftrightarrow \text{ending node} \leftrightarrow \text{tail}

versus

head,tail\text{head} , \text{tail}

List Class: Traversing the List

Pseudo code:

displayList(){
  Node * cur = head->next
  while(cur!=tail){
    output cur->data
    cur = cur->next
  }
}

Graphic of cur moving through each (empty) element of the queue.

End