C programming from problem analysis to program design second edition
This presentation is the property of its rightful owner.
Sponsored Links
1 / 81

C++ Programming: From Problem Analysis to Program Design, Second Edition PowerPoint PPT Presentation


  • 62 Views
  • Uploaded on
  • Presentation posted in: General

0. C++ Programming: From Problem Analysis to Program Design, Second Edition. Chapter 17: Linked Lists. 0. Objectives. In this chapter you will: Learn about linked lists Become aware of the basic properties of linked lists Explore the insertion and deletion operations on linked lists

Download Presentation

C++ Programming: From Problem Analysis to Program Design, Second Edition

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


0

C++ Programming: From Problem Analysisto Program Design, Second Edition

Chapter 17: Linked Lists


0

Objectives

In this chapter you will:

  • Learn about linked lists

  • Become aware of the basic properties of linked lists

  • Explore the insertion and deletion operations on linked lists

  • Discover how to build and manipulate a linked list

  • Learn how to construct a doubly linked list

C++ Programming: From Problem Analysis to Program Design, Second Edition


0

Introduction

  • Data can be organized and processed sequentially using an array, called a sequential list

  • Problems with an array

    • Array size is fixed

    • Unsorted array: searching for an item is slow

    • Sorted array: insertion and deletion is slow

C++ Programming: From Problem Analysis to Program Design, Second Edition


0

Linked Lists

  • Linked list: collection of components (nodes)

  • Every node (except last) has address of next node

  • Every node has two components

  • Address of the first node of the list is stored in a separate location, called head or first

C++ Programming: From Problem Analysis to Program Design, Second Edition


‘X’ ‘C’ ‘L’

head

0

A Linked List

  • a linked list is a list in which the order of the components is determined by an explicit link member in each node

  • the nodes are structs--each node contains a component member and also a link member that gives the location of the next node in the list

C++ Programming: From Problem Analysis to Program Design, Second Edition


head

“Ted” “Irv” “Lee”

0

Dynamic Linked List

  • in a dynamic linked list, nodes are linked together by pointers, and an external pointer (or head pointer) points to the first node in the list

C++ Programming: From Problem Analysis to Program Design, Second Edition


3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

0

Nodes can be located anywhere in memory

  • the link member holds the memory address of the next node in the list

head

C++ Programming: From Problem Analysis to Program Design, Second Edition


‘A’6000

.info .link

0

Declarations for a Dynamic Linked List

// Type DECLARATIONS

struct NodeType {

char info;

NodeType* link;

}

// Variable DECLARATIONS

NodeType* head;

NodeType* ptr;

8


ptr

.info .link

ptr

‘A’ 6000

.info .link

*ptr

ptr

‘A’ 6000

.info .link

(*ptr).info

ptr->info

0

Pointer Dereferencing and Member Selection

‘A’ 6000

ptr

9


ptr

.info .link

0

ptr is a pointer to a node

‘A’ 6000

ptr

10


ptr

0

*ptr is the entire node pointed to by ptr

‘A’ 6000

.info .link

*ptr

11


ptr

.info .link

0

ptr->infois a node member

‘A’ 6000

ptr->info

(*ptr).info // equivalent

12


ptr

.info .link

0

ptr->linkis a node member

‘A’ 6000

ptr->link

(*ptr).link // equivalent

13


ptr

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 3000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 3000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 3000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 5000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 5000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 5000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 2000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 2000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr 2000

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr NULL

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


ptr NULL

3000 5000 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

head

0

Traversing a Dynamic Linked List

//PRE: head points to a dynamic linked list

ptr = head ;

while (ptr != NULL) {

cout << ptr->info ;

// Or, do something else with node *ptr

ptr = ptr->link ;

}

C++ Programming: From Problem Analysis to Program Design, Second Edition


0

Using Operator new

If memory is available in an area called the free store (or heap), operator new allocates the requested object, and returns a pointer to the memory allocated.

The dynamically allocated object exists until the delete operator destroys it.

26


‘X’ ‘C’ ‘L’

head

0

Inserting a Node at the Front of a List

‘B’

item

char item = ‘B’;

NodeType* location;

location = new NodeType;

location->info = item;

location->link = head;

head = location;


‘X’ ‘C’ ‘L’

head

0

Inserting a Node at the Front of a List

‘B’

item

char item = ‘B’;

NodeType* location;

location = new NodeType;

location->info = item;

location->link = head;

head = location;

location


‘X’ ‘C’ ‘L’

head

0

Inserting a Node at the Front of a List

‘B’

item

char item = ‘B’;

NodeType* location;

location = new NodeType;

location->info = item;

location->link = head;

head = location;

location


‘X’ ‘C’ ‘L’

head

0

Inserting a Node at the Front of a List

‘B’

item

char item = ‘B’;

NodeType* location;

location = new NodeType;

location->info = item;

location->link = head;

head = location;

‘B’

location


‘X’ ‘C’ ‘L’

head

0

Inserting a Node at the Front of a List

‘B’

item

char item = ‘B’;

NodeType* location;

location = new NodeType;

location->info = item;

location->link = head;

head = location;

‘B’

location


head

0

Inserting a Node at the Front of a List

‘B’

item

char item = ‘B’;

NodeType* location;

location = new NodeType;

location->info = item;

location->link = head;

head = location;

‘X’ ‘C’ ‘L’

‘B’

location


0

Using Operator delete

The object currently pointed to by the pointer is deallocated, and the pointer is considered undefined. The object’s memory is returned to the free store.

33


head

0

Deleting the First Node from the List

item

NodeType* tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

‘B’ ‘X’ ‘C’ ‘L’

tempPtr


head

0

Deleting the First Node from the List

‘B’

item

NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

‘B’ ‘X’ ‘C’ ‘L’

tempPtr


head

0

Deleting the First Node from the List

‘B’

item

NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

‘B’ ‘X’ ‘C’ ‘L’

tempPtr


head

0

Deleting the First Node from the List

‘B’

item

NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

‘B’ ‘X’ ‘C’ ‘L’

tempPtr


head

0

Deleting the First Node from the List

‘B’

item

NodeType * tempPtr;

item = head->info;

tempPtr = head;

head = head->link;

delete tempPtr;

‘X’ ‘C’ ‘L’

tempPtr


0

What is a List?

  • a list is a varying-length, linear collection of homogeneous elements

  • linear means each list element (except the first) has a unique predecessor, and each element (except the last) has a unique successor


0

struct NodeType

// SPECIFICATION FILE DYNAMIC-LINKED SORTED LIST( slist2.h )

struct NodeType

{

char item ;// Data (char to keep example simple)

NodeType* link ;// link to next node in list

} ;

40


0

// SPECIFICATION FILE DYNAMIC-LINKED SORTED LIST( slist2.h )

class SortedList2

{

public :

bool IsEmpty () const ;

void Print ( ) const ;

void InsertTop ( /* in */ char item ) ;

void Insert ( /* in */ char item ) ;

void DeleteTop ( /* out */ char& item ) ;

void Delete ( /* in */ char item );

SortedList2 ( ) ;// Constructor

~SortedList2 ( ) ;// Destructor

SortedList2 ( const SortedList2& otherList ) ; // Copy-constructor

private :

NodeType* head;

} ;

41


‘C’ ‘L’ ‘X’

0

class SortedList2

SortedList2

Private data:

head

~SortedList2

IsEmpty

Print

InsertTop

Insert

DeleteTop

Delete


0

Insert Algorithm

  • what will be the algorithm to Insert an item into its proper place in a sorted linked list?

  • that is, for a linked list whose elements are maintained in ascending order?


0

Insert algorithm for SortedList2

  • find proper position for the new element in the sorted list using two pointers prevPtr and currPtr, where prevPtr trails behind currPtr

  • obtain a node for insertion and place item in it

  • insert the node by adjusting pointers


0

Implementing SortedList2Member Function Insert

// DYNAMIC LINKED LIST IMPLEMENTATION (slist2.cpp)

void SortedList2 :: Insert ( /* in */ char item )

// PRE: item is assigned && List components in ascending order

// POST: item is in List && List components in ascending order

{

.

.

.

}


‘C’ ‘L’ ‘X’

0

Inserting ‘S’ into a Sorted List

prevPtr currPtr

Private data:

head


‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

NULL

Private data:

head


‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

Private data:

head


‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

Private data:

head


‘S’

0

Inserting ‘S’ into Proper Position

prevPtr currPtr

Private data:

head

‘C’ ‘L’ ‘X’


0

// IMPLEMENTATION DYNAMIC-LINKED SORTED LIST (slist2.cpp)

SortedList2 ::SortedList2 ( ) // Constructor

// Post: head == NULL

{

head = NULL ;

}

SortedList2 :: ~SortedList2 ( ) // Destructor

// Post: All linked nodes deallocated

{

char temp ;

// keep deleting top node

while ( !IsEmpty )

DeleteTop ( temp );

}

51


0

void SortedList2 :: Insert( /* in */ char item )

// Pre: item is assigned && list components in ascending order

// Post:new node containing item is in its proper place

// && list components in ascending order

{ NodeType* currPtr ;

NodeType* prevPtr ;

NodeType* location ;

location = new NodeType ;

location->info = item;

prevPtr = NULL ;

currPtr = head ;

while ( currPtr != NULL && item > currPtr->info )

{prevPtr = currPtr ; // advance both pointers

currPtr = currPtr->link ;

}

location->link = currPtr ; // insert new node here

if ( prevPtr == NULL )

head = location ;

else

prevPtr->link = location ;

}

52


0

void SortedList2 :: DeleteTop ( /* out */ char& item )

// Pre: list is not empty && list elements in ascending order

// Post: item == element of first list node @ entry

// && node containing item is no longer in linked list

// && list elements in ascending order

{

NodeType* tempPtr = head ;

// obtain item and advance head

item = head->info ;

head = head->link ;

delete tempPtr ;

}

53


void SortedList2 :: Delete ( /* in */ char item )

// Pre: list is not empty && list elements in ascending order

// && item == component member of some list node

// Post: item == element of first list node @ entry

// && node containing first occurrence of item is no longer

// in linked list && list elements in ascending order

{ NodeType* delPtr ;

NodeType* currPtr ;// Is item in first node?

if ( item == head->info )

{delPtr = head ;// If so, delete first node

head = head->link ;

}

else {// search for item in rest of list

currPtr = head ;

while ( currPtr->link->info != item )

currPtr = currPtr->link ;

delPtr = currPtr->link ;

currPtr->link = currPtr->link->link ;

}

delete delPtr ;

}

54


‘C’ ‘L’ ‘X’

class SortedList2

SortedList2

Private data:

head

~SortedList2

IsEmpty

Print

InsertTop

Insert

DeleteTop

Delete


Another Linked List

  • Linked list above has four nodes

  • Address of first node is stored in head

  • Each node has two components:

    • Info: stores the info

    • Link: stores address of the next node

C++ Programming: From Problem Analysis to Program Design, Second Edition


Doubly Linked Lists

  • Doubly linked list: every node has next and back pointers

  • Can be traversed in either direction

C++ Programming: From Problem Analysis to Program Design, Second Edition


Struct for Doubly Linked List

struct NodeType

{

int item ;// Data

NodeType* next;// link to next node in list

NodeType* back; // link to previous node in list

} ;

C++ Programming: From Problem Analysis to Program Design, Second Edition


Delete a Node

  • Consider the list shown in the figure below

C++ Programming: From Problem Analysis to Program Design, Second Edition


Programming Example

  • A new video store in your neighborhood is about to open

  • However, it does not have a program to keep track of its videos and customers

  • The store managers want someone to write a program for their system so that the video store can operate

C++ Programming: From Problem Analysis to Program Design, Second Edition


Programming Example (continued)

  • The program should be able to perform the following operations:

    • Rent a video; that is, check out a video

    • Return, or check in, a video

    • Create a list of videos owned by the store

    • Show the details of a particular video

    • Print a list of all videos in the store

    • Check whether a particular video is in the store

    • Maintain a customer database

    • Print list of all videos rented by each customer

C++ Programming: From Problem Analysis to Program Design, Second Edition


Programming Example (continued)

  • There are two major components of the video store:

    • A video

    • A customer

  • You need to maintain two lists:

    • A list of all videos in the store

    • A list of all customers of the store

C++ Programming: From Problem Analysis to Program Design, Second Edition


Part 1: Video Component (continued)

  • The common things associated with a video are:

    • Name of the movie

    • Names of the stars

    • Name of the producer

    • Name of the director

    • Name of the production company

    • Number of copies in store

C++ Programming: From Problem Analysis to Program Design, Second Edition


Video List

  • This program requires us to

    • Maintain a list of all videos in the store

    • Add a new video to our list

  • Use a linked list to create a list of videos

C++ Programming: From Problem Analysis to Program Design, Second Edition


Part 2: Customer Component

  • Primary characteristics of a customer:

    • First name

    • Last name

    • Account number

    • List of rented videos

C++ Programming: From Problem Analysis to Program Design, Second Edition


Basic Operations

  • Basic operations on personType:

    • Print the name

    • Set the name

    • Show the first name

    • Show the last name

C++ Programming: From Problem Analysis to Program Design, Second Edition


Basic Operations (continued)

  • Basic operations on an object of the type customerType are:

    • Print name, account #, and number of rentals

    • Set name, account #, and number of rentals

    • Rent a video, add video to the list

    • Return a video, delete video from the list

    • Show account #

C++ Programming: From Problem Analysis to Program Design, Second Edition


Main Program

  • The data in the input file is in the form:

    video title

    movie star1

    movie star2

    movie producer

    movie director

    movie production co.

    number of copies

    .

    .

    .

C++ Programming: From Problem Analysis to Program Design, Second Edition


Algorithm of the Main Function

  • Open the input file, exit if not found

  • createVideoList: create the list of videos

  • displayMenu: show the menu

  • While not done, perform various tasks

C++ Programming: From Problem Analysis to Program Design, Second Edition


CreateVideoList

  • Read data and store in a video object

  • Insert video in list

  • Repeat steps 1 and 2 for each video in file

C++ Programming: From Problem Analysis to Program Design, Second Edition


displayMenu

Select one of the following

  • Check whether a particular video is in the store

  • Check out a video

  • Check in a video

  • Check whether a particular video is in the store

  • Print the titles of all videos

  • Print a list of all videos

  • Exit

C++ Programming: From Problem Analysis to Program Design, Second Edition


Summary

  • A linked list is a list of items (nodes)

  • Order of the nodes is determined by the address, called a link, stored in each node

  • The pointer to a linked list is called head or first

  • A linked list is a dynamic data structure

  • The list length is the number of nodes

C++ Programming: From Problem Analysis to Program Design, Second Edition


Summary

  • Insertion and deletion does not require data movement; only the pointers are adjusted

  • A (single) linked list is traversed in only one direction

  • Search of a linked list is sequential

  • The head pointer is fixed on first node

  • Traverse: use a pointer other than head

C++ Programming: From Problem Analysis to Program Design, Second Edition


Summary

  • Doubly linked list

    • Every node has two links: next and previous

    • Can be traversed in either direction

    • Item insertion and deletion require the adjustment of two pointers in a node

C++ Programming: From Problem Analysis to Program Design, Second Edition


  • Login