CSC-335 Data Structures and Algorithms

(Chapter 6 Lists)

The content of this power point lecture has been originally created by Christos Kolonis and modified by Dr. Ahmad R Hadaegh
1

Chapter Contents
6.1 List as an ADT

6.2 An Array-Based Implementation of Lists

6.3 An array Based Implementation of Lists with Dynamic Allocation 6.4 Introduction to Linked Lists 6.5 A Pointer-Based Implementation of Linked Lists in C++

Chapter Objectives
To study list as an ADT
Build a static-array-based implementation of lists and note strengths, weaknesses Build a dynamic-array-based implementation of lists, noting strengths and weaknesses See need for destructor, copy constructor, assignment methods

Take first look at linked lists, note strengths, weaknesses

Study pointer-based implementation of linked lists (Optional) Study array-based implementation of linked lists

Consider Every Day Lists

List of Groceries to be purchased List of the Job to-do List of assignments for a course

Dean's list
etc
4

Properties of Lists
Can have a single element Can have no elements

There can be lists of lists

We will look at the list as an abstract data type
Homogeneous Finite length Sequential elements
5

Basic Operations
Construct an empty list Determine whether or not empty Insert an element into the list Delete an element from the list Traverse (iterate through) the list to
Modify Output Search for a specific value Copy or save Rearrange

Designing a List Class

Should contain at least the following function members
Constructor empty() insert() delete() display()

Implementation involves
Defining data members Defining function members from design phase

Array-Based Implementation of Lists

An array is a practical choice for storing list elements
Element are sequential It is a commonly available data type Algorithm development is easy

Normally sequential orderings of list elements match with array elements

Implementing Operations
Constructor
Static array allocated at compile time

56 is inserted

Empty
Check if size == 1

Traverse
Use a loop from 0th element to size 1

Insert
Shift elements to right of insertion point

25 is deleted

Delete
Shift elements back

List Class with Static Array

Must deal with issue of declaration of CAPACITY

Use typedef mechanism

typedef Some_Specific_Type ElementType ElementType array[CAPACITY];

For specific implementation of our class we simply fill in desired type for Some_Specific_Type

10

Dynamic-Allocation for List Class

Changes required in data members
Eliminate const declaration for CAPACITY Add variable data member to store capacity specified by client program Change array data member to a pointer Constructor requires considerable change

Little or no changes required for

empty() display() erase() insert()

11

Dynamic-Allocation for List Class Now possible to specify different sized lists
cin >> maxListSize; List aList1 (maxListSize); List aList2 (500);

12

New Functions Needed

Destructor
When object goes out of scope the pointer to the dynamically allocated memory is reclaimed automatically The dynamically allocated memory is not

The destructor reclaims dynamically allocated memory

13

New Functions Needed

Copy Constructor - makes a "deep copy" of an object
When argument passed as value parameter When function returns a local object When temporary storage of object needed When object initialized by another in a declaration

If copy is not made, observe results(aliasing problem, "shallow" copy)

14

New Functions Needed

Assignment Operator
Default assignment operator makes shallow copy

Can cause memory leak, dynamically-allocated memory has nothing pointing to it

15

Notes on Class Design

If a class allocates memory at run time using the new, then a it should provide A destructor A copy constructor

An assignment operator

16

Future Improvements to Our List Class Problem 1: Array used has fixed capacity Solution:
If larger array needed during program execution Allocate, and then copy smaller array to the new one

Problem 2: Class bound to one type at a time Solution:

Create multiple List classes with differing names Use class template

17

Recall Inefficiency of Array-Implemented List

insert() and erase() functions inefficient for

dynamic lists
Those that change frequently Those with many insertions and deletions

So

We look for an alternative implementation.

18

Linked List
For the array-based implementation: 1. First element is at location 0 2. Successor of item at location i is at location i + 1 3. End is at location size 1

Fix: 1) Remove requires that that list elements be stored in consecutive location
2) But then need a "link" that connects each element to its successor
19

Linked Lists !!

Linked List
Linked list nodes contain
Data part stores an element of the list

Next part stores link/pointer to next element (when no next element, null value)

20

Linked Lists Operations

Construction: first = null_value; Empty: first == null_value?

Traverse
Initialize a variable ptr to point to first node

Process data where ptr points

21

Linked Lists Operations

Traverse (ctd)
set ptr = ptr->next, process ptr->data

Continue until ptr == null

22

Operations: Insertion
predptr

newptr

20

Insertion
To insert 20 after 17 Need address of item before point of insertion

predptr points to the node containing 17 Get a new node pointed to by newptr and store 20 in it
Set the next pointer of this new node equal to the next pointer in its predecessor, thus making it point to its successor. Reset the next pointer of its predecessor to point to this new node
23

Operations: Insertion
Note: insertion also works at end of list
pointer member of new node set to null

Insertion at the beginning of the list

predptr must be set to first pointer member of newptr set to that value first set to value of newptr

Note: In all cases, no shifting of list elements is required !

24

Operations: Deletion
predptr
ptr

Delete node containing 22 from list.

Suppose ptr points to the node to be deleted predptr points to its predecessor (the 17)

To free space

Do a bypass operation:
Set the next pointer in the predecessor to point to the successor of the node (node 26) to be deleted Deallocate the node being deleted.
25

Linked Lists - Advantages Access any item as long as external link to first item maintained Insert new item without shifting Delete existing item without shifting Can expand/contract as necessary
26

Linked Lists - Disadvantages

If dynamic, must provide
destructor copy constructor

No longer have direct access to each element of the list

Many sorting algorithms need direct access Binary search needs direct access

Access of nth item now less efficient

must go through first element, and then second, and then third, etc.

27

Linked Lists - Disadvantages

List-processing algorithms that require fast access to each element cannot be done as efficiently with linked lists. Consider adding an element at the end of the list Array
a[size++] = value;

Linked List
Get a new node; set data part = value next part = null_value If list is empty Set first to point to new node. Else
Traverse list to find last node Set next part of last node to point to new node.

This is the inefficient part

28

6.5 Using C++ Pointers and Classes To Implement Nodes

class Node { public: DataType data; Node* next; };

Note that the next member is defined as a pointer to a Node

29

Working with Nodes

Declaring pointers
Node* ptr; or typedef Node * NodePointer; NodePointer ptr;

Allocate and deallocate

ptr = new Node; delete ptr;

Access the data and next part of node (*ptr).data and (*ptr).next ptr->data and ptr->next
30

or

Working with Nodes

Note data members are public
class Node { public: DataType data; Node * next;

};

This class declaration will be placed inside another class declaration for List

The data members data and next of struct Node will be public inside the class
will accessible to the member and friend functions

will be private outside the class

31

Data Members for Linked-List Implementation

A linked list will be characterized by: A pointer to the first node in the list. Each node contains a pointer to the next node in the list The last node contains a null pointer

As a variation first may be a structure also contain a count of the elements in the list
32

Class List
class Node { public: DataType data; Node* next; }; //----------------------------------------Class List { protcted: Node* top; public: List(){top = NULL;} List( List& L); // copy constructor destroy(); ~List(){destroy();}
33

Function Members for Linked-List Implementation

Constructor
Make first a null pointer and set mySize to 0
0

Destructor
Nodes are dynamically allocated by new Default destructor will not specify the delete All the nodes from that point on would be "marooned memory" A destructor must be explicitly implemented to do the delete
34

Function Members for Linked-List Implementation

deep Copy

Shallow Copy

Copy constructor for deep copy

By default, when a copy is made of a List object, it only gets the head pointer Copy constructor will make a new linked list of nodes to which copy will point
35