Doubly linked lists
Download
1 / 54

Doubly-Linked Lists - PowerPoint PPT Presentation


  • 176 Views
  • Updated On :

Doubly-Linked Lists. Same basic functions operate on list Each node has a forward and backward link: What advantages does a doubly-linked list offer?. 88. 42. 109. NULL. NULL. head_ptr. Doubly-Linked Lists. Same basic functions operate on list Each node has a forward and backward link:

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Doubly-Linked Lists' - randi


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Doubly linked lists l.jpg
Doubly-Linked Lists

  • Same basic functions operate on list

  • Each node has a forward and backward link:

  • What advantages does a doubly-linked list offer?

88

42

109

NULL

NULL

head_ptr


Doubly linked lists2 l.jpg
Doubly-Linked Lists

  • Same basic functions operate on list

  • Each node has a forward and backward link:

  • What advantages does a doubly-linked list offer?

    Cursor can move forwards and backwards in list.

88

42

109

NULL

NULL

head_ptr


Stacks and queues l.jpg

Stacks and Queues

Kruse and Ryba Ch 2 and 3


What is a stack l.jpg
What is a stack?

  • It is an ordered group of homogeneous items of elements.

  • Elements are added to and removed from the top of the stack (the mostrecently added items are at the top of the stack).

  • The last element to be added is the first to be removed (LIFO: Last In, First Out).


Stack specification l.jpg
Stack Specification

  • Definitions: (provided by the user)

    • MAX_ITEMS: Max number of items that might be on the stack

    • ItemType: Data type of the items on the stack

  • Operations

    • MakeEmpty

    • Boolean IsEmpty

    • Boolean IsFull

    • Push (ItemType newItem)

    • Pop (ItemType& item) (or pop and top)


Push itemtype newitem l.jpg
Push (ItemType newItem)

  • Function: Adds newItem to the top of the stack.

  • Preconditions: Stack has been initialized and is not full.

  • Postconditions: newItem is at the top of the stack.


Pop itemtype item l.jpg
Pop (ItemType& item)

  • Function: Removes topItem from stack and returns it in item.

  • Preconditions: Stack has been initialized and is not empty.

  • Postconditions: Top element has been removed from stack and itemis a copy of the removed element.


Stack implementation l.jpg
Stack Implementation

#include "ItemType.h"

// Must be provided by the user of the class

// Contains definitions for MAX_ITEMS and ItemType

class StackType {

public:

StackType();

void MakeEmpty();

bool IsEmpty() const;

bool IsFull() const;

void Push(ItemType);

void Pop(ItemType&);

private:

int top;

ItemType items[MAX_ITEMS];

};


Stack implementation cont l.jpg
Stack Implementation (cont.)

StackType::StackType()

{

top = -1;

}

void StackType::MakeEmpty()

{

top = -1;

}

bool StackType::IsEmpty() const

{

return (top == -1);

}


Stack implementation cont12 l.jpg
Stack Implementation (cont.)

bool StackType::IsFull() const

{

return (top == MAX_ITEMS-1);

}

 void StackType::Push(ItemType newItem)

{

top++;

items[top] = newItem;

}

 void StackType::Pop(ItemType& item)

{

item = items[top];

top--;

}


Slide13 l.jpg

Stack overflow

  • The condition resulting from trying to push an element onto a full stack.

    if(!stack.IsFull())

    stack.Push(item);

    Stack underflow

  • The condition resulting from trying to pop an empty stack.

    if(!stack.IsEmpty())

    stack.Pop(item);


Implementing stacks using templates l.jpg
Implementing stacks using templates

  • Templates allow the compiler to generate multiple versions of a class type or a function by allowing parameterized types.


Implementing stacks using templates15 l.jpg
Implementing stacks using templates

(cont.)

template<class ItemType>

class StackType {

public:

StackType();

void MakeEmpty();

bool IsEmpty() const;

bool IsFull() const;

void Push(ItemType);

void Pop(ItemType&);

private:

int top;

ItemType items[MAX_ITEMS];

};


Example using templates l.jpg
Example using templates

// Client code

StackType<int> myStack;

StackType<float> yourStack;

StackType<StrType> anotherStack;

myStack.Push(35);

yourStack.Push(584.39);

The compiler generates distinct class types and gives its own internal name to each of the types.


Function templates l.jpg
Function templates

  • The definitions of the member functions must be rewritten as function templates.

    template<class ItemType>

    StackType<ItemType>::StackType()

    {

    top = -1;

    }

    template<class ItemType>

    void StackType<ItemType>::MakeEmpty()

    {

    top = -1;

    }


Function templates cont l.jpg
Function templates (cont.)

template<class ItemType>

bool StackType<ItemType>::IsEmpty() const

{

return (top == -1);

}

template<class ItemType>

bool StackType<ItemType>::IsFull() const

{

return (top == MAX_ITEMS-1);

}

template<class ItemType>

void StackType<ItemType>::Push(ItemType newItem)

{

top++;

items[top] = newItem;

}


Function templates cont19 l.jpg
Function templates (cont.)

template<class ItemType>

void StackType<ItemType>::Pop(ItemType& item)

{

item = items[top];

top--;

}


Implementing stacks using dynamic array allocation l.jpg
Implementing stacks using dynamic array allocation

private:

int top;

int maxStack;

ItemType *items;

};

template<class ItemType>

class StackType {

public:

StackType(int);

~StackType();

void MakeEmpty();

bool IsEmpty() const;

bool IsFull() const;

void Push(ItemType);

void Pop(ItemType&);


Implementing stacks using dynamic array allocation cont l.jpg
Implementing stacks using dynamic array allocation (cont.)

template<class ItemType>

StackType<ItemType>::StackType(int max)

{

maxStack = max;

top = -1;

items = new ItemType[max];

}

template<class ItemType>

StackType<ItemType>::~StackType()

{

delete [ ] items;

}


Example postfix expressions l.jpg
Example: postfix expressions

  • Postfix notation is another way of writing arithmetic expressions.

  • In postfix notation, the operator is written after the two operands.

    infix: 2+5 postfix: 2 5 +

  • Expressions are evaluated from left to right.

  • Precedence rules and parentheses are never needed!!



Postfix expressions algorithm using stacks cont l.jpg
Postfix expressions:Algorithm using stacks (cont.)


Postfix expressions algorithm using stacks l.jpg
Postfix expressions:Algorithm using stacks

WHILE more input items exist

Get an item

IF item is an operand

stack.Push(item)

ELSE

stack.Pop(operand2)

stack.Pop(operand1)

Compute result

stack.Push(result)

stack.Pop(result)


Slide26 l.jpg

  • Write the body for a function that replaces each copy of an item in a stack with another item. Use the following specification. (this function is a client program).

    ReplaceItem(StackType& stack, ItemType oldItem, ItemType newItem)

    Function: Replaces all occurrences of oldItem with newItem.

    Precondition: stack has been initialized.

    Postconditions: Each occurrence of oldItem in stack has been replaced by newItem.

    (You may use any of the member functions of the StackType, but you may not assume any knowledge of how the stack is implemented).


Slide27 l.jpg

1 item in a stack with another item. Use the following specification. (this function is a

3

5

2

3

1

3

5

1

Stack

tempStack

{

ItemType item;

StackType tempStack;

while (!Stack.IsEmpty()) {

Stack.Pop(item);

if (item==oldItem)

tempStack.Push(newItem);

else

tempStack.Push(item);

}

while (!tempStack.IsEmpty()) {

tempStack.Pop(item);

Stack.Push(item);

}

}

Stack

oldItem = 2

newItem = 5


What is a queue l.jpg
What is a queue? item in a stack with another item. Use the following specification. (this function is a

  • It is an ordered group of homogeneous items of elements.

  • Queues have two ends:

    • Elements are added at one end.

    • Elements are removed from the other end.

  • The element added first is also removed first (FIFO: First In, First Out).

tail

queue

head

elements

enter

elements

exit

4

3

2

1

no changes of order


Queue specification l.jpg
Queue Specification item in a stack with another item. Use the following specification. (this function is a

  • Definitions: (provided by the user)

    • MAX_ITEMS: Max number of items that might be on the queue

    • ItemType: Data type of the items on the queue

  • Operations

    • MakeEmpty

    • Boolean IsEmpty

    • Boolean IsFull

    • Enqueue (ItemType newItem)

    • Dequeue (ItemType& item) (serve and retrieve)


Enqueue itemtype newitem l.jpg
Enqueue (ItemType newItem) item in a stack with another item. Use the following specification. (this function is a

  • Function: Adds newItem to the rear of the queue.

  • Preconditions: Queue has been initialized and is not full.

  • Postconditions: newItem is at rear of queue.


Dequeue itemtype item l.jpg
Dequeue (ItemType& item) item in a stack with another item. Use the following specification. (this function is a

  • Function: Removes front item from queue and returns it in item.

  • Preconditions: Queue has been initialized and is not empty.

  • Postconditions: Front element has been removed from queue and item is a copy of removed element.


Implementation issues l.jpg
Implementation issues item in a stack with another item. Use the following specification. (this function is a

  • Implement the queue as a circular structure.

  • How do we know if a queue is full or empty?

  • Initialization of front and rear.

  • Testing for a full or empty queue.


Slide35 l.jpg

Make item in a stack with another item. Use the following specification. (this function is a front point to the element preceding the front element in the queue (one memory location will be wasted).


Slide36 l.jpg

Initialize item in a stack with another item. Use the following specification. (this function is a front and rear


Slide37 l.jpg

Queue is empty now!! item in a stack with another item. Use the following specification. (this function is a

rear == front


Queue implementation l.jpg
Queue Implementation item in a stack with another item. Use the following specification. (this function is a

private:

int front;

int rear;

ItemType* items;

int maxQue;

};

template<class ItemType>

class QueueType {

public:

QueueType(int);

QueueType();

~QueueType();

void MakeEmpty();

bool IsEmpty() const;

bool IsFull() const;

void Enqueue(ItemType);

void Dequeue(ItemType&);


Queue implementation cont l.jpg
Queue Implementation (cont.) item in a stack with another item. Use the following specification. (this function is a

template<class ItemType>

QueueType<ItemType>::QueueType(int max)

{

maxQue = max + 1;

front = maxQue - 1;

rear = maxQue - 1;

items = new ItemType[maxQue];

}


Queue implementation cont40 l.jpg
Queue Implementation (cont.) item in a stack with another item. Use the following specification. (this function is a

template<class ItemType>

QueueType<ItemType>::~QueueType()

{

delete [] items;

}


Queue implementation cont41 l.jpg
Queue Implementation (cont.) item in a stack with another item. Use the following specification. (this function is a

template<class ItemType>

void QueueType<ItemType>:: MakeEmpty()

{

front = maxQue - 1;

rear = maxQue - 1;

}


Queue implementation cont42 l.jpg
Queue Implementation (cont.) item in a stack with another item. Use the following specification. (this function is a

template<class ItemType>

bool QueueType<ItemType>::IsEmpty() const

{

return (rear == front);

}

template<class ItemType>

bool QueueType<ItemType>::IsFull() const

{

return ( (rear + 1) % maxQue == front);

}


Queue implementation cont43 l.jpg
Queue Implementation (cont.) item in a stack with another item. Use the following specification. (this function is a

template<class ItemType>

void QueueType<ItemType>::Enqueue (ItemType newItem)

{

rear = (rear + 1) % maxQue;

items[rear] = newItem;

}


Queue implementation cont44 l.jpg
Queue Implementation (cont.) item in a stack with another item. Use the following specification. (this function is a

template<class ItemType>

void QueueType<ItemType>::Dequeue (ItemType& item)

{

front = (front + 1) % maxQue;

item = items[front];

}


Queue overflow l.jpg
Queue overflow item in a stack with another item. Use the following specification. (this function is a

  • The condition resulting from trying to add an element onto a full queue.

    if(!q.IsFull())

    q.Enqueue(item);


Queue underflow l.jpg
Queue underflow item in a stack with another item. Use the following specification. (this function is a

  • The condition resulting from trying to remove an element from an empty queue.

    if(!q.IsEmpty())

    q.Dequeue(item);


Example recognizing palindromes l.jpg
Example: recognizing palindromes item in a stack with another item. Use the following specification. (this function is a

  • A palindrome is a string that reads the same forward and backward.

    Able was I ere I saw Elba 

  • We will read the line of text into both a stack and a queue.

  • Compare the contents of the stack and the queue character-by-characterto see if they would produce the same string of characters.


Example recognizing palindromes48 l.jpg
Example: recognizing palindromes item in a stack with another item. Use the following specification. (this function is a


Example recognizing palindromes49 l.jpg
Example: recognizing palindromes item in a stack with another item. Use the following specification. (this function is a

cout << "Enter string: " << endl;

while(cin.peek() != '\\n') {

cin >> ch;

if(isalpha(ch)) {

if(!s.IsFull())

s.Push(toupper(ch));

if(!q.IsFull())

q.Enqueue(toupper(ch));

}

}

#include <iostream.h>

#include <ctype.h>

#include "stack.h"

#include "queue.h“

int main()

{

StackType<char> s;

QueType<char> q;

char ch;

char sItem, qItem;

int mismatches = 0;


Example recognizing palindromes50 l.jpg
Example: recognizing palindromes item in a stack with another item. Use the following specification. (this function is a

while( (!q.IsEmpty()) && (!s.IsEmpty()) ) {

s.Pop(sItem);

q.Dequeue(qItem);

if(sItem != qItem)

++mismatches;

}

if (mismatches == 0)

cout << "That is a palindrome" << endl;

else

cout << That is not a palindrome" << endl;

return 0;

}


Case study simulation l.jpg
Case Study: Simulation item in a stack with another item. Use the following specification. (this function is a

  • Queuing System: consists of servers and queues of objects to be served.

  • Simulation: a program that determines how long items must wait in line before being served.


Case study simulation cont l.jpg
Case Study: Simulation (cont.) item in a stack with another item. Use the following specification. (this function is a

  • Inputs to the simulation:

    (1) the length of the simulation

    (2) the average transaction time

    (3) the number of servers

    (4) the average time between job arrivals


Case study simulation cont53 l.jpg
Case Study: Simulation (cont.) item in a stack with another item. Use the following specification. (this function is a

  • Parameters the simulation must vary:

    (1) number of servers

    (2) time between arrivals of items

  • Output of simulation: average wait time.


ad