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


  • 60 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


C programming from problem analysis to program design second edition

0

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

Chapter 17: Linked Lists


Objectives

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


Introduction

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


Linked lists

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


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

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


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

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


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

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


Struct nodetype

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


C programming from problem analysis to program design second edition

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

‘C’ ‘L’ ‘X’

0

class SortedList2

SortedList2

Private data:

head

~SortedList2

IsEmpty

Print

InsertTop

Insert

DeleteTop

Delete


Insert algorithm

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?


Insert algorithm for sortedlist2

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


Implementing sortedlist2 member function insert

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

‘C’ ‘L’ ‘X’

0

Inserting ‘S’ into a Sorted List

prevPtr currPtr

Private data:

head


C programming from problem analysis to program design second edition

‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

NULL

Private data:

head


C programming from problem analysis to program design second edition

‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

Private data:

head


C programming from problem analysis to program design second edition

‘C’ ‘L’ ‘X’

0

Finding Proper Position for ‘S’

prevPtr currPtr

Private data:

head


C programming from problem analysis to program design second edition

‘S’

0

Inserting ‘S’ into Proper Position

prevPtr currPtr

Private data:

head

‘C’ ‘L’ ‘X’


C programming from problem analysis to program design second edition

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


C programming from problem analysis to program design second edition

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


C programming from problem analysis to program design second edition

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


C programming from problem analysis to program design second edition

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

‘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


  • Login