c programming from problem analysis to program design second edition
Download
Skip this Video
Download Presentation
C++ Programming: From Problem Analysis to Program Design, Second Edition

Loading in 2 Seconds...

play fullscreen
1 / 81

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


  • 86 Views
  • Uploaded on

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

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 'C++ Programming: From Problem Analysis to Program Design, Second Edition' - omar-frederick


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
c programming from problem analysis to program design second edition
0

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

Chapter 17: Linked Lists

objectives
0Objectives

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

introduction
0Introduction
  • 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

linked lists
0Linked 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

a linked list
‘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

dynamic linked list
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

nodes can be located anywhere in memory
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

declarations for a dynamic linked list
‘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

pointer dereferencing and member selection
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 is a pointer to a node
ptr

.info .link

0

ptr is a pointer to a node

‘A’ 6000

ptr

10

ptr is the entire node pointed to by ptr
ptr

0

*ptr is the entire node pointed to by ptr

‘A’ 6000

.info .link

*ptr

11

ptr info is a node member
ptr

.info .link

0

ptr->infois a node member

‘A’ 6000

ptr->info

(*ptr).info // equivalent

12

ptr link is a node member
ptr

.info .link

0

ptr->linkis a node member

‘A’ 6000

ptr->link

(*ptr).link // equivalent

13

traversing a dynamic linked list
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

traversing a dynamic linked list1
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

traversing a dynamic linked list2
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

traversing a dynamic linked list3
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

traversing a dynamic linked list4
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

traversing a dynamic linked list5
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

traversing a dynamic linked list6
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

traversing a dynamic linked list7
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

traversing a dynamic linked list8
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

traversing a dynamic linked list9
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

traversing a dynamic linked list10
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

traversing a dynamic linked list11
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

using operator new
0Using 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

inserting a node at the front of a list
‘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;

inserting a node at the front of a list1
‘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

inserting a node at the front of a list2
‘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

inserting a node at the front of a list3
‘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

inserting a node at the front of a list4
‘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

inserting a node at the front of a list5
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

using operator delete
0Using 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

deleting the first node from the list
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

deleting the first node from the list1
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

deleting the first node from the list2
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

deleting the first node from the list3
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

deleting the first node from the list4
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

what is a list
0What 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
struct nodetype
0struct 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

slide41
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

slide42
‘C’ ‘L’ ‘X’

0

class SortedList2

SortedList2

Private data:

head

~SortedList2

IsEmpty

Print

InsertTop

Insert

DeleteTop

Delete

insert algorithm
0Insert 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?
insert algorithm for sortedlist2
0Insert 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
implementing sortedlist2 member function insert
0Implementing 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

{

.

.

.

}

slide46
‘C’ ‘L’ ‘X’

0

Inserting ‘S’ into a Sorted List

prevPtr currPtr

Private data:

head

slide47
‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

NULL

Private data:

head

slide48
‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

Private data:

head

slide49
‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

Private data:

head

slide50
‘S’

0

Inserting ‘S’ into Proper Position

prevPtr currPtr

Private data:

head

‘C’ ‘L’ ‘X’

slide51
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

slide52
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

slide53
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

slide54
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

slide55
‘C’ ‘L’ ‘X’

class SortedList2

SortedList2

Private data:

head

~SortedList2

IsEmpty

Print

InsertTop

Insert

DeleteTop

Delete

another linked list
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 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 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
Delete a Node
  • Consider the list shown in the figure below

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

programming example
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
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 continued1
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
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
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
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
  • 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 (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
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
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
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
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
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

summary1
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

summary2
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

ad