Data Structures (CS301) LAB

Transcription

1 Data Structures (CS301) LAB Objectives The objectives of this LAB are, o Enabling students to implement Doubly Linked List practically using c++ and adding more functionality in it. Introduction to Singly Linked List data structure Linked Memory Linked Memory is the collection of objects in which each object is pointing to next object in linear form as shown below, Node 1 Node 2 Node 3 Node 4 Node 5 Node 6 For using the linked memory (collection of linked objects of same type) it is necessary to keep the pointer of next object in the previous object so we use a variable of pointer to same object type in every object it is explained below as well, A Single Node Value Node * ptr Each cell in linked memory is called a Node. We can link infinite number of nodes according to our requirements similarly we can also remove as much number of nodes as possible from our linked memory so linked memory is dynamic which is not possible in the case of arrays that have fixed length defined at the time of their creation that can neither be increased nor decreased as shown below, Array of 5 elements (fixed size once created) Link List (Dynamic size) (In start only head LinkList size = 0) Data Structures (CS301) 1

2 (After adding three nodes LinkList size = 3) (After removing two nodes only one node left LinkList size = 1) (After adding another node LinkList size = 2) Singly Linked List uses the concept of Linked Memory to store data values, in simple words it is linear collection of Nodes connected together. Link List (Linear Structure) All these nodes are independent of each other and connected using pointers. An analogy: Suppose in a shopping store there are 10 empty shopping carts available for coming customers as shown below, When a customers come he takes a shopping cart and start putting the things he want to purchase in it in case shopping cart is full he takes another empty shopping cart and he can take as many shopping carts as he needs. Now suppose three customers A, B and C used 1, 2 and 3 shopping carts respectively for putting there goods as shown below, Data Structures (CS301) 2

3 Customer A Customer B Customer C So 6 shopping carts were used and there are 4 shopping carts available for new customers. If we see this scenario in the context of link list, The total number of shopping cart corresponds to the available computer memory. The customers with shopping cart make a linked list. You can well imagine that we can t define the fix size for this sort of memory requirements (shopping cart) because the no of persons demanding the shopping cart will change from time to time. At 8:00 am At 10:00 am At 12:00 pm At 2:00 pm Fig. LinkList status at different times Now suppose our customers A, B and C are computer processes that are requesting memory in the form of small nodes from all the available computer memory. We can t allocate these nodes easily to processes as we are allocating shopping carts to customers in the case of shopping store. The problem is described below, Problem: We have computer memory in the form of large collection of bytes and many processes including those who belong to operating system itself are using this memory randomly when they need some memory they request for it to the operating system and get it Data Structures (CS301) 3

4 For example in case of three processes A, B and C an example diagram at a certain time is shown below, A Single Node int Value Node * ptr A single Node in Memory An integer (two bytes) Pointer (two bytes) Suppose we created three nodes for our program they will be stored in memory at different locations as given below, Node I Node II Node III Now the question arises how we will access all these nodes, as these are present at different memory locations, we solve this problem by making a logical chain of nodes by connecting these nodes by pointers as shown below, Data Structures (CS301) 4

5 Node Pointer of first node points to second node int value of node in two bytes node pointer having address of next node(two bytes) int value of node in two bytes node pointer having address of next node(two bytes) Node I Node II Node Pointer of second node points to third node int value of node in two bytes node pointer having address of next node(two bytes) Node III Implementation of Doubly linked list using Dev c++: To implement doubly link list we use the same concept as for singly link list we need mainly two classes one is class node (like shopping cart) and second is the single link list class used to manage (add and remove) these nodes. Data Structures (CS301) 5

6 The node class for singly link list is given blow, class Node private: The data members of this Node class int object; Node * nextnode; One is of int type to store our data Second is Node pointer (Node * ) to store the address of next node. public: void set (int ); int get(); void setnext(node * ) Node * getnext( ) Functions of this Node class As our node class has two members first data member is int variable to store an integer value in this node and second is pointer to next node) so there should be four functions, two for integer member (one for getting its value and one for setting its value) similarly two for Node pointer member. ; Then we wrote a link list class so that we can create and mange a link list using the node class objects. Doubly Link List Implementation: For doubly link list there will be two pointers in node class one to point to next node and other to point to previous node as shown below, Data Structures (CS301) 6

7 class Node private: int object; Node * nextnode; Node * prevnode; The data members of this Node class One is of int type to store our data Second is Node pointer (Node * ) to store the address of next node. Third is Node pointer (Node * ) to store the address of previous node. public: /* Necessary functions to set and get the value of private data members of this node As node has now three members so there will be six functions now */ ; We will also write a doubly link list class to mange this node class, the functions we will write for this node class are given below with their description, DoublyLinkedList constructor This will be called once when we will create the doubly linked list object. In it we will create head node and will set this head node next and previous node pointers to NULL and list size equal to zero. We will also set currentnode and lastcurrentnode pointers to NULL. Pointers data members are assigned a value called NULL so that they don t point to any incorrect memory location before we assign them a value later ) Data Structures (CS301) 7

8 add Method next Method prev Method get Method Traverse forward method Traverse backward method This will add a new Node to the list it is similar to singly link list add method with the change that now we will also set prevnode pointer to previous node pointer. Will move the currentnode and lastcurrrentnode pointers one node ahead. Will move currentnode and lastcurrentnode pointers to one node backward. This method will return the current node value (the node pointed by currentnode pointer) This method will traverse (move from first node called head to last node called tail of the list) and will show each node value. This method will traverse backward (move from last node called tail to the first node head of the list) and will show each node value. The process for this doubly link list project is shown below, Create new project: Data Structures (CS301) 8

9 Save this project file in a new folder, Now we will add new files in this project first adding Node.h as shown below, Data Structures (CS301) 9

10 Then we will write the code for Node.h as shown below, Data Structures (CS301) 10

11 Similarly we will add three more files, having names, Node.cpp DoublyLinkList.h DoublyLinkList.cpp Data Structures (CS301) 11

12 Our project will look like this, The basic code for doubly link list we will write in these files is given below, /*Node.h file*/ #include <iostream> #include <stdlib.h> using namespace std; /* The Node class declaration */ class Node public: int get(); void set(int ); Node * getnext(); void setnext(node *); Node * getprev(); void setprev(node *); private: int object; Node * nextnode; Node * prevnode; ; /*Node.cpp file*/ #include "Node.h" Data Structures (CS301) 12

13 /* The Node class implementation*/ int Node:: get() return object; void Node:: set(int object) this->object = object; Node * Node::getNext() return nextnode; void Node:: setnext(node * nextnode) this->nextnode = nextnode; Node * Node::getPrev() return prevnode; void Node:: setprev(node * prevnode) this->prevnode = prevnode; /*DoublyLinkList.h file*/ #include "Node.h" /* The LinkList class declaration*/ class DoublyLinkList public: DoublyLinkList(); void add (int addobject); Data Structures (CS301) 13

14 int get(); bool next(); bool prev (); friend void traverseforward(doublylinklist list); friend void traversereverse(doublylinklist list); friend DoublyLinkList addnodes(); private: int size; Node * headnode; Node * currentnode; Node * lastcurrentnode; ; /*DoublyLinkList.cpp file*/ #include "DoublyLinkList.h" /* The LinkList class implementation*/ /* Constructor */ DoublyLinkList::DoublyLinkList() headnode = new Node(); headnode->setnext(null); headnode->setprev(null); currentnode = NULL; lastcurrentnode = NULL; size = 0; /* add() class method */ void DoublyLinkList::add (int addobject) Node * newnode = new Node(); newnode->set(addobject); if( currentnode!= NULL ) // If list is not empty newnode->setnext(currentnode->getnext()); if (currentnode->getnext()!= NULL) currentnode->getnext()->setprev(newnode); Data Structures (CS301) 14

15 newnode->setprev(currentnode); currentnode->setnext( newnode ); lastcurrentnode = currentnode; currentnode = newnode; else // If list is empty newnode->setnext(null); newnode->setprev(headnode); headnode->setnext(newnode); lastcurrentnode = headnode; currentnode = newnode; size ++; /* get() class method */ int DoublyLinkList::get() if (currentnode!= NULL) return currentnode->get(); /* next() class method */ bool DoublyLinkList::next() if (currentnode == NULL) return false; // no node in list lastcurrentnode = currentnode; currentnode = currentnode->getnext(); if (currentnode == NULL size == 0) // we have reached at the tail no more nodes return false; else return true; /* prev() class method */ bool DoublyLinkList::prev() if (currentnode == NULL) return false; // no node in list Data Structures (CS301) 15

16 currentnode = lastcurrentnode; lastcurrentnode = lastcurrentnode->getprev(); if (lastcurrentnode == NULL size == 0) // we have reached at the head no more nodes return false; else return true; /* Friend function to traverse linked list */ void traverseforward(doublylinklist list) Node* savedcurrentnode = list.currentnode; list.currentnode = list.headnode; cout<<"\n Traversing in Forward Direction"; for(int i = 1; list.next(); i++) cout << "\n Element " << i << " of the list is " << list.get()<< endl; list.currentnode = savedcurrentnode; void traversereverse(doublylinklist list) Node* savedcurrentnode = list.currentnode; cout<<"\n Traversing in Reverse Direction"; do cout << "\n Element " << list.size << " of the list is " << list.get()<< endl; list.size = list.size -1; while (list.prev()); list.currentnode = savedcurrentnode; Data Structures (CS301) 16

17 /* Friend function to add Nodes into the list */ DoublyLinkList addnodes() DoublyLinkList list; int temp; for(int i = 0; i < 9 ; i++) cout <<"\n Please Enter the Element No # "<<i+1<<": "; cin>>temp; list.add(temp); cout << "\n\n List size is = " << list.size <<'\n'; return list; /*Main file code*/ #include "DoublyLinkList.h" int main() DoublyLinkList list = addnodes(); traverseforward(list); traversereverse(list); system("pause"); return 0; Data Structures (CS301) 17

18 Sample out put is What you have to submit: You have to submit the doubly link list project as we created and discussed above with the sample given code, but you will add the integer part of your roll number in your doubly link list addnodes method for example if someone has roll no. bc , he will add integers 0 2 Data Structures (CS301) 18

19 In the same order as in this list You will add two more friend functions in doubly link list class as described below: 1. First function will get the first four integers and will show the student batch for example in case of roll number. bc the batch to be displayed will be, Second function will add all the entered roll number integers and will check whether the result is even or odd and will show the result. For example out put for this function may be, The sum is Even Assignment Submission Instructions: Please submit you project as single zipped file having all the functionalities mentioned above. Good Luck Data Structures (CS301) 19