Data accessing is faster because we just need to specify the array name and the index of the element to be accssed.. ie arrays are simple to use

Size: px

Start display at page:

Download "Data accessing is faster because we just need to specify the array name and the index of the element to be accssed.. ie arrays are simple to use"

Victor Stokes
6 years ago
Views:

1 Module 3 Linear data structures and linked storage representation Advantages of arrays Linear data structures such as stacks and queues can be represented and implemented using sequential allocation ie using arrays. Use of arrays have the following advantages Data accessing is faster because we just need to specify the array name and the index of the element to be accssed.. ie arrays are simple to use Disadvantages The size of the array is fixed. This limits the user in determining the required storage well in advance. However memory requirement cannot be determined while writing the program. ie if the allocation is more and required is less then memory is wasted. Similarly if less memory is allocated and requirement is more then we cannot allocate memory during execution. Also array items are stored sequentially. In such a case contigious memory may not be available. Most of the times chunks of memory will be available but they cannot be used as they are not contiguous. Finally insertion and deletion of items in a array is difficult. Insertion of an element at the i th position requires us to move all the elements from i+1 th position To the next position and only after this movement insertion can be performed. A similar movement is required for deletion also. Linked lists A linked list is a collection of zero or more nodes where each node has some information Info link Link will contain the address of the next node Info will contain the information. Hence if the address of a node is known we can easily access the subsequent nodes 1

2 Types of lists Singly linked lists doubly linked lists circular linked lists circular doubly linked lists Singly linked list A singly linked list is a collection of zero or more nodes. Each node will have one info field and one link field. A chain is a singly list with zero or more nodes. A empty list is as shown \0 A list is represented as follows First Note: List contains 4 nodes where each node contains a info and link fields Info filed contains the data Link field contains the address of the next node First is a variable containing the address of the first node of the list Using first we can access any node in the list The link field of the last node will have NULL 2

3 Representation Nodes in the list are self referential structures. A structure is a collection of one or more fields which are of the same type or different type. A self refrential structure is a structure which has at least one field which is a pointer to the same structure. ex struct node Int info; Struct node * link; ; Info is a int containing integer data Link is a pointer and should contain the address and normally it contains the address of the next node Declaration of variable We have the following declaration struct node Int info; Struct node * link; ; typedef struct node * NODE; now a pointer variable first can be declared as NODE first; Creation of a empty list 3

4 Before creating a list we need to create a empty list first. This is achieved by assigning NULL to the variable first ie first=null creating a new node A new node is created as follows First=(NODE) malloc(1 * sizeof(node)) The above statement will allocate memory to the variable first Using first we can access the contents of the node such as First->info or first->link(for the next node) To store the data. We use First->info=10; We need to store NULL as this is the first node First->link=NULL Deleting a node Any node which is not required is deleted using the free function Free(first); When the above statement is executed the memory which was allocated to first using malloc is deallocated and returned to the OS. The variable first will have a invalid address and hence is called as dangling pointer Operations on a singly linked list Inserting a node Deleting a node Search for a node 4

5 Display the list #include<stdio.h> #include<stdlib.h> // Declaration of the node struct node int data; struct node *next; *head; //function to add a node at the end of the list void append(int num) struct node *temp,*right; temp= (struct node *)malloc(sizeof(struct node)); temp->data=num; right=(struct node *)head; while(right->next!= NULL) right=right->next; right->next =temp; right=temp; right->next=null; void add( int num ) struct node *temp; temp=(struct node *)malloc(sizeof(struct node)); temp->data=num; if (head== NULL) head=temp; head->next=null; else 5

6 temp->next=head; head=temp; //function to add a node after a given node void addafter(int num, int loc) int i; struct node *temp,*left,*right; right=head; for(i=1;i<loc;i++) left=right; right=right->next; temp=(struct node *)malloc(sizeof(struct node)); temp->data=num; left->next=temp; left=temp; left->next=right; return; //function to insert a node void insert(int num) int c=0; struct node *temp; temp=head; if(temp==null) add(num); else while(temp!=null) if(temp->data<num) c++; temp=temp->next; if(c==0) add(num); 6

7 else if(c<count()) addafter(num,++c); else append(num); //function to delete a node int delete(int num) struct node *temp, *prev; temp=head; while(temp!=null) if(temp->data==num) if(temp==head) head=temp->next; free(temp); return 1; else prev->next=temp->next; free(temp); return 1; else prev=temp; temp= temp->next; return 0; 7

8 // function to display a list void display(struct node *r) r=head; if(r==null) return; while(r!=null) printf("%d ",r->data); r=r->next; printf("\n"); //function to count the number of nodes in a list int count() struct node *n; int c=0; n=head; while(n!=null) n=n->next; c++; return c; 8

9 // main program to perform all the operations int main() int i,num; struct node *n; head=null; while(1) printf("\nlist Operations\n"); printf("1.insert\n"); printf("2.display\n"); printf("3.size\n"); printf("4.delete\n"); printf("5.exit\n"); printf("enter your choice : "); scanf("%d",&i) switch(i) case 1: printf("enter the number to insert : "); scanf("%d",&num); insert(num); case 2: if(head==null) printf("list is Empty\n"); else printf("element(s) in the list are : "); display(n); 9

10 return 0; case 3: printf("size of the list is %d\n",count()); case 4: if(head==null) printf("list is Empty\n"); else printf("enter the number to delete : "); scanf("%d",&num); if(delete(num)) printf("%d deleted successfully\n",num); else printf("%d not found in the list\n",num); case 5: return 0; default: printf("invalid option\n"); Function to search for a element in a list void search(struct node *head, int key) while (head!= NULL) if (head->a == key) printf("key found\n"); return; head = head->next; printf("key not found\n"); 10

11 Circular linked list Circular Linked List is little more complicated linked data structure. In the circular linked list we can insert elements anywhere in the list whereas in the array we cannot insert element anywhere in the list because it is in the contiguous memory. In the circular linked list the previous element stores the address of the next element and the last element stores the address of the starting element. The elements points to each other in a circular way which forms a circular chain. The circular linked list has a dynamic size which means the memory can be allocated when it is required. Application of Circular Linked List The real life application where the circular linked list is used is our Personal Computers, where multiple applications are running. All the running applications are kept in a circular linked list and the OS gives a fixed time slot to all for running. The Operating System keeps on iterating over the linked list until all the applications are completed. Another example can be Multiplayer games. All the Players are kept in a Circular Linked List and the pointer keeps on moving forward as a player's chance ends. Circular Linked List can also be used to create Circular Queue. In a Queue we have to keep two pointers, FRONT and REAR in memory all the time, where as in Circular Linked List, only one pointer is required. 11

12 #include<stdio.h> #include<conio.h> struct circular int i; struct circular *next; ; struct circular *temp; struct circular *head; struct circular *p; struct circular *mid; struct circular *move; int cnt=0; void create(void); void insert(void); void display(void); void del(void); void main() int ch=0; clrscr(); while(ch!=5) printf("\n1.create"); printf("\n2.insert"); printf("\n3.delete"); printf("\n4.display"); printf("\n5.exit"); scanf("%d",&ch); if(ch==1) create(); 12

13 cnt++; cnt++; if(ch==2) insert(); cnt++; if(ch==3) del(); cnt--; if(ch==4) display(); if(ch==5) getch(); void create() head=(struct circular *)malloc(sizeof(struct circular)); head->next=head; printf("eneter THE DATA"); scanf("%d",&head->i); temp=head; temp->next=(struct circular *)malloc(sizeof(struct circular)); temp=temp->next; temp->next=head; printf("eneter THE DATA"); scanf("%d",&temp->i); 13

14 void insert() int add,t; printf("\n\t ENTER ANY NUMBER BETWEEN 1 AND %d",cnt); scanf("%d",&add); p=head; t=1; while(t<add) p=p->next; t++; printf("%d",p->i); clrscr(); mid=(struct circular *)malloc(sizeof(struct circular)); printf("eneter THE DATA"); scanf("%d",&mid->i); mid->next=p->next; p->next=mid; void display() p=head; printf("%d-->",p->i); p=p->next; 14

15 while(p!=head) printf("%d-->",p->i); p=p->next; void del(void) int add,t; printf("\n\t ENTER ANY NUMBER BETWEEN 1 AND %d",cnt); scanf("%d",&add); p=head; t=1; while(t<add-1) p=p->next; t++; printf("%d",p->i); clrscr(); mid=p->next; p->next=mid->next; Doubly linked list In computer science, a doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes. Each node contains two fields, called links, that are references to the previous and to the next node in the sequence of nodes. The beginning and ending nodes' previous and next links, respectively, point to some kind of terminator, typically a sentinel node or null, to facilitate traversal of the list. If there is only one sentinel node, then the list is circularly linked via the sentinel node. It can be conceptualized as two singly linked lists formed from the same data items, but in opposite sequential orders. A doubly linked list whose nodes contain three fields: an integer value, the link to the next node, and the link to the previous node. The two node links allow traversal of the list in either direction. While adding or removing a node in a doubly linked list requires changing more links than the same operations on a singly 15

16 linked list, the operations are simpler and potentially more efficient (for nodes other than first nodes) because there is no need to keep track of the previous node during traversal or no need to traverse the list to find the previous node, so that its link can be modified. #include<stdio.h> #include<conio.h> #include<stdlib.h> //define the structure struct node struct node *previous; int data; struct node *next; *head, *last; //function to insert ate the beginning void insert_begning(int value) 16

17 struct node *var,*temp; var=(struct node *)malloc(sizeof(struct node)); var->data=value; if(head==null) head=var; head->previous=null; head->next=null; last=head; else temp=var; temp->previous=null; temp->next=head; head->previous=temp; head=temp; // function to insert at the end of the list void insert_end(int value) struct node *var,*temp; var=(struct node *)malloc(sizeof(struct node)); var->data=value; if(head==null) head=var; head->previous=null; head->next=null; last=head; else last=head; while(last!=null) temp=last; last=last->next; last=var; temp->next=last; last->previous=temp; 17

18 last->next=null; // function to insert after a node int insert_after(int value, int loc) struct node *temp,*var,*temp1; var=(struct node *)malloc(sizeof(struct node)); var->data=value; if(head==null) head=var; head->previous=null; head->next=null; else temp=head; while(temp!=null && temp->data!=loc) temp=temp->next; if(temp==null) printf("\n%d is not present in list ",loc); else temp1=temp->next; temp->next=var; var->previous=temp; var->next=temp1; temp1->previous=var; last=head; while(last->next!=null) last=last->next; //function to delete at the end of the list 18

19 int delete_from_end() struct node *temp; temp=last; if(temp->previous==null) free(temp); head=null; last=null; return 0; printf("\ndata deleted from list is %d \n",last->data); last=temp->previous; last->next=null; free(temp); return 0; // function to delete a node from the middle of the list int delete_from_middle(int value) struct node *temp,*var,*t, *temp1; temp=head; while(temp!=null) if(temp->data == value) if(temp->previous==null) free(temp); head=null; last=null; return 0; else var->next=temp1; temp1->previous=var; free(temp); return 0; else 19

20 var=temp; temp=temp->next; temp1=temp->next; printf("data deleted from list is %d",value); // function to display the list void display() struct node *temp; temp=head; if(temp==null) printf("list is Empty"); while(temp!=null) printf("-> %d ",temp->data); temp=temp->next; // main program int main() int value, i, loc; head=null; printf("select the choice of operation on link list"); printf("\n1.) insert at begning\n2.) insert at at\n3.) insert at middle"); printf("\n4.) delete from end\n5.) reverse the link list\n6.) display list\n7.)exit"); while(1) printf("\n\nenter the choice of operation you want to do "); scanf("%d",&i); switch(i) case 1: printf("enter the value you want to insert in node "); scanf("%d",&value); 20

21 insert_begning(value); display(); case 2: printf("enter the value you want to insert in node at last "); scanf("%d",&value); insert_end(value); display(); case 3: printf("after which data you want to insert data "); scanf("%d",&loc); printf("enter the data you want to insert in list "); scanf("%d",&value); insert_after(value,loc); display(); case 4: delete_from_end(); display(); case 5: printf("enter the value you want to delete"); scanf("%d",value); delete_from_middle(value); display(); case 6 : display(); case 7 : exit(0); 21

22 printf("\n\n%d",last->data); display(); getch(); Applications of linked lists Polynomial addition A polynomial is sum of terms where each term is of the form ax e Where a is the coefficient is the variable, e is the exponent The largest exponent is also called as the degree. Various operations can be performed on the polynomials Iszero(poly)-Returns 0 if the polynomial does not exist Coeff(poly,expo)-returns the coefficient Leadexpo(poly)-returns the largest exponent Attach- Attach a term<coeff,expo> onto the polynomial 22

23 Remove (poly,expo)-delete a term Add(poly1,poly2)-adds two polynomials General procedure to add two polynomials Three cases exist Case 0 : Powers of the two terms to be added are equal In such a case the coefficients of the two terms are added using Sum=coeff(a,leadexpo(a)+coeff(b,leadexpo(b)) And then insert the resultant term on to the resulting polynomial using the attach function. We move onto the next term using the remove function. Ie A=remove(a,leadexpo(a)); B= remove (b,leadexpo(b)); Case 1: Power of the first term is > power the second term In such a case we insert the first term onto the resulting polynomial using Attach(c,coeff(a,leadexpo(a)) And move onto the next term using remove function A=remove(a,leadexpo(a) Default case: Here the power of the first term is < the power of the second term In such a case we insert the second term onto the resulting polynomial using Attach(c,coeff(b,leadexpo(b)) And move onto the next term using remove function b=remove(b,leadexpo(b) 23

24 //9.c polynomial operations #include<stdio.h> #include<process.h> #include<conio.h> #include<math.h> typedef struct node int expo,coef; struct node* next; node; node * insert(node *,int,int); node * create(); node * add(node *p1,node *p2); int eval(node *p1); void display(node *head); node * insert(node *head,int coef1,int expo1) node *p,*q; p=(node *) malloc(sizeof(node)); p->expo=expo1; 24

25 p->coef=coef1; p->next=null; if(head==null) head=p; head->next=head; return (head); if(expo1>head->expo) p->next=head->next; head->next=p; head=p; return(head); if(expo1==head->expo) head->coef=head->coef+coef1; return(head); q=head; while(q->next!=head && expo1>=q->next->expo) 25

26 ////insert q=q->next; if(p->expo==q->expo) q->coef=q->coef+coef1; else p->next=q->next; q->next=p; return (head); ////inserted node *create() int n,i,expo1,coef1; node *head =NULL; printf("\n enter num of poly terms"); scanf("%d",&n); for(i=0;i<n;i++) printf("\n enter coef and expo"); scanf("%d%d",&coef1,&expo1); head=insert(head,coef1,expo1); 26

27 return (head); node *add(node *p1,node *p2) node *p; node *head=null; printf("\n addition of ploy"); p=p1->next; do head=insert(head,p->coef,p->expo); p=p->next; while(p!=p1->next); p=p2->next; do head=insert(head,p->coef,p->expo); p=p->next; while(p!=p2->next); return (head); int eval(node *head) 27

28 node *p; int x,ans=0; printf("\n enter the value of x"); scanf("%d",&x); p=head->next; do ans=ans+p->coef*pow(x,p->expo); p=p->next; while(p!=head->next); return (ans); void display(node *head) node *p,*q; int n=0; q=head->next; p=head->next; do n++; q=q->next; 28

29 while(q!=head->next); printf("\n poly is "); do if(n-1) printf(" %dx^(%d) + ",p->coef,p->expo); p=p->next; else printf(" %dx^(%d)",p->coef,p->expo); p=p->next; n--; while(p!=head->next); void main() node *p1,*p2,*p3; int a,x,ch; p1=p2=p3=null; 29

30 while(1) printf("\n1.add"); printf("\n2.evaluate"); printf("\n 3.exit"); printf("enter ur choice"); scanf("%d",&ch); switch(ch) case 1: p1=create(); display(p1); p2=create(); display(p2); p3=add(p1,p2); display(p3); case 2: p1=create(); display(p1); a=eval(p1); printf("\n value of poly is %d",a); case 3: exit(0); 30

31 default: printf("\n invalid choice"); 31

Linked List in Data Structure. By Prof. B J Gorad, BECSE, M.Tech CST, PHD(CSE)* Assistant Professor, CSE, SITCOE, Ichalkaranji,Kolhapur, Maharashtra

Linked List in Data Structure. By Prof. B J Gorad, BECSE, M.Tech CST, PHD(CSE)* Assistant Professor, CSE, SITCOE, Ichalkaranji,Kolhapur, Maharashtra Linked List in Data Structure By Prof. B J Gorad, BECSE, M.Tech CST, PHD(CSE)* Assistant Professor, CSE, SITCOE, Ichalkaranji,Kolhapur, Maharashtra Linked List Like arrays, Linked List is a linear data