Content: Learning Objectives

Size: px

Start display at page:

Download "Content: Learning Objectives"

Justin Roland Craig
6 years ago
Views:

1 BLOOM PUBLIC CHOOL Vasant Kunj, New Delhi Lesson Plan Class: XII ubject: Computer cience Month : July No of s: 21 Chapter:Data structure: Linked List TTT: 8 WT: 12 Content: Learning Objectives At

1 1 BLOOM PUBLIC CHOOL Vasant Kunj, New Delhi Lesson Plan Class: XII ubject: Computer cience Month : July No of s: 21 Chapter:Data structure: Linked List TTT: 8 WT: 12 Content: Learning Objectives At the end of this chapter the students will be able to: a) Define Linked List b) Analyse the need for Linked List c) Represent ingly Linked List d) Perform Basic Operations on ingly Linked List e) Apply the Linked List / Array concepts as tacks, Queues. Resources : a) A Computer with specifically C++ compiler installed b) umita arora (Text book) c) Herbert cheldt fundamentals of c++ Assessment Class test

2 2 wise plan 1 What is a Linked List? What is its need? The teacher emphasises the need to store information as data elements pointing to the next in the sequence. The teacher then defines the linked list as A Linear Collection of data elements, called nodes pointing to the next node by means of pointers. Each Node is divided into two parts: the first part containing the information of the element, and the second part called the link or the next pointer containing the address of the next node in the list. In arrays the memory is reserved before processing. For this reason, arrays are called dense lists or static data structures. Linked lists overcome the drawbacks of arrays as in linked lists number of elements need not be predetermined, more memory can be allocated or released during the processing as and when required, making insertions and deletions much easier and simpler. 2

3 3 Each data element stored in the memory is given some memory. This process of giving main memory is called memory allocation. This can be done in two manners: Dynamically and tatically.tatic Memory Allocation This reserves fixed amount of memory before actual processing takes place, therefore, number of elements stored must be predetermined. uch a type of memory allocation is called static memory allocation. Arrays are allocated memory using this technique only. 2 and 3 Dynamic Memory Allocation This memory technique facilitates allocation of memory during the program execution itself, as and when required. This technique also facilitates release of memory if memory is not required any more. Data tructures like linked lists and trees use this technique for their memory allocation. What are ingly Linked Lists? tart Info Link Info Link Info Link Info This represents a singly linked list where tart is a special pointer, which stores the address of first node in the linked list. The link pointer of the last node stores, which means this node is not pointing to any other node, i.e., it is the last node in the list A B 7865 C 5678 D Representation of a Linked List in Memory Trying to implement in memory in the simplest form, using two linear arrays one called INFO array for INFO storage and the other known as LINK array for next pointer storage such ass INFO [I] and LINK [I] contain INFO part and next pointer of K h node. Also a separate variable TART is required to store the beginning location of the list. ince the subscripts of the array INFO and LINK will usually INFO be positive, LINK we choose NULL=o, unless otherwise stated. TART 7 1 L 2 3 R 4 5 J 6 7 E 8 V tart = INFO [7] = E LINK [7] = 5 INFO [5] = J LINK [5] = 1 INFO [1] = L LINK [1] = 3 3

4 INFO [3] = R LINK [3] = 4 INFO [4] = LINK [4] = 8 INFO [8] = V LINK [8] = 0 i.e. 4 To incorporate these features, together with the linked lists in memory, a special list is maintained consisting of unused memory cells. This list (called AVAIL list) has its own pointer pointing to the next free node and is called free-storage list or free-pool. With every insertion, number of free nodes in AVAIL is reduced and with every deletion this number is increased. INFO [9] is the first available free node, then INFO[2], INFO[10], and INFO[6[ are the following available nodes. With every insertion, AVAIL points to its next node, and with every deletion AVAIL points to the freed node and next pointer of the freed node points to the previous first AVAIL node. This method of adding free nodes in AVAIL list, is called garbage collection, 4 and 5 Free-tore Allocation in C++ In C++, every program is provided with a pool of unallocated memory that it may utilize during execution. This memory is known as free store memory. In C++, one aspect of this free store memory is that it is unnamed. Objects allocated on the free store do not possess any name; rather, they are manipulated indirectly through pointers. Free store memory is allocated by applying operator new to a type specifier and which returns a pointer pointing to the allocated memory. To allocate memory for a node of a linked list the following statements are given: struct Node char info [15]; Node *next; ; Node *ptr; ptr = new Node; //declare variable forming info part //pointer that will point to the next node //pointer that will point to the newly allocated memory //allocate memory to hold a Node and make ptr point to it Now to refer to the info part, we may write To refer to the next pointer, we may write ptr -> info ptr -> next When the node is to be deleted, it is done as delete ptr; where ptr is pointer pointing to the Node to be deleted. Basic Operations on ingly Linked List Various operations that can be performed on singly linked list are: Insertion, Deletion, Traversal, Reversal, plitting and Concatenation. Picking up Insertion in the beginning and in the end), Deletion( from the beginning) and traversal in details. Insertion To add an ITEM in the beginning of the list, TART is modified to the point to the new node of ITEM and the next pointer of the new node points to the previous first node. 4

5 5 start B C D E E A The status before insertion To add an ITEM in the end of the list, next pointer of the last node is made to point to the new ITEM s node and the next pointer of the new ITEM s node is made NULL. Inserting in the beginning of a List a) Allocate memory for the new node which will be done as follows : NEWPTR = new Node; Where Node specifies the type of the node for which memory is to be allocated and NEWPTR is the pointer pointing to the newly allocated memory. a) Check whether memory has actually been allocated. If not then display appropriate message. NEWPTR = NULL b) If the sufficient memory has been allocated, copy ITEM to INFO part of the NEWPTR, NEWPTR -> INFO = ITEM 6 ALGORITHM - Inserting in the beginning of a List 1. ptr = TART 2. NEWPTR = new Node 3. if NEWPTR = NULL 4. print No pace Available! Aborting!! 5. else 6. NEWPTR - > INFO = ITEM 7. NEWPTR - > LINK = NULL 8. if TART = NULL then 9. TART = NEWPTR 10. else 11. ave = TART 12. TART = NEWPTR 13. NEWPTR - > LINK = ave 14. END DEMO CW Write a function that implements insertion of a node in the beginning of a List 7 ALGORITHM - Inserting in the end of a List 1. Declare pointers TART, PTR, NEWPTR, REAR 2. ptr = TART 3. NEWPTR = new Node 5

6 4. if NEWPTR = NULL 5. print No space Available! Aborting!! 6. Exit 7. else 8. NEWPTR -> LINK = NULL 9. if TART = NULL then 10. TART = NEWPTR 11. REAR = NEWPTR 12. REAR -> LINK = NEWPTR 13. REAR = NEWPTR 14. END 6 8 DEMO CW Write a function that implements insertion of a node in the end of a List Deletion Deletion of ITEM from a linked list involves a) earch for ITEM in the list for availability b) If available, make its previous node point to its next node start Previously NULL A B C D E E ALGORITHM - Deletion from the beginning of a List 1. If TART = NULL then 2. Print UNDERFLOW 3. else 4. ptr = TART 5. TART = ptr - > LINK 6. delete ptr 7. END DEMO CW Write a function that implements deletion of a node from the List ALGORITHM - Traversal 1. ptr = TART 2. Repeat steps 3 and 4 until ptr = NULL 3. print ptr - > INFO 4. ptr = ptr - > LINK 5. END F 6

7 DEMO 7 CW Write a function that implements traversal of the List 9 and 10 What is a TACK? A tack is a linear dynamic structure implemented in LIFO (Last In First Out), i.e. insertions and deletions happen at the TOP. An insertion in a stack is called Pushing and deletion in a stack is called Popping. Physically it can be implemented as an array or as a linked list. Implementation of tack as an Array As arrays are static data structures, space required for them must be predetermined i.e. how many total elements will be existing together at any point of time must be known beforehand. Therefore, creation of a stack as array involves determining the number of elements beforehand. Insertion in a tack as an Array ( Pushing ) Pushing an element in the stack involves shifting of elements as the new element will be inserted at the top only. If at any point of time we have stack like shown : X PUH P 2 Z 1 Y 0 N P 3 X 2 Z 1 Y 0 N PUH L 6 5 L 4 P 3 X 2 Z 1 Y 0 N In case the array is full and no new element can be accommodated, it is called TACK-FULL condition. This condition is also called an OVERFLOW. ALGORITHM - Inserting in a stack as an Array - Pushing //Assuming that array stack can hold maximum N elements 1. top = Read Item 3. If ( top == N-1 ) then 4. print Overflow 5. else 6. top=top+1 7. stack[top] = Item 8. END DEMO CW Write a function that implements Pushing an element in a TACK Deletion in a tack as an Array ( Popping ) Popping an element from the stack involves removes the element at the top most position. If at any 7

8 point of time we have stack like shown below : P POP 3 X P 2 Z 1 Y 0 N X 2 Z 1 Y 0 N In case the last element is popped, the stack becomes empty. If one tries to delete an element from an empty stack, this is called UNDERFLOW. ALGORITHM - Deletion from a tack as an Array - Popping //Firstly check for underflow condition 1. if top == -1 then print Underflow 4. Exit from Program else print stack [top] 9. top = top END DEMO CW Write a function that implements Popping an element from a TACK 11 Implementation of tack as a Linked List tack implemented as linked list is a dynamic data structure and inherits all properties of linked lists. Insertion in a Linked tack ( Pushing ) A push can occur only at the Top, Top gets modified every time. If we have a stack as shown below, after pushing, it becomes as shown. After pushing another element P, it becomes as the next shown stack. Top Top H M H M Top P H M 8

9 9 ALGORITHM - Insertion in a linked list ( Pushing ) //get new node for the ITEM to be pushed 1. NEWPTR = new ptr 2. NEWPTR - > INFO = ITEM 3. NEWPTR - > LINK = NULL //Add new node at the top 4. If Top = then 5. Top = NEWPTR 6. else 7. NEWPTR - > LINK = TOP 8. TOP = NEWPTR 9. END DEMO CW Write a function that implements Pushing an element in a TACK 12 Deletion from a Linked tack ( Popping ) Popping of elements also requires modification of TOP, i.e. TOP is made to point to the next mode in the sequence. If the stack is as shown below, after popping P, it will appear as shown. After popping, it becomes as shown in the next figure: Top P H M Top Top H M H M ALGORITHM - Deletion from a linked list ( Pushing ) 1. If Top = NULL then 2. Print tack Empty, Underflow 3. Else 4. Print Top - > INFO 5. Top = Top -> LINK 6. END DEMO 9

10 10 CW Write a function that implements Popping an element from a TACK 13 and 14 Application of tacks There are several applications and uses of stacks. The stacks are basically applied where LIFO (Last in First Out) scheme is required. a) Reversing a Line :This can be accomplished by pushing each character on to a stack as it is read. When the characters are finished, they are then popped off the stack. They will come off in the reverse order as shown: If the given line is : tack I Push in Empty tack VII Pop k c k a II Push t t t VIII Pop c III Push a a t a t c IX Pop a IV Push c c a t X Pop t t a XI Pop t V Push k k c a t VI End of line b) Poilish trings : This is conversion of arithmetic expressions in high level language to the language that computers understand, binary language. Complex arithmetic expressions 10

11 11 can be converted into polish strings using stacks which can be executed in two operands and an operator form. There are two forms : Prefix & Postfix Forms Infix Notation Prefix Notation Postfix Notation A + B + AB AB + (A C) X C X ACB AC B X A + ( B X C ) + A X BC ABC X + (A + B) / (C D) - / + A B CD AB + CD - / Conversion of infix to Postfix Notation The evaluation order followed while evaluating an infix expression according to which I Brackets or Parenthesis II Exponentiation III Multiplication or Division IV Addition or ubtraction take place according to the above specified order. The operators with the same priority are evaluated from left to right. tep to convert infix expression into postfix manually a) Determine the actual evaluation order by inserting braces b) Convert the expression in the innermost braces into braces into postfix notation by putting the operator after the operands c) Repeat step (b) until entire expression is converted into postfix notation Examples 1. ((A + B) X C) / D a) =((A + B) X C) /D b) =((AB+) X C) / D c) =(AB + C X) / D d) AB + C X D / 2. (( A + B ) * C/D + E F))/G a) =(((A + B) * C)/D)+(E F))/G b) =(((AB+C*)/D) +EF )/G c) =((AB+C*D/EF + G/ 3. Not A ) Or Not B Not C a) =((Not A) Or ((Not B) And (Not C))) b) =((A Not) Or ((B Not) And (C Not))) c) =((A Not) Or ((B Not C Not And)) d) =A Not B Not C Not And Or ALGORITHM - Conversion of Infix Expression to Postfix Form uppose X is an arithmetic expression written in infix notation. 1. Push ( onto TACK, and add ) to the end of X 2. can X from left to right and REPEAT steps 3 to 6 for each element of X UNTIL the TACK is empty 3. if an operand is encountered, add it to Y 4. if a left parenthesis is encountered, push it onto TACK 5. if an operator is encountered then : a) Repeatedly pop from TACK and add to Y each operator which has same precedence as or higher precedence than operator b) Add operator to TACK 6. if a right parenthesis is encountered then a) Repeatedly pop from TACK and add to Y each operator until a left parenthesis is 11

12 encountered b) Remove the left parenthesis. [Do not add the left parenthesis to Y] 7. END 12 Examples 1. Convert X : A + (B*C (D / E F) * G) * H into postfix form showing stack status after every step in tabular form. No ymbol tack Expression Y canned 1 A ( A 2 + ( + A 3 ( ( + ( A 4 B ( + ( A B 5 * ( + ( * A B 6 C ( + ( * A B C 7 - ( + ( - A B C * 8 ( ( + ( - ( A B C * 9 D ( + ( - ( A B C * D 10 / ( + ( - ( / A B C * D 11 E ( + ( - ( / A B C * D E 12 ( + ( - ( / A B C * D E 13 F ( + ( - ( / A B C * D E F 14 ) ( + ( - A B C * D E F / 15 * ( + ( - * A B C * D E F / 16 G ( + ( - * A B C * D E F / G 17 ) ( + A B C * D E F / G * - 18 * ( + * A B C * D E F / G * - 19 H ( + * A B C * D E F / G * - H 20 ) A B C * D E F / G * - H * + Advantage of postfix over infix expression : A postfix expression determines the precedence of operators. Otherwise it is difficult for the machine to know and keep track of precedence operators.. Therefore, it gets easier for the machine to carry out postfix expression than an infix expression. Evaluation of postfix expression A postfix expression is without parenthesis and can be evaluated as two operands and an operator at a time; this becomes easier for the compiler and the computer to handle. Evaluation rule of postfix expression states: While reading the expression from left to right, push the element in the stack if it is an operand; pop the two operands from the stack, if the element is an operator( except NOT operator ) In case of NOT operator, pop one operand from the stack and then evaluate it ( two operands and an operators ). Push back the result of the evaluation. Repeat till the end of the expression. For a binary operator, two operands one popped from stack and for a unary operator, one operand is popped. Then, the result is calculated using operand(s) and the operator, and pushed back into the stack. ALGORITHM - Evaluation of Postfix Expression //Reading of expression takes place from left to right 1. Read the next element // first element for the first time 12

13 2. If element is operand then Push the element in the stack 3. If element is operator then 4. Pop two operands from the stack 5. Evaluate the expression formed by the two operands and the operator 6. Push the result of the expression in the stack end 7. If no more elements then 8. POP the result 9. Else 10. Go to step END Example Evaluate the postfix expression AB + C X D / if A = 2, B = 3, C = 4 and D = 5. tarting from left to right I. First element is operand A, push A into the stack II. econd element is also operand B, push B also into the stack III. Third element + is an operand, pop 2 operands from the stack, i.e., A and B and evaluate the expression i.e. A + B = = 5 IV. Push the result (5) into the stack A tack I tack IV 5 20 tack VII tack II B A tack V C 5 D 20 tack VIII 4 tack III tack VI tack IX tack X V. Next element C is operand; pushed into the tack VI. Next X is an operator, pop 2 operands from the stack i.e., 5 and C and evaluate 5 X C = 5 X 4 = 20 VII. Push the result (20) into stack VIII. Next D is operand, pushed into stack IX. Next / is operator; two operands popped D and 20. Expression evaluated as follows : 20 = 20 = 4 X. End of the expression, Pop from stack. Thus the result is 4 D 5 2. Evaluate the postfix expression True NOT OR NOT AND OR AND tarting from left to right I. is operand, pushed into stack II. is operand, pushed into stack III. is operand, pushed into stack IV. NOT is a unary operator. Thus only one operand is popped. Evaluating NOT = ; Pushing the result into the stack. V. is an operand; pushed into stack VI. is an operand, pushed 13

14 14 VII. OR is operator, Pop two operands,,. Evaluating the expression, we get OR =. Pushing the result into the stack. VIII. NOT is operator; One operand is popped, i.e.. Evaluating NOT = IX. AND is operator; Pop two operands, i.e.,,. Evaluating AND =. Pushing the result, into the stack X. OR is operator; Pop two operands i.e.,. Evaluating OR = ; Push the result XI. AND is operator; Pop two operands, i.e.,,. Evaluate and Push back : AND = XII. No more elements, Pop from stack therefore the result is. tack I tack II tack III tack IV tack V tack VI tack VII tack VIII tack IX tack X tack XI 16 Deletion in a Queue as an Array As deletions occur at the front end only, with every deletion, the front gets modified. Whenever an element is deleted from the queue, the value of front is increased by 1( if only, elements remaining in the queue are not to be shifted ) front = 0 rear = 5 front front = 2 = 1 rear rear = 5 = 5 front = 3 rear = N 2 N N 2 N N 2 N N 2 N

15 ALGORITHM - Deletion in a Queue as an Array If rear = NULL then Print Queue Empty else ITEM = QUEUE [front] If front = rear then Front = rear = NULL else front = front + 1 END Implementation of Queue as a Linked List Linked queues are the queue having links among its elements. Two pointers are maintained to store the frot position and the rear position front rear 17 and 18 Implementation of Queue as a Linked List Linked queues are the queue having links among its elements. Two pointers are maintained to store the frot position and the rear position front rear Insertion in a Linked Queue Insertions in a linked list take place only at the rear i.e. the rear gets modified with every insert Rear new Link front Old Link ALGORITHM - Insertion in Linked Queue NEWPTR = new Node NEWPTR - > INFO = ITEM; NEWPTR - > LINK = NULL If rear = NULL then front = NEWPTR rear = NEWPTR 15

16 else END Rear->LINK=NEWPTR Rear = NEWPTR 16 Old Link Deletion in a Linked Queue Insertions in a linked list take place only from the front i.e. the front gets modified with every delete front New Link rear 19 and 20 ALGORITHM - Deletion from a Linked Queue If front = NULL then Print Queue Empty else ITEM = front-> INFO If front=rear then front=rear=null else front=front->link END Variations in Queue Queues can be used in several forms: Circular Queues and Dequeues (double ended queues) Circular Queues are the queues implemented in circular form rather than a straight line. They overcome the problem of unutilised space in linear queues implemented as arrays front = 3 rear = N - 2 front = 3 rear = N N 2 N N 2 N front = 4 rear = N N 2 N front = 4 rear = N 2 N

17 17 Deque are refined in which elements can be added or removed at either end but not in the middle. The two variations of deque: input restricted deque and an output restricted deque. An input restricted deque is deque which allows insertions only at one end but allows deletions at both ends of the list. An output restricted deque is a deque which allows deletions only at one end of the list but allows insertions at both the ends of the list. ALGORITHM - Insertion in a Circular Queue //Assuming that the Circular Queue is stored in QU with size N If front=0 and rear=n-1 or front=rear+1 Write Overflow! else If front=null then et front=0 Rear=0 Else if rear=n-1 then et rear=0 Else et rear=rear+1 et QU[rear] = ITEM END ALGORITHM - Deletion from a Circular Queue Assuming that the queue is stored in as array QU with size N. If front=null then Write Underflow Return Else et D_ITEM = QU[front] If front=rear then Front=NULL Rear=NULL Else if Front=N 1 then Front = 0 Else Front=front+1 END 21 Class Test 17

18 18 18

Solution: The examples of stack application are reverse a string, post fix evaluation, infix to postfix conversion.

Solution: The examples of stack application are reverse a string, post fix evaluation, infix to postfix conversion. 1. What is the full form of LIFO? The full form of LIFO is Last In First Out. 2. Give some examples for stack application. The examples of stack application are reverse a string, post fix evaluation, infix