3BCA3 - Data Structure

UNIT – I (2) Linked List: - Link List Data Elements dk ,d Linear Collection
Data Structure gSaA ftls Node dgrs gSaA Linear Order dks Pointers ds }kjk
fdlh Hkh Program esa Data dks fofHkUu izdkj ls Arrange fd;k tk Maintain fd;k tkrk gSaA gj Node dks nks Parts esa Divide
ldrk gSaA fdlh Hkh ,d Representation dk Logical ;k Arithmetical djrs gSaA ,d Link List Linear Link List ;k Doubly Link List gks
Representation gh Data Structure dykrk gSaA fdlh Data Representation ldrh gSaA
dks Choose djuk nks concepts ij fuHkZj djrk gSaA (i) Linear Link List esa gj Node dks nks Parts esa divide
(1) Data bruk Arranged gksuk pkfg, fd og Actual Relation dks fd;k tkrk gSa
iznf'kZr djrk gSaA  First Part esa Information dks j[kk tkrk
(2) og bruk Easy gksuk pkfg, fd vko';drk iM+us ij mls gSaA
vklkuh ls le>k tk ldrk gSaA  Second Part dks Link Part ;k Next Pointer Field
(3) Data Structure dks eq[;r% nks Parts esa Divide fd;k x;k dgk tkrk gSa ftlesa List ds next Node dk
gSaA Address jgrk gSaA
(i) Linear Data Structure: - ;g ,d ,slk data structure gSa List dh First Element dks ,d Pointer Point djrk gSa ftls Head
ftlesa Elements Sequence esa Store jgrs gSa rFkk dgrs gSaA Linear Link List dks ,d Direction esa Traverse fd;k
gj Element ,d Unique Pre-decessor vkSj Success tkrk gSaA STAR
gksrk gSaA Linear Data Structure ds mnkgj.k fuEu T
gSaA Arrays, Linked List, Stack rFkk Queue INF INF X
(ii) Non Linear Data Structure: - ,d ,slk Data Structure gSa O O
ftlesa Elements Sequence esa ugha jgrs gSaA STAR
vkSj blds fy, fdlh Unique Pre-decessor ;k Successor T
dh vko';drk ugha gksrh gSaA Example: - Trees, Prev Info Next Prev Info Next Prev Info Next
Graphs etc. Node Node
fofHkUu Data Structures fuEu gSaA s s
(1) Arrays: - Array Ltd. No. of Elements rFkk Same Data Type dh ,d
List dks Represent djrs gSaA Array dks Individual elements Linked List
dks Index ds }kjk Access fd;k tk ldrk gSaA Array 3 izdkj ds
gksrs gSaA (ii) Doubly Link List: - Doubly Link List esa gj Node dks 3
(i) One Diemensional Array: - bl izdkj ds Array esa ,d Parts esa Divide fd;k x;k gSaA
Index dks Access djus dh vko';drk gksrh gSaA  First Part esa Information dks j[kk tkrk gSaA
(ii) Two Diemensional Array: - ,d Individual element dks  Second Part dks Previous Pointer field dgk tkrk gSa
Access djus ds fy, nks Indexes dh vko';drk gksrh ftlesa List ds fiNys (Pre-decessor) Element dk
gSaA (Matrix) Address jgrk gSaA
(iii) Multi Diemensional Array: - blds fy, nks ;k nks ls  Third Part dks Next Pointer Field dgk tkrk gSa
vf/kd Indexes dks Store fd;k tkrk gSaA ftlesa List ds next element dk address jgrk gSaA

1 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
nks Pointer Variable dks Perform fd;k tkrk gSa ftls Head vkSj Tail (i) Front vkSj Rear dsoy nks gh Condition esa cjkcj gksrs
dgrs gSa tks Doubly Link List ds First vkSj Last Element ds Address gSaA
dks Contain djrs gSaA First Element ds Previous Pointer esa NULL (a) tc Queue [kkyh gks ;kuh Front = 0 vkSj Rear
Store fd;k tkrk gSa ftlls ;g irk yxrk gSa fd blds ihNs dksbZ Node = -1
ugha gSaA Last Element ds Next Pointer esa NULL dks Store fd;k (b) tc Queue esa dsoy ,d gh element gks vr%
tkrk gSaA ftls ;g irk yxrk gSa fd blds vkxs dksbzZ Node ugha front = 0 vkSj Rear = 0
gSaA Doubly Link List dks nksuks Direction esa Traverse fd;k tk (ii) Queue [kkyh gksxh tc Front rFkk Rear nksuksa gh –1 dks
ldrk gSaA iznf'kZr djsaA
(iii) Queue iwjh Hkjh gqbZ gksxh tc
Stacks: - Stack dks Last In First Out (LIFO) System Hkh dgk tkrk (a) Queue dk Front 0 rFkk Rear Max –1 dks iznf'kZr djsxk
gSaA ;g ,d Linear Link List gSa ftlesa Insertion vkSj Deletion ,d gh (b) tc Queue dk Front = Rear + 1
End ls fd;k tkrk gSaA ftls Top dgrs gSaA Stack dks cukus vkSj (iv) Queue dks Hkh nks izdkj ls cuk;k tk ldrk gSaA
feVkus ds fy, dsoy nks gh Function gS (a) Array ds }kjkA
(1) Push: - Stack esa fdlh Hkh lwpuk dks tksM+us ds fy, (b) Linked List ds }kjkA
(2) Pop: - Stack ls fdlh Hkh Item dks feVkus ds fy,A 12 20 44 55 50
Stack ,d izdkj dh List gSa ftls nks izdkj ls iznf'kZr fd;k tk ldrk  
gSa (1) Array ds }kjk vkSj (2) Link List ds }kjk front rear
Queue with 5 Elements

Trees: - Tree ,d Important Concept gS Tree esa Stored Information dks

Node dgrs gSaA Tree ds lHkh Nodes Edges ds }kjk tqM+s gksrs
54 gSaA Tree ,d ,slk Data Structure gSa ftls fofHkUu Hierarchical
Top
13 Top 13
20 Top 20 20 Relations gSa ds }kjk iznf'kZr fd;k tkrk gSaA Tree dk fuekZ.k
Stack Empty Top Inserting First Inserting Second Inserting Third mlds Root ls fd;k tkrk gSaA tree ds izR;sd Node ds mij (Root dks
Element Element Element NksM+dj) ,d Node gksrh gSaA ftls Parent Node dgk tkrk gSaA
Node ds lh/ks uhps okyh Node dks child node dgk tkrk gSaA ,d
Queues: - Queue dks First In Frist Out (FIFO) System dgk tkrk gSaA tree vertices vkSj Edges dk Collection gSa tks fuf'pr vko';drkvksa
queues ,d fo'ks"k izdkj dh Data Structure gSa ftlesa Stack dh rjg gh dks Satisfy djrk gSaA
Information dks Add djus vkSj Delete djus dh izfØ;k ugha gksrh
cfYd blesa ,d LFkku ls Information dks Add fd;k tkrk gSa vkSj E
nwljs LFkku ls Information dks Delete fd;k tkrk gSaA ftl txg ij
Information dks Queue esa tksM+k tkrk gSa og Position Rear H I
(Queue dk vUr) dgykrh gSaA ftl LFkku ls queue esa ls Information
dks Delete fd;k tkrk gSaA oks Front dgykrk gSaA Front vkSj Rear K L M
ls tqM+h dqN Information ugha gSaA
2 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Vertex: - Vertex ,d Object ;k Node gS tks uke ;k vU; Relative Edge: - tc nks Vertices ds chp Connection Establish fd;k tkrk gSa
Information dks Store djrk gSaA rks mls H dgrs gSaA

Graph
: - dHkh & dHkh Data Elements ds e/; relationship dks iznf'kZr fd;k (1) Sorting: - bl rduhd ds }kjk Records dks Arrange fd;k tkrk
tkrk gSa tks izd`fr ls Hierarchical gks ;g vko';d ugha vr% ,slk gSaA ;s Records Logically Arrange gksrs gSaA Sorting
Data Strcutre tks ,d fo'ks"k Relationship dks iznf'kZr djrk gSaA Ascending (vkjksgh) ;k descending (vojksgh) Order esa gksrh
mls Graph Data Structure dgk tkrk gSaA Graph ds varxZr set of gSaA
notes rFkk set of edges dks j[kk tkrk gSaA Graph dks 2 Hkkxksa (2) Merging: - tc vyx&vyx Records dks 2 Qkbyksa ls fdlh ,d
esa ckaVk x;k gSaA file esa ykuk gks rks blds fy, List Merging Operation dks
(1) Direct Graph (2) In Direct Graph Perform fd;k tkrk gSaA

DATA STRUCTURE OPERATION ADT (Abstract Data Type) or (Abstract Data Structure)
fdlh Hkh Data Structure ij different operation dks process fd;k tk ldrk fdlh Hkh Data Type dh Logical Properties dks Specify djus ds fy,
gSaA ,d special data structure tks nh gqbZ condition ds fy, pquk Abstract Data Type dks mi;ksx esa fy;k tkrk gSaA Data Type cgqr
tkrk gSaA og operation perform djus dh la[;k ij fuHkZj djrk gSaA lh Values rFkk Operations dk Collection gSaA ftlls Hardware rFkk
Normally fdlh Hkh data structure dks 5 operations dks perform fd;k Software Data Structure }kjk Implement fd;k tkrk gSaA Abstract Data
tkrk gSaA Type fdlh Hkh Data Type ds Mathematical Concept dks define djrs
(1) Traversing : - tc ,d ckj data structure rS;kj gks tkrk gSa rks gSaA tc Abstract Data Type ds Mathematical Concept dks Define fd;k
dHkh&dHkh izR;sd element dks Access djus dh vko';drk tkrk gSa rks Time o space ij /;ku ugha fn;k tkrk gSaA ADT dks
gksrh gSaA bl izdkj ds Concept dks Traversing dgk tkrk Specify djus ds fy, ds cgqr ls Methods gSaA ftlds }kjk budk
gSaA Implementation fd;k tkrk gSaA eq[;r% ADT dks 2 Parts esa ckaVk
(2) Searching: - tc dHkh nh xbZ key value ds lkFkk Record dh ;k tkrk gSaA
Node Value dks Locate djuk gks rks blds fy, Hkh Link list ij (1) Value Definition
Searching Operation Perform fd;k tkrk gSaA (2) Operator Definition
(3) Insertion: - tc fdlh Hkh u;s Node dks List esa Add djuk gks Value Definition collection of Values dks ADT ds fy, Define djrh gSaA
rks mls List esa Item Insert djuk dgk tkrk gSaA ftlds 2 Parts gksrs gSaA
(4) Deletion: - tc Structure esa ls fdlh Node dks delete djuk gks (1) Definition
rks bls List Deletion Operation dgk tkrk gSaA (2) Condition
(5) Updation: - tc fdlh Structure esa fdlh Existing Record dh fdlh Hkh Operator dks Define djus ds fy, 3 Parts dh vko';drk gksrh
Value dks Change djuk gks rks mlds fy, List esa Updation gSaA
Operation dks Perform fd;k tkrk gSaA (1) Header
dHkh&dHkh ,d ls vf/kd Operation dks mi;ksx esa ysus dh (2) Optional Pre-condition
vko';drk gksrh gSaA (3) Post Conditions

3 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Abstract Typedef ds }kjk Value Definition dks Define fd;k tkrk gSa
rFkk Condition Keyword ds }kjk fdlh Hkh Condition dks Specify djrs Stack
gq, ges'kk Value Definition ds ckn Operator Definition dks Define Stack ,d Non primitive data Structure gSa ;g ,d Sequence List esa Data
fd;k tkrk gSaA
dks Add djrk gSa vkSj ogha ls Data Item dks gVk;k tkrk gSaA
Stack esa Single Entry vkSj Single Exit Point gksrk gSaA Stack Lifo
concepts (Last in First out) ij dk;Z djrh gSaA
ADT For Strings
ADT Specification dks Strings ij Hkh Perform fd;k tkrk gSaA 4 Basic tc fdlh Data Item dks Stack esa Insert djuk gks rks blds fy, ftl
Operation dks Strings Support djrs gSaA
Operation dks Perform fd;k tkrk gSa mls Push Operation dgrs gSaA
(1) Length: - ;g Function Current Strings dh Length dks Return djrk
gSaA Item dks Remove djus ds fy, Pop Operation dks Perform fd;k tkrk
(2) Concat: - ;g Function 2 Inputted Strings dks tksM+ dj ,d Single
gSaA blds vUrxZr ,d Pointer Stack ds Last esa Mkys x;s Item dks
String Return djrk gSaA
(3) Substr: - ;g Function fdlh Hkh String dk Substring Return djrk Point djrk gSaA ftlls Top dgk tkrk gSaA tc Stack esa dksbZ u;k
gSaA
Item Add fd;k tkrk gSa rks mldk Top c<+rk gSa vkSj tc fdlh
(4) Pos: - ;g Function fdlh ,d String dh First Position dks Return
djrk gSaA Item dks remove fd;k tkrk gSa rks Top ?kVrk gSaA

Arrays dks Hkh Abstract Data Type dh rjg Represent fd;k tkrk gSaA
Insert Element In The Stack
Arrays dks Normally 3 Parts esa Define fd;k tk ldrk gSaA
(1) One dimensional Array (1-D Array)
(2) Two dimensional Array (2-D Array)
(3) Multi dimensional Array
54 Top
Analysis Of Algorithm 13 Top 13
20 Top 20 20
dksbZ Hkh Program Data Structure rFkk Algorithm nksuks dk Stack Empty Top Inserting First Inserting Second Inserting Third
Combination gksrk gSaA Algorithm fdlh Hkh specific Problem dks Element Element Element
Solve djus ds fy, fofHkUu Steps dk combination gksrk gSaA Remove Element From The Stack
Algorithm dks fdlh Hkh Problem dks Read djus o mldh Solution dks
define djus ds fy, Use esa fy;k tkrk gSaA ;g Operations ftUgsa
Perform fd;k tk;sxk lkFk gh Example ds lkFk ml Problem ds
Solution dks contain djrk gSaA Algorithm ds }kjk Time vkSj Space
54 Top
Complexity dks Check fd;k tkrk gSaA Algorithm ds Complexity 13 13 Top
function gksrh gSa tks Run time ;k Input size dks consider djrh gSaA 20 20 20 Top
Stack Initially Element 54 Element 13 Element 20 Top
Deleted 4 Deleted
B.M.COLLEGE BALOTRA
Deleted
 3BCA3 - Data Structure
void push( )
{ int item;
Stack Operation if (top= =MAXSIZE-1)
Stack ij eq[;r% 2 izdkj ds Operations dks Perform fd;k tkrk gSaA { printf("Stack is full");
(1) Push Operation: -Top ij dksb Hkh u;k Element Mkyuk ;k getch( );
tksM+uk Push Operation dgykrk gSaA tc Hkh Push Operation exit(0);
gksrk gSa] Top esa ,d la[;k Mkyh tkrh gSa vkSj Top ,d }
Level c<+rk gSaA ,slk djrs djrs ,d Level ij vkdj og iwjk else
Hkj tkrk gSa rks og fLFkfr STACK-FULL fLFkfr dgykrh {
gSaA prinf("Enter the element to be inserted");
(2) Pop Operation: - Top ij ls Element dks Delete djus dh fØ;k scanf("%d", & item);
dks Pop Operation dgrs gSaA gj Pop Operation ds ckn Stack top=top+1;
,d Level de gks tkrk gSaA lkjs Element [kRe gksus ds ckn stack[top] = item;
Stack Under Flow fLFkfr esa igq¡p tkrk gSaA }
}
Stack Implementation With Array
lcls igys Stack Array dks fuEu izdkj Define fd;k tk;sxkA Algorithm for Deleting an Element from the Stack
(1) Define the Maximum Size of the Stack Variable 1. [Check for the Stack under flow]
(1) ,d Int Stack Variable dks Array define dj Maximum Size Declare if Top<0, then
djukA printf("Stack under flow") and exit
#define MAXSIZE 10 else [Remove the Top element]
int stack [MAXSIZE]; Set item=Stack [Top]
2. Decrement the stack top
(2) ,d int Top dks –1 ls Initialized fd;k tk;sxkA set Top = Top-1
(2) Define the Integer Variable Top and Initialized it with -1 3. Return the deleted item from the stack.
4. Exit.
Algorithm for Push Operation
Let Stack[Max size] is an array for implementing stack. Function for Pop Operation
1. [Enter for stack overflow ?] int pop( )
if Top = MAXSIZE –1, then : print : overflow and exit. {
2. Set Top = Top+1[Increase Top by 1] if(top = = -1)
3. Set STACK[TOP] : = ITEM [Insert new element] { printf ("The stack is Empty")
4. Exit. getch( );
exit(0);
Function for Push Operation }

5 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
else Algorithm for Pop
{ item = stack[top]; Step1- set int data (,d data uked Variable dks intialize
top = top-1; djk,aA)
} Step2- set struct *t = top (Stack ds VkWi ij struct node izdkj
return(item); ds Varialbe t dks HkstsaA)
} Step3- check whether top = NULL (tkapas fd D;k top, NULL ij
gSA)
Stack Implementation with Link List if yes then (;fn gk¡ rks
Algorith For Push Function Process step 4 to 5 4 ls 5 rd ds step dks djsa
Step1- struct node n = (struct node) malloc (size of (struct node)) else vU;Fkk
(malloc Function ds }kjk ,d struct node izdkj ds Pointer process step 6 to 9 6 ls 9 rd ds step dks djsaA)
n dks Memory fnyk,aA) Step4- print ("underflow") (underflow dks fizUV
Step2- set n info = data (vFkkZr~ n dh info esa data dks djk,aA)
lqjf{kr djsaA) Step5- Exit (0) (Main() Function ls ckgj vk
Step3- n next = top (n ds next {ks= esa top dk address tk,aA)
(irk) HkstsaA) Step6- set data = t info (t ds info {ks= esa lqjf{kr
Step4- set top = n (top dks n ij HkstsaA) lwpuk dks MkVk esa lqjf{kr djk,aA)
Step5- Exit Step7- set top = top next (top dks mlds vxyh Node ij
HkstsaA)
Function to Insert an Item in the Stack Step8- free (t) (t esa lqjf{kr Memory dks
void push (stack **top, int value) eqDr djk,aA
{ Step9- return(data) (data esa lqjf{kr lwpuk
stack *ptr; dks main( ) Function esa HkstsaA
ptr = (stack*) malloc (sizeof(stack)); Step10- Exit
if (ptr = = NULL)
{ Function to Delete an Item From the Stack
printf("\nUnable to allocate to memory for new node..."); int pop (stack **top)
printf("\nPress any key to exit ..."); {
getch( ); int temp;
return; stack *ptr;
} temp = (*top)->info;
ptr->info = value; ptr = *top;
ptr->next = *top; *top = (*top)->next;
*top = ptr; free(ptr);
} return temp;
6 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
}
MULTIPLE STACKS APPLICATION OF STACKS
;fn Stack dks Array ds }kjk Implement fd;k tkrk gSa rks Stack esa Stack dks Main Data Structure dh rjg Use esa fy;k tkrk gSaA bldh
Sufficient Space dks Allocate fd;k tkuk pkfg, ;fn Array ds }kjk dqN Application fuEu gSaA
allocate Space de gksxh rks Overflow Condition Occur gks tk;sxh bls (1) Stack dks Function ds chp Parameters Pass djus ds fy, Use esa
nwj djus ds fy, Array esa vkSj Memory dks allocate djuk fy;k tkrk gSaA
gksxkA ;fn Number of Overflow dks de djuk gSa rks blds fy, (2) High level Programming Language tSls Pascal, C vkfn Stack dks
Large Space Of Array dks Allocate djuk gksxk ftlls Memory ds waste Recursion ds fy, Hkh Use esa ysrs gSaA
gksus dh lEHkkouk Hkh c<+ tkrh gSaA
bl izdkj dh Condition ds fy, ,d ls T;knk Stack dks ,d Array esa Stack dks cgqr lh Problems dks solve djus ds fy, Use esa fy;k tkrk
cuk;k tk ldrk gSaA gSaA eq[;r% 3 Notation esa Stack dks iznf'kZr fd;k tkrk gSaA
(1) Prefix Notation
Representing Two Stack: - (2) Infix Notation
,d gh Array esa 2 Stack dks Implement fd;k tk ldrk gSaA bu (3) Post Fix Notation
nksuks Stack dh Size 0 ls N-1 rd gksxh tc nksuks Stacks dks
Combine fd;k tk;sxk rks budh Size N (Array Size) ls T;knk ugha
gksxhA Infix Notation : - Normally fdlh Hkh Expression dks ;k Instruction dks
0 1 2 .... ..... n-3 cukus ds fy, 2Values dh vko';drk gksrh gSaA
n-2 n-1 (1) Operand
 (2) Operator
 vr% Operator o Operand ls feydj ,d Expression ;k Instruction curh
Stack-A gSaA tSls
Stack - B A+B ;gka ij A vkSj B Operand gSa rFkk + ,d Operator gSaA vr%
Stack-A Left ls right dh rjQ c<+rh gS rFkk Stack-B Right ls Left dh Infix Notation esa Operands ds chp Operators gksrs gSaA
rjQ c<+rh gSaA
Precedence of Operator: -
Representing More Than Two Stack: - Highest: Exponentiation ()
,d gh Array esa 2 ls T;knk Stack dks Hkh Implement fd;k tk ldrk Next highest: Multiplication (*) and division (/)
gSaA gj Stack dks Array esa Equal Space fn;k tkrk gSa vkSj Array Lowest: Addition (+) and subtraction ( - )
Indexes dks Define dj fn;k tkrk gSaA
b[1] t[1] b[2] t[2] b[3] t[3] b[4] t[4] b[5] Prefix Notation: - Prefix Notation og Notation gSa tgka ij Operator
t[5] b[6] t[6] Operand ls igys vkrk gSaA tSls +AB
     
Stack 1 Stack 2 Stack 3 Stack 4 Stack 5
Stack 6
7 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Post Fix Notation: - ;g og Notation gSa tgka Operator Operand ds (AB+)-C
ckn vkrs gSa tSls AB+ Post Fix Notation dks Suffix Notation ;k AB+C-
Reverse Police Notation gh dgk tkrk gSaA
Conversion of Notation: - ;fn fdlh Expression dks Infix Notation esa (3) A*B+C/D
fy[kk x;k gS vkSj bUgsa Solve djuk gSa rks blds fy, Bodmass ds ;g Multiplication dh Precedence High gSaA vr% lcls igys
Rule dks Use esa fy;k tkrk gSaA tSls Multiplication dks Solve fd;k tk;sxkA
A+B*C ;g A=4, B=3 vkSj C = 7 Solution: -
4+3 x 7 = 7 x 7 = 49 (A*B)+C/D
mijksDr Expression dk Solution xyr gSa D;ksafd Bodmass ds fglkc (AB*) + C/D
ls igys * gksuk pkfg, ckn esa Edition gksuk pkfg, Divide dh Precedence High gSaA
(AB*) + (C/D)
Conversion Into Infix To Postfix (AB*) + (CD/)
A+B * C (Infix Notation) AB*CD/+ (Post Fix Notation)
A+ (B * C)
A + (BC *) (B * C dks Postfix Notation esa cnyk x;k) (4) (A+B)/(C-D)
vc BC* ,d Operand gSa vkSj A ,d Operand gSaA vr% vc bls Postfix oSls rks Division dh Precedence High gSa ijUrq mlls Hkh High
Notation esa Convert fd;k tk;sxkA Bracket dh Precedence gksrh gSa vr% lcls igys Bracket dks Solve
ABC*+ ;g A+B*C dk Postfix Notation gSaA fd;k tk;sxkA
(AB+)/(CD-)
(1) Example of Postfix Notation: - A + [(B+C)+(D+E)*F]/G ds fy;s AB+CD-/
Postfix Form iznku dhft;sA
Solution: - (5) (A+B)*C/D+E^F/G
lcls igys Bracket dks solve fd;k tk;sxk ;gka lcls High Precedence (^) Operator dh gSaA vr% lcls igys
A+[(BC+)+(DE+)*F]/G Bracket dks vkSj mlds ckn (^) dks solve fd;k tk;sxk
Bracket ds vUnj Multiplication dh Precedence High gSa vr% igys (AB+)*C/D+E^F/G
Multiplication dks Solve fd;k tk;sxkA (AB+)*C/D+EF^/G
A+[(Bc+)+(DE+F*]/G AB+C*/D+EF^/G
A+[BC+DE+F*+]/G AB+C*D/+EF^G/
Plus o Division ds chp Division dh Precedence High gSa vr% AB+C*D/EF^G/+
A+BC+DE+F*+G/
ABC+DE+F*+G/+ Conversion Into Infix To Prefix Notation
Prefix Expression esa igys Operators vkrs gSa rFkk ckn esa
(2) A+B-C ds fy;s Postfix Form iznku dhft;sA Operands dks fy[kk tkrk gSaA Prefix dks fuEu izdkj Solve djrs
Solution: - gSaA
(A+B)-Cx
8 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
1. A*B+C (2) fdlh Element dks Queue ls Delete djukA
Multiplication dh Precedence High gSa vr% igys Multiplication fdlh Hkh Element dks tc Queue esa Add djuk gks rks mlds fy,
dks Solve fd;k tk;sxkA Queue ds Last esa Add fd;k tkrk gSaA Queue ds Last dks Rear dgrs
(A*B)+C gSa rFkk tgka ls Data Element dks Remove fd;k tkrk gSaA og
(*AB)+C Front dgykrk gSaA
+*ABC
Insert Element In The Queue: -
2. A/B^C+D 1. Initialize front = 0 and rear = -1
^Operator dh Precedence High gSa vr% lcls igys ^ dks Solve 2. if Rear>= MAXSIZE
fd;k tk;sxkA write Queue Overflow and return
A/(B^C) + D else;
A/(^BC) + D Set Rear = rear +1
/A^BC + D 3. Queue [Rear] = item ;
+/A^BCD 4. if Front = -1 [Set the Front Pointer]
3. (A-B/C)*(D*E-F) 5. Return.
Left to Right Associativity ds According lcls igys First Bracket
dks Solve fd;k tk;sxkA blds vUnj Hkh Operator Precedence Function for Insert an Item in the Queue: -
ds According Solution fd;k tk;sxkA void insert (int item)
(A-(B/C))*((D*E)-F) {
(A-/BC)*((D*E)-F) if(rear>=maxsize)
-A/BC*(*DE-F) { printf("Queue overflow");
-A/BC*(-*DEF) break;
*-A/BC-*DEF }
else
Introduction to Queue {Rear = Rear+1;
Queue Logical First in First Out (FIFO) rjg dh List gSa bls Normally Queue [Rear] = item;
Use esa fy;k tkrk gSaA Queue dks nks rjg ls Implement fd;k tk }
ldrk gSaA
(1) Static Implementation Delete Element From the Queue: -
(2) Dynamic Implementation 1. If front <0 [Check UnderFlow Condition]
ftl Queue dks Array ds }kjk Implement fd;k tkrk gSaA og Static Write Queue is Empty and return
gksrh gSa vkSj ftl Queue ds fy, Pointers dks Use esa ysrs gSaA 2. else ; item = Queue [front] [Remove Element from Front]
mls Dynamic Queue dgk tkrk gSaA fdlh Hkh queue ij nks rjg ds 3. Find new Value of front
Operation dks Perform fd;k tkrk gSaA if (front = = Rear) [Checking for Empty Qeueu]
(1) Queue esa Value Insert djukA Set Front = 0 ; rear = -1; [Re-initialize the Pointer]

9 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
else tem=tempnext
Front = Front+1; 7. Temp = tempNEWPTR
Function for Delete an Item from the Queue: - 8. End.
void delete( ) Algorithm for Deletion
{ 1. if(front = = NULL)
if (Front<0) write Queue is empty and exit
{ printf"Queue is empty"); else
break; temp = start
} value = tempno
else Start = Startnext
{ free(temp) [End else]
item=Queue[Front]; return(value) [End if]
Front=Front+1; 2. Exit.
printf("item deleted=%d",item);
} Circular Queue
} Linear Queue dh rjg gh Circular Queue esa Hkh Insertion, Initialization
Queue Implementation with Link List Underflow Condition dh Testing vkfn dks Perform fd;k tkrk gSaA
Algorithm for Insertion vU; Operations dqN Different gksrs gSaA
1. Struct_Queue NEW PTR, *temp [Declare variable type Testing of Overflow Condition in Circular Queue: - fdlh Hkh u;s
struct_queue] Element dks tc Circular Queue esa Insert djuk gks rks mlls igys
2. temp=start [Initialize temp] Circular Queue esa Space Allocate djuk iM+rk gSa vkSj mlls igys
3. NEW = new node [Allocate memory for Circular Queue Full gSa ;k ugha mls Check fd;k tk;sxkA ;fn Queue
new element] Full ugha gSa rks Queue ds Rear esa Insert Operation Perform fd;k
4. NEWno = value [Insert value into the tk;sxkA
data filed of front = 0 and rear = capacity –1
element]; front = rear + 1
5. NEWPTRNEXT=NULL vxj buesa ls ;s nksuks Conditions Satisfy gksrh gSa rks Circular
6. If (Rear = = NULL) [Queue is empty, and Queue Full gksxhA
element to be
entered is first Function For Checking The Full Condition Of The Queue: -
element] boolean isFull(queue *pq)
Set Front = NEW PTR {
Set Rear = NEW PTR if(((pq->front = = 0) && (pq->rear = = CAPACITY-1))
else : ||(pa->front = = pq->rear+1))
while(tempnext = NULL) return true;
10 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
else pq->rear = (pq->rear + 1) % CAPACITY;
return false; /* store element at new rear */
} pq->elements[pq->rear] = value;
Circular queue esa ;fn Data Item Insert djuk gks vkSj Circular Queue
Full ugha gSa rks fuEu Operations dks Perform fd;k tk;sxkA DEQUEUE
Dequeue ,d izdkj dh Queue gSa ftlesa Elements dks fdlh Hkh End
Insert Item in a Circular Queue ls Remove vkSj Add fd;k tk ldrk gSa ijUrq Middle ls Insert ugha
blds fy, 3 Conditions dks /;ku esa j[kk tkrk gSaA ;fn Circular fd;k tk ldrkA Dequeue dks Double Ended Queue dgk tkrk gSaA
Queue full ugha gSa rks dkSulh Condition Occur gksxh og fuEu Dequeue nks izdkj dh gSaA
gSa % & (1) Input Restricted Dequeue: - blesa Insertion rks Rear ls gksrk
(1) ;fn Queue Empty gSa rks Front vkSj Rear dks –1 ;k 0 ls Set dj gSa ijUrq Deletion Front vkSj Rear nksuks ls fd;k tk ldrk
fn;k tkrk gSaA gSaA
(2) ;fn Queue Empty ugha gSa rks Rear dh Value Queue ds Last (2) Output Restricted Dequeue: - blesa Insertion Front vkSj Rear
Element dks Pointer djsaxs vkSj Rear Increment dj fn;k nksuks ls gksrk gSa ijUrq Deletion flQZ Front ls fd;k tkrk
tk;sxkA gSaA
(3) ;fn Queue Full ugha gSa rks Rear Variable dks Capacity –1 ds
= gksxk rFkk Rear Variable dks 0 ls Initialize dj fn;k tk;sxkA PRIORITY QUEUE
Priority Queue og Queue ftlesa gj element dh Priority dks Assign fd;k
void enqueue (queue *pa, int value) { tkrk gSa vkSj fdl Order esa Element dks Delete fd;k tk;sxk ;k
/* adjust rear variable Process fd;k tk;sxk blds fy, fuEu Rules dks Follow fd;k tkrk gSaA
if (pq->front = = -1) (1) Highest Priority Element dks lcls igys Process fd;k tk;sxkA
pq->front = pq->rear = 0; (2) nks ;k nks ls vf/kd Elements ftudh Priority Same gSa
else if (pq->rear = = CAPACITY-1) mUgsa Queue esa os fdl vk/kkj ij Add fd;s x;s gSa ds }kjk
pq->rear = 0; Process fd;k tk;sxkA
else Priority Decide djus ds fy, dqN vU; rjhds Hkh Define fd;s tk
pq->rear++; ldrs gSa
/* store element at new rear */ (1) cM+h Jobs ij NksVh Jobs dh Priority High gksrh gSa vr%
pq->elements [pq->rear] = value; lcls igys Small Jobs dks Execute fd;k tk;sxkA
} (2) Amount ds vk/kkj ij gh fdlh Hkh Job dh Priority dks Set fd;k
tk ldrk gSaA
void enqueue(queue *pq, int value) { (3) ;fn dksbZ Job High Priority ds lkFk Queue esa Enter gksrh
/* adjust rear variable */ gSa rks lcls igys mls gh Execute fd;k tk;sxkA Memory esa
if (pq->front = = -1) Priority queue dks 3 izdkj ls iznf'kZr fd;k tk ldrk gSaA
pq->front = pq->rear = 0; (i) Linear Link List
else (ii) Using Multiple Queue
11 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(iii) Using heap (2) tc Jobs dks Network Printer ij Submit fd;k tkrk gSa rks os
Arrival ds Order esa Arrange gksrk gSaA
Link List Representation: - bl izdkj dh Queue dks tc Link List dh rjg (3) ;g ,d izdkj dk Computer Network gSa tgka ij Disk ,d
iznf'kZr fd;k tkrk gSa rks List ds izeq[k 3 Fields (gj Node ds) Computer ls Attach gksrh gSa ftls File Server dgk tkrk gSaA
gksrs gSaA vU; Computers mu Files dks FCFS (First Come First Server) ds
(1) Information Field ftlesa Data Elements dks Store fd;k tkrk vk/kkj ij access djrs gSaA
gSaA (4) Queue Application dks Real Life esa Hkh Use esa fy;k tkrk
(2) Priority Field ftlesa Element ds Priority Number dks Store fd;k gSa tSls Cinema Hall, Railway Reservation, Bus Stand vkfnA
tkrk gSaA
(3) Next Pointer Link ftlesa Queue ds Next Element dk Address UNIT – II
gksrk gSaA Link List
;fn fdlh Programs ds Execution ds igys Memory dks Divide fd;k
Multiple Queue Representation tkrk gS rks og Static gks tkrh gS vkSj mls Change ugha fd;k tk
Multiple Queue ;k Priority Queue dks Ascending Priority Queue dk ldrk ,d fo'ks"k Data Structure ftls Link List dgrs gSaA og Flexible
Descending Priority Queue esa Hkh divide fd;k tkrk gSaA Storage System iznku djrk gSaA ftldks Array ds iz;ksx dh vko';drk
(1) Ascending Priority Queue : - bl izdkj dh queue esa lcls NksVs ugha gksrh gSaA Stack vkSj Queue dks computer memory esa
Item dh Priority lcls vf/kd gksrh gSaA vr% lcls NksVs Item iznf'kZr djus ds fy, ge Array dk iz;ksx djrs gSaA ftlls Memory
dks lcls igys Delete fd;k tk;sxkA dks igys ls Declare djuk iM+rk gSA blls Memory dk Wastage gksrk
(3) Descending Priority Queue: - bl izdkj dh queue esa lcls cM+s gSaA Memory ,d egRoiw.kZ Resource gSa vr% bls de ls de Use
Item dh Priority lcls vf/kd gksrh gSaA vr% lcls cM+s Item esa ysdj vf/kd ls vf/kd Programs dks Run djuk pkfg,A
dks lcls igys Delete fd;k tk;sxkA Link List ,d fo'ks"k izdkj ds Data Element dh List gksrh gSa tks ,d
& nwljs ls tqM+h gksrh gSaA Logical Ordering gj Element dks
Heap Representation of Priority Queue vxys Element ls Point djrs gq, Represent djrs gSaA ftlds nks Hkkx
Heap ,d Complete Binary Tree gSa ftldh dqN Additional Property gksrs gSaA
gksrh gSaA tSls ;k rks Root Element Small gksxk ;g Largest (1) Information Part
gksxkA ;fn Root Element lcls NksVk gks mls Minimum Heap dgk (2) Pointer Part
tkrk gSaA ;fn Root Element Largest gks rks mls Maximum Heap dgk
tk;sxkA

Application of Queue
Queue dh dqN Application fuEu gSa %&
(1) Queue ds }kjk cgqr lh Problem dks vklkuh ls Solve dj fn;k
tkrk gSa tSls BFS (Breadth First Search) ;k DFS (Depth First
Search)

12 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(iii) vkSj List ds e/; esa
STAR (4) Traversing : - ;g izfØ;k fdlh Link List dks ,d Point ls nwljs
T Point rd Values dks Print djokus ds dke vkrh gSaA vxj igys
INF INF X Node ls vk[kjh Node dh vksj Traversing djrs gSa rks ;g
O O Forward Traversing dgykrh gSaA
STAR (5) Con Catenation: - ;g izfØ;k nwljs List ls Node dks tksM+us
T ds dke vkrh gSa ;fn nwljh List ij Node gksrk gSa rks
Prev Info Next Prev Info Next Prev Info Next Concatenation Node esa M+N Node gksxk
Node Node (6) Display: - ;g Operation izR;sd Node dh lwpuk dks Point djus
Link List s s ds iz;ksx esa vkrk gSaA vr% Information Part dks Print
djuk gh List Display dgykrk gSaA
Singe Link List esa ,d Node esa nks Parts gksrs gSaA
(1) Information Part TYPES OF LINK LIST
(2) Link Part lk/kkj.kr;k% List dks 4 Part esa ckaVk tkrk gSaA
tcfd Doubly Link List esa nks Pointer Part rFkk ,d Information Part (1) Single Link List
gksrk gSaA (2) Doubly Link List
Operation on Link List (3) Circular Link List
Link List esa fuEu Basic Operation dks Perform fd;k tkrk gSaA (4) Circular Double Link List
(1) Creation : - ;g Operation Link List cukus ds fy, Use esa ysrs (1) Single Link List : - Single Link List ,slh Link List gksrh gSa
gSaA tc Hkh vko';drk gks fdlh Hkh Node dks List esa ftlesa lkjs Node ,d nwljs ds lkFk Øe esa tqM+s gksrs
tksM+ fn;k tkrk gSaA gSa blfy, bldks Linear Link List Hkh dgrs gSaA bldk
(2) Insertion : - ;g Operation Link List esa ,d u;h Node dks izkjEHk vUr gksrk gSaA blesa ,d leL;k ;g gSa fd List ds
fo'ks"k fLFkfr esa fo'ks"k LFkku ij tksM+us ds fy, dke vkxs okys Node rks Access fd;k tk ldrk gSa ijUrq ,d ckj
esa fy;k tkrk gSaA ,d u;h Node dks fuEu LFkkuksa ij Pointer ds vkxs tkus ds ckn ihNs okys Node dks Access
Insert fd;k tk ldrk gSaA ugha fd;k tk ldrk gSaA
(i) List ds izkjEHk esa
(ii) List ds vUr esa STAR
(iii) fdlh List ds e/; esa T
(iv) vxj List iwjh [kkyh gSa rc u;k Node Insert
fd;k tkrk gSaA 1 2 3
(3) Deletion: - ;g Operation Link List ls fdlh Node dks Delete djus 0 Single Link List 0 0
ds fy, iz;ksx esa fy;k tkrk gSaA Node dks ftu rjhdksa ls
Delete fd;k tkrk gSa og fuEu gSaA (2) Doubly Link List: - Doubly Link List og Link List gksrh gSa
(i) List ds izkjEHk esa ftlesa lkjs Node ,d nwljs ds lkFk Multiple Link ds }kjk
(ii) List ds vUr esa tqM+s gksrs gSaA blds vUrxZr List ds vkxs okys Node o
13 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
List ds ihNs okys Node nksuks dks Access fd;k tk ldrk HEADER NODE
gSaA blhfy, Doubly Link List esa igys Node dk Left vxys dHkh&dHkh ,d Extra Node dks List ds Front esa j[kuk vko';d gks
Node ds Right dk Address j[krk gSaA tkrk gSaA bl Node esa fdlh Item dks Represent ugha fd;k tkrk ;g
STA Node Header Node ;k List Header dgykrk gSaA bl Node dk
RT Information Part Unused gksrk gSaA bl Node ds Information Part esa
Pr Da Su Pr Da Su Pr Da Su List dh Global Information dks j[kk tkrk gSa tSls Header Node ds
ev ta
1 cc ev ta
2 cc ev ta
3 cc vUrxZr ds List esa fdrus Nodes gSa dh Information dks Store fd;k
0 0 0 tkrk gSaA (Not Including Header Node) bl izdkj ds Data Structure esa
Doubly Link List fdlh Hkh Data Item dks add vkSj Delete djus ds fy, Header Node dks
Hkh Adjust djuk iM+rk gSaA Number of Nodes fdrus gSaA bls
(3) Circular Link List: - Circular Link List ,slh Link List gksrh gSa Directly Header Node ls Access dj fy;k tkrk gSA blds fy, List
ftldh dksbZ 'kq:vkr o vUr ugha gksrk gSaA ,d Single Link Traversing dh vko';drk ugha iM+rh gSaA
List ds igys Node ls vfUre Node dks tksM+ fn;k tkrk gSaA Header Node dk ,d vU; mnkgj.k fuEu gSaA ,d Particular Machine dk
vr% List ds Last Node esa List ds First Node dk Address j[kk cukus ds fy, fuEu Parts dks Use esa fy;k tkrk gSaA tSls B841,
tkrk gSaA K321, A087, J492 vkfnA bl Assembly dks List }kjk iznf'kZr fd;k
STAR tkrk gSaA Empty List dks NULL Pointer ds }kjk iznf'kZr djrs
T No 1 No 2 No 3 No 4 gSaA
de
1 de
2 de
3 de
4
0 0 0 0 Operation of Single Link List
Circular Link List Single List esa Structure dks Use esa fy;k tkrk gSaA D;ksafd ,d
Node nks vyx Data Types dh Value dks Store djrk gSaA
(4) Circular Doubly Link List: - ;g ,d ,slh List gksrh gSa ftlesa (1) Information Part
nksuks Pointer (1) Successor Pointer (2) Pre-Decessor Pointer (2) Link Part
Circle Shape esa gksrs gSaA vr% Link List cukus ds fy, lcls igys Link List ds Structure dks
START cuk;k tk;sxkA
struct node
{
int info;
10 20 30 struct node * link;
};

Characteristics of Link List

Circular Doubly Link List
(1) bl izdkj dh Link List esa ,d Node esa nks vyx Data Type dh
Values dks Store fd;k tkrk gSaA

14 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(i) Information Part : - ftlesa fdlh Hkh (int, char, double, (2) Display List: - List dks 'kq:vkr ls Last rd Traverse fd;k tkrk
long vkfn Data Type dh Values dks Store fd;k tk gSaA blds fy, ,d Head Pointer dh vko';drk gksrh gSaA lkFk
ldrk gSa) gh ,d vkSj Temporary Pointer dh vko';drk gksrh gSa tks
(ii) Pointer Part: - Pointer Part ftlesa Next Node dk List ds Last Node rd tkrk gSaA List dk Last Node og Node
Address gksrk gSaA vr% Link Part ds }kjk gh gSa ftlds Link Part esa NULL gksrk gSa vr% nks struct
Next Node dks Access fd;k tk ldrk gSaA Node Pointer dh vko';drk gksxh ftlesa igyk List ds First
(2) List ds ftl Node ds Link Part esa NULL gksrk gSaA og List Node dks Point djsxk rFkk nwljk ,d ds ckn ,d Next Node ij
dk Last Node dgykrk gSaA tk;sxk vkSj Information Part dks Print djsxkA
(3) ;fn List [kkyh gS rks Information vkSj Link Part nksuks Function: -
NULL gksxsaA void printlist (struct node*head)
(4) ;fn Information Part esa Value gS rFkk ml Node dk Link Part {
NULL gSa vr% List esa ,d Item gSaA struct node*t;
(5) ;fn Link Part esa nwljs Node dk Address gSa vr% List [kkyh t = head;
ugha gSaA if (t == NULL)
(6) Link List ds vUrxZr ,d Pointer List ds First Node dks Point {
djrk gSaA ftlls List ds Last Node rd igqapk tk ldrk gSaA printf ("\n list is empty");
return;
}
Operations on Link List else
(1) Create an Empty Link List: - while (t link != NULL)
(1) ,d Node Pointer head cuk;k tk;sxk ftlesa fdlh Value dks {
Initialize ugha fd;k x;k gSaA ;g Pointer List ds First Element printf ("%d", t info);
dks Point djus ds fy, Use esa fy;k tkrk gSaA t = t link;
(2) 'kq:vkr esa List Empty gksxh vr% Head Pointer dks NULL ls }
Initialize fd;k tk;sxkA }
(3) ;g iznf'kZr djrk gSa fd List Empty gSa blds fy, C esa fuEu
Function dks cuk;k tk;sxkA Insertion in Link List: - fdlh Hkh Element dks List esa Insert djus ds
fy, lcls igys Free Node dh vko';drk gksrh gSaA tc Free Node cuk
Function: - fy;k tkrk gSa rks Node ds Information Field esa Data Value dks add
void emptylist (struct node*head) dj nsrs gSa vkSj bl u;s Node dks mldh txg ij Add dj fn;k tkrk
{ gSaA fdlh Hkh List esa Insertion 3 izdkj ls fd;k tk ldrk gSaA
head = NULL; (1) List ds Beginning esa
} (2) List ds End esa
(3) fdlh fn;s x;s Element ds ckn

15 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Insertion at the Beginning: - fdlh Hkh Element dks List ds First esa (2) New Node dh Information Part esa Data Value Insert djsaxsA
Add djus ds fy, lcls igys List Empty gSa ;k ugha bls check fd;k (3) New Node ds Link Part esa NULL MkysaxsA
tk;sA ;fn List Empty gSa rks u;k Node gh List dk First Node gksxk (4) vc Head Pointer New Node dks Point djsaxkA
blds fy, fuEu Steps dks Perform djsaxsA
(1) New Node cuk;sxsaA ;fn List Empty ugha gSa rks List dks Traverse dj Last Element rd
(2) New Node ds Information Part esa Data Value Enter djsaxsA igqWapsaxs vkSj ckn esa Last esa u;s Node dks Insert dj fn;k
(3) New Node ds Link Part NULL Value Insert djsaxs vkSj vc tk;sxkA blds fy, fuEu Steps dks Follow djasxsA
(4) List dk Pointer Head ml u;s Node dks Point djsxkA (1) New Node cuk;sxsaA
;fn List Empty ugha gS rks u;s Node dks List ds lcls vkxs Add dj (2) New Node dh Information Part esa Data Value Insert djsaxsA
fn;k tk;sxkA blds fy, fuEu Steps dks Follow djsaxsA (3) New Node ds Link Part esa NULL MkysaxsA
(1) New Node cuk;sxsaA (4) vc Head Pointer ds vykok ,d u;s Pointer dh vko';drk gksxh
(2) New Node ds Information Part esa Data Value Enter djsaxsA tks List ds Last Node rd tk;sxkA
(3) New Node ds Link Part esa Head (List Pointer tks List ds First (5) List ds Last Node ds Link Part esa u;s Node dk Address
Item dks Point dj jgk gS) dk Address MkysaxsA Mkysaxs
(4) vc Head New Node dks Point djsaxk
Function:-
Function: - void insertatlast (struct node**head, int item)
void insert (struct node ** head, int item) {
{ struct node * new, *temp;
struct node*new; new = malloc (sizeof (struct node));
new = malloc (sizeof (struct node)); new info = item;
new info = item; new link = NULL;
if (*head = = NULL) //if the list is empty if (*head = = NULL) //if list is empty
new link = NULL; *head = new;
else else
new link = *head; {
* head = new; temp = *head;
} while (temp link != NULL)
temp = temp link;
Insert at The End of the list: - ;fn fdlh Element dks List ds End esa temp link = new;
Insert djuk gks rks lcls igys List Empty gSa ;k ugha Condition dks }
Test fd;k tk;sxk ;fn List Empty gSa rks u;k Node List dk First Node }
Hkh gksxk vkSj List dk Last Node Hkh gksxkA vr% fuEu Steps
dks Perform djsaxsA Insert After The Given Element Of The List: - ;fn u;s Node dks fdlh
(1) New Node cuk;saxsA fn;s x;s Element ds ckn Insert djuk gks rks lcls igys ml Location
16 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
dks Findout fd;k tk;sxk tgka Node dks Add djuk gSa vkSj blds }
ckn List esa u;s Node dks Add dj fn;k tk;sxkA blds fy, fuEu Steps
dks Perform djrs gSaA Delete The Element From The List
(1) New Node cuk;saxsA fdlh Hkh Element dks List ls Delete djus ds fy, lcls igys Pointers
(2) New Node dh Information Part esa Data Value Insert djsaxsA dks Properly Set fd;k tkrk gSaA ckn esa ml Memory dks Free dj
(3) ,d Temporary Pointer ysaxs tks List ds ml Element dks Point fn;k tkrk gSaA ftls Node }kjk Use esa fy;k tk jgk FkkA List dk
djsxk ftlds ckn u;k Node Add djuk gSaA ;fn Deletion 3 txg ls fd;k tk ldrk gSaA
(4) ;fn Temporary Pointer NULL rd igq¡p tkrk gSa vr% List eas (1) List ds Beginning ls
Item ugha gSa ftlds ckn u;s Node dks Add djuk gSa (2) List ds End ls
(5) ;fn Temporary Pointer ml Item dks <w¡< ysrk gSa rks fuEu (3) fn;s x;s Element ds ckn okys Node dks Delete djuk
Steps dks Follow djsaxsA
(i) u;s Node ds Link Part esa Temporary Pointer ds (1) Delete the Element from the beginning of the List: - tc List ds First
Link Part dks Mky nsaxsA Element dks Delete djuk gks rks blds fy, fuEu Steps dks Perform
(ii) Temporary Pointer ds Link Part esa New Node dks fd;k tkrk gSaA
Mky nsaxs (i) Head dh Value dks fdlh Temporary Variable esa
Assign djukA
Function: - (ii) vc head ds Next Part dks Head esa Assign dj fn;k
void insertatmiddle (struct node **head, int loc, int item) tk;sxkA
{ (iii) tks Memory ptr }kjk Point dh tk jgh gS mls
struct node * new, * temp; Deallocate dj fn;k tk;sxkA
int i;
temp = *head; Function: -
for (i = 0; i < loc; i++) void deletefromfirst (struct node **head)
{ {
temp = temp link; struct node*ptr;
if (temp = = NULL) if (*head == NULL)
{ return;
printf ("item not found"); else
return; {
} ptr = *head;
} head = (*head)  link;
new = malloc (sizeof (struct node)); free (ptr);
new info = item; }
new link = temp link; }
temp link = new;
17 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Delete From End Of The List: - fdlh Hkh Element dks List ds End ls while (ptr link != NULL)
Delete djus ds fy, lcls igys List dks Second Last Element rd Traverse {
fd;k tk;sxkA blds ckn Last Element dks Delete djus ds fy, fuEu loc = ptr;
Steps dks Follow fd;k tk;sxkA ptr = ptr link;
(1) ;fn head NULL gSa rks List esa dksbZ Data Item ugha gSa }
vr% fdlh Item dks Delete ugha fd;k tk ldrkA loc link = NULL;
(2) ,d Temporary Pointer ysaxs ftlesa head dh value dks assign free(ptr);
djsaxsA }
(3) ;fn head dk link part NULL gSa rks List esa ,d Item gSa ftls }
Delete djuk gSaA
(4) bls Delete djus ds fy, head esa NULL Assign dj nsaxs vkSj Delete After A Given Element Of The List: - tc fdlh fn;s x;s Element
Pointer ptr dks Free djs nsaxsA ds ckn okys Element dks Delete djuk gks rks lcls igys Location
(5) ;fn List esa ,d ls T;knk Item gS vr% igys NULL rd tk;sxs dks Find out fd;k tk;sxk ftlds ckn okys Element dks Delete djuk
vkSj ,d Pointer Last Node ds igys okys Node dks Point gSaa blds fy, fuEu Steps dks Follow djrs gSaA
djsxkA (1) blds fy, 2 Struct Node Pointers ysxsaA
(6) IInd Last Node ds Link Part esa NULL Value Assign dj nsaxsA (2) Head Pointer List ds first element dks Point djrk gSa ,d vkSj
(7) og Pointer tks Last Node dks Point dj jgk Fkk mls Free dj Pointer ogha Point djsxk tgka Head Point dj jgk gSA
nsaxsA (3) ;fn Head NULL gS vr% List Empty gSA
(4) ;fn List Empty ugha gS rks ,d vU; Pointer ysxsa tks specific
Function: - location ftls Delete djuk gS ds ihNs jgsxkA
void deletefromlast (struct node **head) (5) vc ihNs okys Pointer ds Link Part esa vkxs okys Pionter dk
{ Link Part Mky nsaxs vkSj List Pointer dks NULL rd c<+krs
struct node *ptr, *loc; jgsaxsA
if (*head = = NULL)
return; Function: -
else if ((*head) link = = NULL) delete (struct node*head, int loc)
{ {
ptr = *head; struct node *ptr, *temp;
*head = NULL; ptr = head;
free (ptr); if (head = = NULL)
} {
else printf ("list is empty");
{ return;
loc = *head; }
ptr = (*head) link; else

18 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
temp = ptr Representation of Doubly Link List
while (ptr != NULL) ekuk dh user Link List esa Integer Values dks Store djuk pkgrk gSA
{ blds fy, Doubly Link List Structure dk memory esa gksuk vko';d
if (ptr info = = loc) gSA vr% Structure define djsaxsA
{
temp link = ptr link; Node Structure: -
free (ptr); struct node
return; {
} int info;
temp = ptr; struct node * prev, *next;
ptr = ptr link; };

} Insert A Node At The Begning

} Doubly Link List ds 'kq: esa fdlh Node dks tksM+us ds fy, ;g
} check djrs gSa fd List [kkyh rks ugha gSA ;g ns[kus ds fy, head
Pointer dks check djrs gSaA ;fn Head NULL gS rks u;s Node dks vc
Doubly Link List Head Point djus yxsxkA ugha rks Head ds Previous Pointer esa u;s
Doubly Link List dks Two way List Hkh dgk tkrk gS ftlesa gj Node Node dk Address Mky fn;k tkrk gSA vr% fdlh Node dks tksM+us
dks 3 Parts esa Divide fd;k tkrk gSA ds fy, fuEu Algorithm fy[ksaxsA
(1) List dk igyk Part Previous Pointer Field dgykrk gS tks List ds
fiNys Element dk address j[krk gSA Step 1:- u;s Node dks Memory Allocate djsaxsA
(2) List dk nwljk Part Information dks Contain djrk gSA struct node * new = malloc (sizeof (struct node))
(3) List dk IIIrd Part Next Pointer dgykrk gS tks List ds vxys Step 2: - ,d Temporary Variable esa Head dk Address MkysaxsA
element dks Point djrk gSA struct node * temp = head
nks Pointer Variable dks Use esa fy;k tkrk gS tks List ds First Step 3: - New Node ds Information Part esa Data Item Insert
Element rFkk List ds Last Element ds Address dks Contain djrs gSaA djsaxsA
List ds First Element ds Previous Part esa NULL jgrk gS tks ;g crkrk new info = item
gS fd bl Node ds ihNs dksbZ vU; Node ugha gSA List ds Last Step 4: - New Node ds Previous Part dks NULL djsaxsA
Element ds Next Part esa NULL jgrk gS tks ;g crkrk gS fd blds new prev = NULL
vkxs dksbZ Node ugha gSA doubly link list dks nksuks Directions Step 5: - New Node ds Next Part esa head dk address MkysaxsA
esa Travers fd;k tk ldrk gSA new next = head
Step 6: - ;g check djsaxs fd head NULL gS ;k ugha ;fn head
NULL gS rks Step 7 dks Execute djsaxs vU;Fkk
Execute djsaxsA

19 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Step 7: - head esa u;s Node dk Mky nsaxs vr% vc head u;s struct node * temp = head
Node dks Poin djsxkA Step 3: - u;s Node ds Information Part esa Data Item Insert
Step 8: - head ds prev part dks New node dk Address MkysaxsA djsaxsA
head prev = new new info = item
head = new (vc head u;s node dks Point djus yxsxk) Step 4: - check that head = NULL
Step 9: - Exit ;fn head NULL gS rks step 5 dks Run djsaxs ;k
vU;Fkk Step6 dks Run djsaxsA
Function: - Step 5: - Insert at first function dks call djsaxs
Insertatfirst (sturct node ** head, int item) vkSj return gks tk;sxsA
{ Step 6: - (1) u;s Node ds Information Part esa Data Item Insert
struct node*new = malloc (sizeof (struct node)); djsaxsA
new  info = item; new info = item
new prev = NULL; (2) u;s Node ds Next Part esa NULL Insert djsaxs
new next = head; new next = NULL
if (head = = NULL) (3) tc rd T dk Next part NULL ugha gks tkrk gSA T
head = new; dks vkxs c<+k,saxsA
else while (temp next != NULL)
{ temp = temp next
head prev = new; (4) temp ds Next Part esa u;s Node dk Address
head = new; MkysaxsA
} temp next = new
} (5) u;s Node ds Prev Part esa temp dk address
MkysaxsA
Insert The Item At The End Of The Doubly Link List new prev = temp
Link List ds Last esa fdlh u;s Node dks tksM+us ds fy, igys ;g Step 7: - Exit
check djsaxs fd List [kkyh rks ugha gS ;fn List [kyh gS rks igyk
Node gh First Node gksxk rFk ogh Last Node gksxkA ;fn List esa Function: -
vkSj Hkh vkbVel gS rks u;s Node dh Information Part esa Data Item addatlast (struct node **head, int item)
rFkk u;s Node ds Next Part NULL Mkysaxs rFkk mls List ds Last {
esa Add dj nsaxsA struct node * temp = *head;
At a last struct node * new = malloc (sizeof (struct node));
Step 1: - u;k Node cu;saxs if (head = = NULL)
stuct node * new = malloc (sizeof (struct node)); {
Step 2: - ,d Temporary * ysaxs ftlesa head dk address Mky insertatfirst (& head, item);
nsaxs return;
20 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
}
new info = item; Step 1:- ,d Temporary Pointer ysaxs ftlesa Head dk address
new next = NULL; Mkysaxs
while (temp next != NULL) struct node *temp = head
temp = temp next; Step 2: - Check djsaxs fd head NULL gS ;k ugha ;fn head
temp next = new; NULL gS rks return gks tk;sxsaA
new prev = temp; if (head = = NULL)
} return
Step 3: - ;fn head NULL ugha gS rks head esa head ds next part
Traversing the Doubly link List dks assign dj nsaxsA
(1) In order Traversal: - blds fy, fuEu Steps dks Follow fd;k tkrk head = head next
gSA free (temp)
Step 1: - tc rd head NULL ugha gks tkrk rc rd List Pointer dks Step 4: - head ftl Node dks point dj jgk gS mlds prev part esa
vkxs c<+k;saxsA NULL Assign djsaxsA
while (head != NULL) head prev = NULL
Step 2: - List ds gj Information Part dks print djsaxs o head dks Step 5:- Exit
vkxs c<+krs tk;saxsA
print head Info Function: -
head = head next deletefromfirst (struct node *head)
(2) Reverse Order Traversal: - blds fy, fuEu Steps dks Follow fd;k {
tkrk gSA struct node *temp = head;
Step 1: - tc rd tail NULL ugha gks tkrk rc rd List Pointer dks if (head = = NULL)
vkxs c<+k;saxsA return;
while (tail != NULL) head = head next;
Step 2: - List ds gj Information Part dks print djsaxs o tail dks free (temp);
vkxs c<+krs tk;saxsA head prev = NULL;
print tail Info }
tail = tail next
Delete From Last: -
Deletion From Doubly Link List: - List ds Last Node dks Delete djus ds fy, lcls igys 3 Conditions dks
(1) Delete from Begning of List: - ;fn doubly link list [kkyh gS rks Check djsaxsA
return gks tk;saxs vU;Fkk ftl Node dks head pointer point dj (1) ;fn List [kkyh gS rks return gks tk;sxsa
jgk gS mls Delete djsaxsA blds fy, fuEu Steps dks Follow (2) ;fn List esa dsoy ,d gh Node gS rks mls delete dj nsaxs
fd;k tk;sxkA ;gka Head Pointer Struct Node Pointer gS tks List vkSj head esa NULL Insert dj nsaxsA
ds first node dks Point dj jgk gSA
21 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(3) ;fn List esa ,d ls T;knk Items gS rks igys Last Node rd head = NULL;
igqapsxs ckn esa Last Node dks Delete dj nsxsaA blds fy, free (temp);
fuEu Algorithm gSaA return;
}
Step 1: - ,d Temporary Pointer ysxsa ftlesa hand dk address while (temp next != NULL)
Mkysaxs temp = temp next;
struct node * temp = head temp prev next = NULL;
Step 2: - ;g check djsaxsa fd head NULL gS ;k ugh ;fn head free (temp);
NULL gS rks return gks tk;saxsA }
Step 3: - ;g check djsaxsa fd head dk Next NULL gS ;k
ughA ;fn head dk Next NULL gS rks 4 ls 6 rd ds steps Circular Link List: - Simple Link List esa Last Node dk Link Part
dks repeat djsaxsA ges'kk NULL gksrk gS ysfdu Circular Link List esa List ds Last
Step 4: - head esa NULL insert djsaxsaA Node ds Link Part esa ges'kk head dk address jgrk gSA vr% Circular
head=NULL Link List dk vk[kjh Node ges'kk List ds First Node dks Point djrk
Step 5: - Temporary Pointer dks Free dj nsaxs gSA
free(t)
Step 6: - return
Step 7: - tc rd temp ds Next part esa NULL ugha vk tkrk rc rd Insert the New Node In the Circular Link List
temp dks vkxs c<+k,xsaA Insert at First:-
while(temp->next==NULL) tc Circular Link List ds izkjEHk esa fdlh u;s Node dks tksM+uk
temp=temp->next gks rks blds fy;s lcls igys ;g Check djsaxs fd List [kkyh rks
Step 8: - temp ds prev ds next part esa NULL insert djsaxsA ugha gSA ;fn head NULL gS rks u;s Node dks Insert dj fn;k tk;sxk
temp->prev->next=NULL vkSj Head Pointer mls Point djsxk ;fn Head NULL ugha gS rks head
Step 9: - Temp dks Free dj nsxsaA ij igqap dj u;s Node dks add dj fn;k tk;sxkA mlds fy;s fuEu
free(temp) Algorithm gSaA
Step 10: - exit Step1: - New Node cuk;saxs
struct node*new = malloc (sizeof (struct node))
Function: - Step2: - ,d Temporary Pointer cuk,xsaA ftlesa head dk address
deletefromlast (struct node *head) MkysaxsA
{ struct node * temp = *head
struct node * temp = head; Step 3: - New Node ds Information Part esa Item Insert djsaxs
if (head = = NULL) new info = item
return;
if (head next = = NULL)
{
22 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Step 4: - Check djsaxs fd head NULL gS ;k ugha ;fn head
NULL gS rks 5th step dks execute djsaxs ugha rks 6th while(temp->next !=*p)
Step execute gksxkA temp=temp->next;
Step 5:- Head esa u;k Node insert djsaxs temp->next=n;
head = new node n->next=*p;
new node next = head }
Step 6: - new node ds next part esa head dk address Mkysaxs
new node next = head Insert at Last: -
temp ds next part esa tc rd head dk address ugha vk blds fy, lcls igys ;g check djsaxs dh List [kkyh gS ;k ugha ;fn
tkrk rc rd temp dks vkxs c<+k,xsaA List esa ,d Hkh Item ugha gS rks appedn function dks call djsaxs
while (temp next != head) ugha rks while loop dh lgk;rk ls ml Node rd igqapsxs tgka temp
temp = temp next ds next esa Head gksxk vFkkZr~ Last Node rd igqpsaxs vc bl
head esa u;s node dk address Mkysaxs Node ds Info Part esa data item insert djsaxs vkSj Node ds Next Part
head = new node esa head dk address Mky nsaxsA blds fy, fuEu Algorithm gSaA
temp ds next part esa head dk address Mkysaxs Step 1: - u;s Node dks memory allocate djsaxs
temp next = head struct node*new = malloc (sizeof (struct node))
Step 7: - Exit Step 2: - ,d Temporary Pointer cuk,xsaA ftlesa head dk address
MkysaxsA
Function: - struct node * temp = *head
struct node Step 3: - New Node ds Information Part esa Item Insert djsaxs
{ new info = item
int data; Step 4: - Check djsaxs fd head NULL gS ;k ugha ;fn head
struct node *next; NULL gS rks 5th step dks execute djsaxs ugha rks 6th
}; Step execute gksxkA
void append(int x,struct node **p) Step 5:- appedn function dks call djsaxs
{ vkSj return gks tk,saxs
struct node *temp=*p,*n=malloc(sizeof(struct node)); Step 6: - new node ds next part esa head dk address Mkysaxs
n->data=x; new node next = head
printf("\nappending:%d",x); temp ds next part esa tc rd head dk address ugha vk
if(temp==NULL)/*list empty*/ tkrk rc rd temp dks vkxs c<+k,xsaA
{ while (temp next != head)
*p=n; temp = temp next
n->next=n; temp ds next part esa head dk address Mkysaxs
return; temp next = new
}

23 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Step 7: - Exit Step 5: - head esa NULL MkysaxsA
head = NULL
Circular List dh Traversing Step 6: - return
Step 1: - ,d Temporary Pointer cuk,xsaA ftlesa head dk address Step 7: - tc rd temp ds Next part esa head dk adres ugha vk
MkysaxsA tkrk rc rd temp dks vkxs c<+k,xsaA
struct node * temp = head while(temp->next != head)
Step 2: - if head = NULL Step 8: - temp=temp->next
return Step 9: - head = head next (head esa head dk next Insert
Step 3: - Repeat Step 4 to 5 while temp next != head djsaxsA)
Step 4: - print temp info Step 10: - temp ds next esa head MkysaxsA
Step 5:- temp = temp next temp next = head
(end of while loop) Step 11: - free(temp)
Step 6: - print temp info Step 12: - Exit
Step 7: - Exit
Delete from Last: -
Delete an Item from the Circular Link List Circular List ds vUr esa ls fdlh Node dks gVkus ds fy, 3 conditions
Delete from first: - Circular Link List ds izkjEHk ls fdlh Hkh Node dks check djsaxs
dks delete djus ds fy, 3 conditions dks check djsaxs (1) ;fn List [kkyh gS
(1) List [kkyh gSA (2) ;fn List esa dsoy ,d Node gS rks head esa NULL Mky
(2) List esa dsoy ,d Node gSa rks ml Node dks feVkdj head nsaxs
esa NULL Mky nsaxs (3) ;fn List esa ,d ls T;knk Node gS rks Loop dh lgk;rk ls List
(3) List esa ,d ls T;knk Node gS rks Loop dh lgk;rk ls first Node ds vfUre Node ij igqapsxs ml Node dks feVkdj ml Node ds
ij igqapsxsa vkSj ml Node dks feVkdj head dks vxys node fiNys Node esa head dk address MkysaxsA blds fy, fuEu
ij ys tk;saxsA blds fy, fuEu Algorithm gSa%& Algorithm gSaA

Step 1: - ,d Temporary Pointer ysxsa ftlesa head dk address Step 1: - ,d Temporary Pointer ysxsa ftlesa head dk address
Mkysaxs Mkysaxs
struct node * temp = head struct node * temp = head
Step 2: - ;g check djsaxsa fd head NULL gS ;k ugh ;fn head Step 2: - ;g check djsaxsa fd head NULL gS ;k ugh ;fn head
NULL gS rks return gks tk;saxsA NULL gS rks return gks tk;saxsA
Step 3: - ;g check djsaxsa fd head dk Next head gS ;k ughA ;fn Step 3: - ;g check djsaxsa fd head ds Next esa head gS ;k
head dk Next head gS rks 4 ls 6 rd ds steps dks repeat ughA ;fn head dk Next head gS rks 4 ls 6 rd ds steps
djsaxsA dks repeat djsaxsA
Step 4: - Temp dks free dj nsaxsA Step 4: - head esa NULL MkysasxsA
head=NULL head=NULL
24 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Step 5: - temp dks free dj nsaxsA
free (temp)
Step 6: - return
Step 7: - tc rd temp ds Next part esa head dk adress ugha vk
tkrk rc rd temp dks vkxs c<+k,xsaA
while(temp->next != head)
temp=temp->next
Step 8: - temp ds next dks free dj nsaxsA
free (temp next)
Step 9: - temp ds next esa head MkysaxsA
temp next = head
Step 10: - Exit

Application of Link List

Linked List ,d Primitive data Structure gS ftls fofHkUu izdkj dh
Application esa Use esa fy;k tkrk gSA muesa ls dqN Applications
fuEu gSA
(1) fdlh vU; Data Structure dks Implement djus ds fy, tSls Stack
queue, tree rFkk graph
(2) Name dh Directory dks maintain djus ds fy,
(3) Logn Integers ij Arithmetic Operation Perform djus ds fy,
(4) Polynomials dks Manipulate djus ds fy,
(5) Sparts Matrix dks Represent djus ds fy,

25 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
UNIT-III Tree Terminology
TREES Leve of the Eement: - Tree esa lcls T;knk iz;ksx esa vkus okyh
Arrary,Linked list,stacks and queues vkfn dks Linear data structure ds term level gSA Tree ds first element dks root dgk tkrk gSA Tree ds
Onkjk iznf'kZr fd;k tkrk gSA bu structure ds Onkjk hierarchical Root dks ges'kk Level 1 esa j[kk tkrk gSA mijksDr Diagram esa
data dks iznf'kZr ugh fd;k tk ldrkA Hierarchical data esa ancestor- Jaspal Level1 esa iqbal,jaspreet,gurpreet and navtej Level 2 esa rFkk
descendant,superior-subordinate,whole part o data elements ds chp Noni, Aman and Manan Level 3 esa gSaA
similar relationship gksrh gSA
Jaspal Degree of Element: - fdlh Hkh Element dh Degree Number of Children
ij Depend djrh gSaA Leaf Node dh Degree ges'kk 0 gksrh gSa
Iqbal Jaspreet gurpreet Navtej
D;ksafd Leaf Node dk Left vkSj Right Part ugha gksrk gSaA
Degree of The Tree: - fdlh Hkh tree dh Degree Tree esa mifLFkr
Maximum Elements ij Depend djrh gSaA mijksDr diagram esa tree dh
Noni Manan Aman Degree 4 gSaA D;ksafd mlesa ,d Nodes ls vf/kd ls vf/kd 4
Elements tqM+s gSaA
Properties Of Tree : - Tree ds fuEu xq.k gSaA
(1) dksbZ Hkh Node Tree dh Root gks ldrh gSaA Tree esa
mijksDr figure esa jaspal ds descendents dks diagram es hierarchical tqM+h gj Node dk ,d xq.k gksrk gSa fd izR;sd Node dks
order esa iznf'kZr fd;k x;k gSA ftlesa jaspal top of the hierarchy dks fdlh nwljh Node ls tksM+us ds fy, dsoy ,d gh Path gksrk
iznf'kZr dj jgk gSA Jaspal ds children iqbal,jaspreet,gurpreet and navtej gSaA ,d Tree ftlesa fdlh Root dks Identify ugha fd;k x;k
gSA Iqbal ds ,d child Noni gS,gurpreet ds nks o jaspreet and navtej ds gSa og Free Tree dgykrk gSaA
,d Hkh ugh gSA bl izdkj ;g dgk tk ldrk gS fd Iqbal ds siblings (2) ftl Tree esa n No. of Nodes gSa mlesa n-1 Edges gksaxsA
Noni, Jaspal ds descendents iqbal,jaspreet,gurpreet and navtej gS rFkk (3) os Nodes ftudk dksbZ Child Node ugha gksrk leaves ;k
Noni ds ancestors Manan and Aman gSA terminal node dgykrk gSaA
The tree is an ideal data structure for representing the hierarchical data. As (4) os Node ftuds ikl de ls de ,d Child gksrk gSa Nonterminal
there are many Nodes dgykrs gSaA
types of trees in the forest,likewise there are many types of trees in data (5) Nonterminals Node dks Internal Node rFkk Terminal Node dks
structure-tree,binary tree,expression tree,tournament tree,binary search External Node dgrs gSaA
tree,threaded tree,AVL tree and B-tree. (6) ,d Level ij mifLFkr lHkh Nodes ds fy, Depth vkSj Height dk
eku ogh gksrk gSa tks mlds Level dk eku gksrk gSaA
Tree ,d ideal data structure gS ftlds }kjk hierarchical data dks iznf'kZr
(7) ,d Node dh Depth dks Node dk Level Hkh dgk tkrk gSaA
fd;k tkrk gSA tSlk fd ge tkurs gSa fd forest esa cgqr ls tree
Tree ds ,d laxzg dks Forest dgrs gSaA uhps fn;s A x, tree ds
gksrs gSaA mlh izdkj data structure esa Hkh db izdkj ds tree
root vkSj edges tks fd mls tree ls tksM+ jgsa gSa dks gVk
gksrs gSa tSls :- B vU; 3 C D
fn;k tk, rks gekjs ikl forest cpsxk ftlesa Trees gksaxs
Tree, binary tree, expression tree, tournament tree, binary search tree,
threaded tree, AVL tree and B-tree. E F G
I 26 B.M.COLLEGE
J BALOTRA
H

K L M
 3BCA3 - Data Structure
Properties of Tree
Binary Tree ds fuEufyf[kr Properties gSa &
(1) ,d Binary Tree ftlesa n vkUrfjd Nodes Internatl Nodes gSaa]
mlesa vf/kdre~ n+1 External Nodes gks ldrh gSaA ;gka ij
Root Node dks Hkh Internal Node ds :i esa fxuk x;k gSaA
(2) ,d Binary Tree ftlesa n Internal Nodes gSa] ds External Path dh
yEckbZ] Internal Path dh yEckbZ dh nks xuqh gksrh gSaA
(3) ,d Binary Tree ftlesa n Internal Nodes gSa dh mapkbZ height
A B E yxHkx log2n gksrh gSaA
izR;sd Binary Tree ,d Tree gksrk gS ijUrq izR;sd Tree ,d Binary Tree
C D F G H I ugha gksrkA
,d iw.kZ Binary Tree (Full vFkok Complete Binary Tree) dh leLr
J K L M Internal Nodes dh Degree gksrh gSa vkSj leLr Leaves ,d gh Level ij
gksrh gSaA
Binary Trees dks 3 Parts esa ckaVk x;k gSaA
Forest (1) Strictly Bianry Tree
(2) Complete Binary Tree
Binary Tree (3) Full Binary Tree
,slk Tree ftldh izR;sd Node ds ikl vf/kdre nks Child Nodes gks ldrh (1) Strictly Binary Tree: - og Tree ftlesa de ls de 0 ;k 2 Nodes dk
gSa] Binary Tree dgykrk gSaA bls ge bl izdkj Hkh dg ldrs gSa gksuk vko';d gSa vFkkZr~ ,d Tree esa ,d Node ls ;k rks
fd Binary Tree esa fdlh Node ds il ds nks vf/kd Child Nodes ugha Left vkSj Right nksuks Values dks Insert fd;k tk;sxk ;k ,d
gks ldrh gSaA Hkh ughaA
A
A
B C
B C
D E

D E C (2) Complete Binary Tree: - og Tree ftldk Level Same gks All most
Complete Binary Tree dgykrk gSaA tSls %&
G A
Binary Tree
B C
Binary Tree lkekU; Tree ds ,d fo'ks"k Class esa vkrs gSaA
D E F

27 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(4) Full Binary Tree: - og Tree tks Strictly Binary o Complete
binary nksuks gks Full Binary Tree dgykrk gSaA ;g
Triangle Property dks iznf'kZr djrk gSaA
(5)
A
B C
D E F G
Tree Representation as Array
Array ds }kjk Binary Tree dks iznf'kZr djus ds fy, Tree ds Nodes
dh Numbering djuh gksrh gSaA fdlh Hkh Tree ds Nodes dh
Numbering djus ds fy, ge Binary Tree dks Full Binary Tree ekudj gj
Node dks ,d Number ns nsrs gSa vkSj ftl Number ij og Node gksrk
gSa mls Array esa Store dj nsrs gSaA
bldk Example fuEu gSaA Linked List Representation of a Binary Tree
1 2 3 4 5 6 7 8 9 10 11 12
A B C D E F G Basic Operations on Binary Tree
Array Representation of a Binary Tree Binary Search Tree ,d fo'ks"k izdkj dk Binary Tree gS tks ;k rks
[kkyh gS ;k Left Sub Tree dh lkjh Information Root ls NksVh gS
1 A vkSj Right Sub Tree dh lkjh Information Root ls cM+h gSa Left vkSj
Right nksuksa gh Sub Trees Binary Search Tree gSaA
2 B 3 C Binary Search Tree esa fuEu Operations dks Perform djuk gksrk
4 D 5 E 6 F gSaA
11 (1) Insertion
7 8 9 10 G 12 (2) Delition
(3) Traversal
Link List }kjk tc Tree Representation fd;k tkrk gSa rks Node ds rhu
Link List Representation of Binary Tree: - fdlh Hkh Tree dks Linked Hkkx gksrs gSaa
A
List }kjk lgh ls iznf'kZr fd;k tk ldrk gSaA ge tkurs gSa fd ,d (1) Left (2) Info (3) Right
Binary Tree esa vf/kdre nks Child Node gh gksrs gSaA vr% bl blds fy, fuEu Strcutre dks cuk;k tk,xk
izdkj ds Representation esa node Value ds nksuks vksj ,d&,d struct node
B gSaA ftlls mldh Child NodesCdks iznf'kZr fd;k
Pointer Maintain djrs {
tkrk gSaA Tree dk og Hkkx ftlesa fdlh lwpuk dks Store ugha struct node * left;
fd;k tkrk D
mUgsa NULL ds E }kjk lqjf{kr j[kk
F tkrk gSaA int info;
struct node * right;
G 28 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
}; return
Step 8: - check whether (data < prev info)
Binary Search Tree esa Node dks tksM+uk% & blds fy, lcls if yes then
igys ,d Temprarory Variable T dks Root ij vkSj ,d Variable Prev dks prev left = n
NULL ij Hkst nsrs gSaA Prev Variable T ls igys okyh Node dks else
iznf'kZr djsxk vc ,d u;s Node dks Memory Allocate djsaxs mlds prev right = n
Information Part esa Data rFkk left vkSj Right esa NULL Value Insert Step 9: - Exit
djsaxs blds ckn Loop ds }kjk Prev dks T ij Hkstk tk,xk vkSj ;g
Check fd;k tk,xk fd D;k Data dh Value T dh Value ls NksVh gSaA fuEu Numbers dks ;fn Binary Tree esa Insert djuk gks rks mlds fy,
;fn Data dh Value T ls NksVh gS rks mls T ds Left esa Insert dj fuEu Steps follow djsaxs
fn;k tk,xk ;fn Data dh Value T ls cM+h gS rks mls T ds Right esa 12, 15, 18 10, 11, 14, 22
Insert fd;k tk,xkA vc ;g Check djsaxs fd Previous Variable tks fd T (1) lcls igys 12 dks add djuk gS pqafd vHkh rd dksbZ Node
ds ihNyh Node dks iznf'kZr dj jgk gSa NULL rks ugha gSaA ;fn Add ugha gqbZ gS] blhfy, ;g lk/kkj.k :i ls Add gks tk,xhA
NULL gS vr% Tree [kkyh gSa rks u;s Node dks Root cuk nsaxsA 12
(2) blds ckn 15 dks Add djkuk gSA pwafd 15, 12 ls cM+k gS
Step 1: - ,d Temporary Pointer ysxsa ftlesa root dk address blhfy, 15, 12 ds nkbZa vksj Add gksxkA
12
Mkysaxs
struct node * t = root 15
Step 2: - struct node * prev = NULL
Step 3: - struct node * n = malloc (sizeof (struct node)) (3) 18 dks Add djrs gq, geus ik;k fd 18, 12 ls cM+k gS ijUrq
Step 4: - n info = data pwafd 12 ds nkbZa vksj 15 igys ls gh gS blhfy, ge bldh
n left = NULL 15 ls Hkh rqyuk djsaxsA rqyuk djus ij geus ik;k fd 18, 15
n right = NULL ls Hkh cM+k gSA blhfy, 18, 12 ds Hkh nkbZa vksj Add
Step 5: - while (t != NULL and data != t info) gksxkA
set prev = t 12
check whether (data < t info)
if yes then 15
t = t left
else 18
t = t right
Step 6: - check whether (data = t info) (4) 10 dks Add djrs gq, geus ik;k fd 10, 12 ls NksVk gS] blhfy,
if yes then return 10, 12 ds ckbZa vksj Add gksxkA
Step 7: - check whether (prev = NULL) (5)
12
if yes then
root = n
10 15
29 B.M.COLLEGE BALOTRA

18
 3BCA3 - Data Structure
igys ls 15 ljqf{kr gS] blfy;s geus bldh rqyuk 15 ls dh
vkSj ik;k 22, 15 ls Hkh cM+k gSA blfy;s 22, 15 ds Hkh
nkbZa vksj tk,xk] ijUrq 15 ds nkbZa vksj 18 lqjf{kr gS]
vr% 22 dh rqyuk 18 ls Hkh dh vkSj ik;k fd 2, 18 ls Hkh
cM+k gS] blfy;s 22, 18 ds nkbZa vksj Add gksxkA vr% ge
dg ldrs gSa fd 22, 15 ds nkbZa vksj lqjf{kr 18 ds nkbZa
(6) 11 dks Add djrs gq, geus ik;k fd 11, 12 ls rks NksVk gS] vksj Add gksxkA
blhfy, 12 ds ckbZa vksj Add gksxk ijUrq 12 ds ckbZa vksj
igys ls lqjf{kr lwpuk 10 ls cM+k gS] blhfy, 11, 12 ds
ckbZa vksj ijUrq 10 ds nkbZa vksj Add gksxkA

12
Delete a Node from Binary Tree
10 15 (1) 15 dks Delete djrs gq, geus ik;k fd 15 ds left vkSj right child
nksuksa Hkjs gq, gSa] blfy;s geus viuh Algorithm ds
vuqlkj bldk Inorder (14, 15, 18) fudkyk vkSj ik;k fd 18 bldk
11 18 Inorder sucessor gSa blfy;s 15 dks delete djds 18 dks Promote
dj fn;kA vr% vc Tree fuEukuqlkj jg tkrk gS &
(7) 14 dks Add djrs gq, geus ik;k fd 14, 12 ls cM+k gS
bfly;s ;g 12 ds nkbZa vksj Add gksxkA ijUrq ;gka ij igys 12
ls gh 18 lqjf{kr gSA blfy;s geus 14 dh rqyuk 15 ls dh vkSj
ik;k fd 14, 15 ls NksVk gS blhfy;s 14, 12 ds nkbZa vksj 10 18
ijUrq 15 ds ckbZa vksj Add gksxkA
11 14 22
12 (2) 10 dks Delete djrs gq, geus ik;k fd 10 dk dsoy right child gh
gS] blfy;s geus blds child dks promote djds 10 dks delete dj
10 15 fn;kA vr% vc tree fuEukuqlkj jg tkrk gS &
12
11 14 18
11 18
(8) vc gesa vfUre lwpuk vFkkZr~ 22 dks Add djuk gSA 22 Traversal of Binary Tree
dks Add djrs gq, geus ns[kk 14 gSaA
Binary Tree dks Traverse djuk lcls Important Operation 22 Binary
12 fd 22, 12 ls cM_k gS] blfy;s
22, 12 ds nkbZa vksj Add gksxkA ijUrq 12 ds nkbZa vksj Tree ij cgqr lkjs Operations Perform fd;s tkrs gSaA Traversing djuk
10 15
30 B.M.COLLEGE BALOTRA
11 14 18

22
 3BCA3 - Data Structure
tree ds gj Node ij gksrk gSaA Traversing ,d Process gSaA ftlesa In Order Traversal of Tree: - (Left, Root, Right)
Tree ds gj Nodes ls xqtjuk gksrk gSaA fdlh Hkh Tree dks Traverse lcls igys Root Node A ij tk,saxsA vc ns[ksaxs fd root dk Left Full
djus ds fy, lcls igys mlds root dks check fd;k tkrk gSaA blds ckn gS vr% A ds Left esa B gSaA vc B ds Left dks Check djsaxs B dk
left Sub Tree dks Traverse djrs gSa rFkk vUr esa Right sub tree dks Left Hkh Full gSaA blds Left esa D gSaA ij D dk Left [kkyh gSa
traverse djrs gSaA Normally Binary Tree ds Traversal 3 izdkj ds vr% ;gka ls Left Root vkSj Right dks Traverse djsaxsA D dk Left
gksrs gSaA [kkyh gSa vr% D vkSj G (Root, Right) dks Traverse djsaxsA D
(1) In order Traversal: - (Left, Root, Right) (1) bl Tree dk In order Traversal D vkSj G gksxkA
(i) lcls igys Left Sub Tree dks Traverse djksA (2) D [qkn B dk Left gSa vr% vc Root dks
G
(ii) Root dks Traverse djksA fy[ksaxs DGB
(iii) Last esa Right Sub Tree dks Traverse djksA (3) B dk Right E gSa rFkk E dk Left H gSa vr% EH
okys Tree ds vUrZxr Traversal HE gksx vr%
(2) Pre Order Traversal: - (Root, Left, Right) Tree
(i) Root dks Traverse djksA D G B H E
(ii) Left Sub Tree dks Traverse djksA (4) Left sub Tree complete gks pqdk gSa vc root
(iii) Last esa Right Sub Tree dks Traverse djksA dks fy[ksaxs
D G B H E A
(3) Post Order Traversal: - (Left, Right, Root) (5) vc Right Sub Tree dks Access djsaxsA F dk Left
(i) Left Sub Tree dks Traverse djksA NULL gS rFkk Right esa I gSaA L, Root, R ds
(ii) Right Sub Tree dks Traverse djksA vk/kkj ij Traversal FI gksxhA
(iii) Root dks Traverse djksA D G B H E A F I
(6) F dk root C esa vkSj C dk Right NULL gSaA vr
% Traversal
A D G B H E A F I
C
B C
Pre Order Traversal: - (Root, Left, Right)
F lcls igys Root Node A ij tk,saxsA vc ns[ksaxs fd root dk Left Full
D E gS vr% A ds Left esa B gSaA vc B ds Left dks Check djsaxs B dk
Left Hkh Full gSaA blds Left esa D gSaA ij D dk Left [kkyh gSa
G H I vr% ;gka ls Root, Left vkSj Right dks Traverse djsaxsA
(1) lcls igys root dks nsaxs Tree dk Root A gSa vr% Tree
mijksDr Tree esa ;fn rhuksa izdkj dj Traversal djuk gks rks blds Traversal esa First Element A gSA
fy, Tree dks Root ls Access fd;k tk,xkA A
(2) A ds Left Sub Tree dks Check djsaxs A ds Left esa B vr%
Tree Traversal
31 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
A B G D H E B F I C
(3) B dk Left D gS vkSj G dk Root D gS vr% Tree Traversal
A B D Threaded Binary Tree
(4) D dk left NULL gS vkSj Right esa G gS vr% root Left Right tc fdlh binary tree dks link list ds :i esa iznf'kZr fd;s tkrs gSa rks
ds vk/kkj ij Tree Traversal Normally vk/ks ls T;knk Pointer Field NULL gksrs gSaA og Space
A B D G ftls NULL Entry }kjk Occupy fd;k tkrk gSaA blesa Valuable
(5) B ds right esa E gS vkSj E H dk Root gS vr% Root left right Information dks Hkh Store dj ldrs gSaA blds fy, ,d Special Pointer
ds vk/kkj ij Tree Traversal dks Store fd;k tkrk gSa tks vius Higher Nodes dks Point djrk gSaA
A B D G E H bu Special Pointer dks Threades dgrs gSaA rFkk ,slk Tree ftlesa bl
(6) vc Right Sub Tree dks Traverse djsaxs A dk Right C gS vr% izdkj ds Pointers dks j[kk tkrk gSa Threaded Binary Tree dgykrs
Tree Traversal gSaA
A B D G E H C Threads Normal Pointer ls vyx gksrs gSaA Threaded Binary Tree esa
(7) C ds Left esa F gS rFkk F I dk Root gS vr% Tree Traversal Threades dks dotted line ds }kjk iznf'kZr fd;k tkrk gSa blds fy, ,d
A B D G E H C F I Extra Field dks Memory esa Store djrs gSa ftls Tag ;k Flag dgk tkrk
gSaA Threaded Binary Tree dks iznf'kZr djus ds cgqr ls rjhds
Post Order Traversal: - (Left, Right vkSj Root) gSaA
lcls igys Root Node A ij tk,saxsA vc ns[ksaxs fd root dk Left Full (1) Tree ds Right NULL Pointer ds gj Node dks Successor ls
gS vr% A ds Left esa B gSaA vc B ds Left dks Check djsaxs B dk Replace djok;k tk,xkA ;g In Order Traversal ds vUrxZr vkrk
Left Hkh Full gSaA blds Left esa D gSaA ij D dk Left [kkyh gSa gSaA blfy, bl Thread dks Right Thread dgk tkrk gSa vkSj bl
vr% ;gka ls Left, Right, Root dks Traverse djsaxsA izdkj dk Tree Right Threaded Binary Tree dgykrs gSaA
(1) A dk Left B gS B dk Left D gS vkSj D dk Left NULL gS ij D (2) Tree ds Left NULL Pointer ds gj Node dks Predecessor ls
dk Right G gS vr% Left Right Root ds vk/kkj ij Traversal Replace djok;k tk,xkA ;g In Order Traversal ds vUrxZr vkrk
G D gSaA blfy, bl Thread dks Left Thread dgk tkrk gSa vkSj bl
(2) B dk Left Sub Tree Complete gS vkSj B ds right sub tree ij izdkj dk Tree Left Threaded Binary Tree dgykrs gSaA
t,saxsA B ds right ij E gS vkSj E ds Left esa H vr% Traversal (3) tc Left vkSj Right nksuksa Pointers dks Predecessor vkSj
G D H E B Successor ls Point djok;k tkrk gSa rks bl izdkj ds Tree dks
(3) A dk Left Sub Tree traverse gks pqdk gS vc A ds Right Sub Full Threaded Binary Tree dgykrs gSaA
Tree dks traverse djsaxsA
(4) A ds Right esa C gS C ds Left esa F gS rFkk F dk Right I gS Threaded Binary Tree nks izdkj ds gksrs gSa
vr% igys IF dks ysaxs vr% Tree Traversal
G D H E B F I (1) One-way Threaded Binary Tree
(5) C dk Left Sub Tree complete traverse gks pqdk gS vr% vc (2) Two-way Threaded Binary Tree
Right Sub Tree NULL gSA vr% Tree Traversal
G D H E B F I C One-way Threading esa dsoy ml Node ls tksM+ nsrs gSa tks
(6) lcls vUr esa Root Node dks fy[kk tk,xkA traversal esa mlds ckn vkrh gSaA
32 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Two-way Threading esa Node dks mu nksuksa Node ls tksM+ nsr
gSa tks Traversal esa mlds nksuks vksj gSaA
A
B C
Full Threaded Binary Tree (Two-Way Threading)
B Tree
X F G X D X E F ;g ,d fo'ks"k izdkj dk tree gS ftlds root esa ge ,d ls vf/kd Node
j[kdj mlesa ls ,d ls vf/kd Branches fudky ldrs gSaA bl izdkj ds
tree dks M-Way tree Hkh dgk tkrk gSa ;gka ,d Balanced M-way tree
dks B Tree dgrs gSaA bl Tree ds Node ,d ls vf/kd ;k cgqr lkjs
X H
Records vkSj childrens ds Pointers dks j[k ldrs gSaA B Tree dks
Right Threaded Binary Tree (One-Way Threading) Balanced Sort Tee Hkh dgk tkrk gSaA ;g Binary Tree ugha gksrk
gSaA ,d B Tree ds fuEu xq.k gSa %&
A (1) izR;sd Node vf/kd ls vf/kd N Childrens j[k ldrh gSa o de ls
de N/2 ;k fdlh vU; la[;kvksa ds Children tks 2 vkSj n ds
chp dgha ij gSA
(2) gj Node esa children ls 1 de dh vk ldrh gSaA
B C (3) Node esa Keys dks ifjHkkf"kr Øe esa O;ofLFkr fd;k tkrk
gSaA
(4) Left Sub Tree dh lHkh Keys, Key dh Predecessor gksrh gSaA
X F G D E X (5) Right Sub Tree dh lHkh Keys, Key dh Successor gksrh gSaA
(6) tc ,d iwjs Hkjs gq, Node esa dksbZ Key tksM+h tkrh gSa
rks Key nks Nodes esa VwV tkrh gSa vkSj og Key tks chp
Left Threaded Binary Tree (One-Way Threading) esa gksxh mls Parent Node esa j[kk tk,xk rFkk NksVh
H Value okyh Key Parent ds Left esa rFkk cM+h Value okyh
A
Key Parent ds Right esa jgsxhA
(7) lHkh Leaves ,d gh Level ij gksrh gSa vr% V ds Level ds mij
dksbZ Hkh [kkyh Sub Tree ugha gksxkA
B C
B Tree esa tksM+uk %&
B-Tree esa fdlh Hkh Key dks tksM+us ls igys ;g ns[kk tkrk gSa
X F G D E X fd og Key dgka tksM+h tkuh gSA ;fn Key igys ls fufeZr Node
esa tk ldrh gS] rks Key dks tksM+uk vklku gS] og Node dks
nks Hkkxksa (Nodes) esa ckaV nsrh gSaA og Key ftldk eku
33 B.M.COLLEGE BALOTRA
H
 3BCA3 - Data Structure
ek/;eku (chp dk) gksrk gS] og Node esa jgrk gS vkSj blds ck,a
child esa bl Key ds nk,a fLFkr leLr Keys vk tkrh gSaA B-Tree esa vc gesa 60 dks tksM+uk gSA tSlk fd ge ns[k ldrs gSa 60, 50 ds
Insertion (tksM+uk) fuEufyf[kr mnkgj.k ls foLrkj ls le>k;k tk jgk ckn tqM+sxk vkSj 50 okyh Node iw.kZr;k Hkj pqdh gSaA
gS & blhfy;s 60 ds tqM+us ij ;g Node nks Hkkxksa esa foHkDr gks
ekuk gesa fuEufyf[kr Keys dk 4 Order dk Tree cukuk gS & tk,xh vkSj ;g Node mu nksuksa dk Parent Node dk eku root node
33
44 33 30 48 50 20 22 60 55 esa merge gks tk,xk &
77 20 22 30 48
lcls igyh key 44 gS ftls gesa tree esa tksM+uk gSA pwafd ;g
igyh key gS blfy, bl Key ds }kjk gh Root Node dk fuekZ.k gksxk
& 40 50 60

44
blh izdkj ge 33 vkSj 30 dks Hkh muds LFkku ds vuq:i Node esa 33 48
tksM+ nsaxs & 50 60
44 33 44 20 22 30

pw¡fd geus ;g 4 order dk tree cuk;k gS blhfy, bldh ,d Node esa 40

vf/kdre~ 3 Keys gh j[k ldrs gSaA vr% vc tks Hkh key blesa
tksM+h tk;sxh og bl (root) Node dks nks Hkkxksa esa foHkDr
dj nsxhA ;gka gesa 48 tksM+uk gS& 44 33 44 48

33 vc gesa 55 dks blds LFkku ds vuq:i tksM+ nsaxs &

30 30 48 33 48

20 22 30 50 55 60 77
33
vc ge 50 dks blds LFkku ds vuq:i tksM+ nsaxs &
33 20 22 30 40 55

30 30 48 50 vc gesa 77 dks tksM+uk gSaA tSlk fd ge ns[k ldrs gSa fd 77,

40
60 ds ckn tqM+sxk] vr% ;gka ij Hkh Node50foHkDr
60 gksxh
77 vkSj
vc ge 20 vkSj 22 dks blds LFkku ds vuq:i tksM+ nsaxs & pwafd vHkh Hkh Root Node esa LFkku fjDr gS blfy, bl Node dk
33 eku Root esa pyk tk,xk &

20 22 30 44 48 50 60
33 48 55
34 B.M.COLLEGE BALOTRA
20 22 30 60 77

40 50
 3BCA3 - Data Structure
yxsaxhA vr% ;g ns[kk tk, rks izR;sd izdkj ds deletion esa
terminal node esa ls ,d key vo'; feVsxhA
;fn ge 'H' dks Delete djrs gSa rks cgqr vklku gS vFkkZr+ dsoy
'H' dks Node esa ls Delete dj nsaxsR &

E G J W
vc ;g Tree Belanced gS] vkSj bl izdkj cuk;k x;k gS fd bldh leLr
Leaves ,d gh Level ij gSaA
B C D I K P X Y Z
B – tree esa ls feVkuk
tSlk fd ge tksM+us esa igys key rFkk mldk LFkku ns[krs gSa F V
mlh izdkj feVkus esa Hkh igys Key rFkk mlds LFkku dks
<wa<rs gSaA
;fn feVkbZ tkus oykh key ,d terminal (leaf) gS] tks feVkuk ljy gS] ;fn ge 'J' dks feVkrs gSa rks gesa blds sucessor, K dks blds
vFkkZr+ dsoy ml key dks Node esa ls feVk nsuk gksxkA LFkku ij dkWih djuk gksxk &
;fn feVkbZ tkus okyh key ,d terminal (leaf) ugha gS rk] bls blds
R
successor ds eku ls cny fn;k tkrk gSaA bl izdkj ;fn successor,
terminal Node esa gSa] rks ogka ls og feVk fn;k tk,xkA
R
E G K W

E G J W B C D I P X Y Z

F V
B C D H I K P X Y Z

F V ;fn ge 'F' dks feVkrs gSa] rks ;gka underflow dh fLFkfr mRiUu
gks tk,xhA ns[kk tk, rks ;gka F ds [kRe gksrs gh G dk ,d child
R
[kRe gks tk;sxkA vr% G dks remove djds E ds child node esa
bl izdkj ;fn sucessor, non-terminal node esa gS] rks mldk sucessor, Hkst fn;k tk,xk] rks blesa fuEu fLFkfr mRiUu gks tk,xh &
replace gksxk vkSj ;gh lkjh 'krsZ bl sucessor ds lkFk Hkh
E K W
G 35 B.M.COLLEGE BALOTRA
B C D I P X Y Z
F V
 3BCA3 - Data Structure
;fn fdlh Binary Tree dh izR;sd Node ds fy, Left Sub – Tree dh height
vkSj Right Sub-Tree dh height eas ;fn dsoy ,d dk vUrj gh gS]
rks ,slk Binary Tree Height Balanced Tree dgykrk gSaA
,d yxHkx Height Balance Tree dks AVL Tree dgk tkrk gSaA

Height Balance Tree dk fuekZ.k

Height Balance Tree ds fy, izR;sd Node dk ;g xq.k gksrk gSa fd
blds Left Sub-Tree dh Height Right Sub-Tree dh Height ls ;k rks 1
T;knk ;k cjkcj ;k fQj 1 de gksrh gSaA bls Balancing Factor (bf)
Hkh dg ldrs gSaA
R
;fn nksuksa Sub – Trees cjkcj gS rks] bf=0
;fn Right Sub-Tree dh height cM+h gS] rks bf = -1 (H
(left)<H(Right))
E K W ;fn Left Sub-Tree dh Height cM+h gS rks vf = +1
(H(left)>H(Right))
vFkkZr~ bf = left height – right height
B C D G I P X Y Z tc Balancing Factor – 2 gksrk gS rks ge tree dks okekorZ
(Anti-Clockwise) ?kqek nsrs gSa vkSj tc Balancing Factor+2 gksrk
F V gSa rks ge tree dks nf{k.kkorZ (Clockwise) ?kqek nsrs gSaA

bl izdkj fn, x, Øe dk B-Tree cuk;k tk ldrk gS vkSj fdlh B-Tree esa mnkgj.k & 3 5 11 8 4 1 12 7
ls fdlh okafNr key dks feVk;k Hkh tk ldrk gSaA 2 6 10
dks gesa height balanced tree cukuk gSaA
AVL Tree (Height Balanced Tree)
,d Binary Tree, ftldh height, h gS] iw.kZ :i ls lUrqfyr (balanced) rHkh ge bl fØ;k dks 0
gksrk gS ;fn mldh leLr leaves ;k rks level ;k fQj h-1 level ij gSa root vFkkZr~ 3
vkSj ;fn h-1 level ls de level ij fLFkr leLr Nodes ds nks children List dh igyh
gSaA lwpuk ls
ge ;g Hkh dg ldrs gSa fd ;fn fdlh Binary Tree dh izR;sd Node dh izkjEHk djrs
left ls lcls yEcs Path dh Length, right esa lcls yEcs Path dh length ds gSa &
yxHkx cjkcj gksrh gS] rks og Binary Tree ,d Balanced Tree dgykrk
gSaA -1
vc Tree esa 3
tksM+us ds fy,
0
36 B.M.COLLEGE BALOTRA
5
 3BCA3 - Data Structure
5 gSA ;g igys
tree ds right esa vc gekjs ikl
tk,xk & tksM+us ds fy,
8 gS] ;g 11 ds
left esa tk,xk &

ifj.kkeLo:i izkIr -2
3
tree vHkh Hkh
balanced gSA
-1
D;ksafd bf = -1
gSA vc gkejs ikl 5
tree esa 0
tksM+us ds fy,
11
11 gSA ;g 5 ds ifj.keLo:i izkIr 0
Right esa tk,xk& 5
tree vHkh Hkh
balanced gSA vc
+1
gesa 4 dks -1
tksM+uk gS ;g 3 11
3 ds right esa
0 tk,xk &
5 0 0
pw¡fd bf dk eku 4 8
–2 gks x;k gS] 0
blfy, ge Tree dks 0
3 11
Anti-clockwise ?
kqek nsaxs &

-1
5 0
5
ifj.kkeLo;i izkIr
0 +1 tree vHkh Hkh
+1
3 11 balanced gSA vc 0
3 11
37 B.M.COLLEGE BALOTRA

0 0 0 0
8 1 4 8
 3BCA3 - Data Structure
gesa 1 tksM+uk tksM+uk
gSA ;g 3 ds left gSA ;g 8 ds left
esa tk,xk & esa tk,xk &

0
5
ifj.kkeLo:i izkIr
tree vHkh Hkh 0
0
balanced gSA vc 3 11 0
gesa 12 dks 5
tksM+uk
gSA ;g 11 ds 0 0 0 0 +1
+1
1 4 8 12 ifj.kkeLo:i izkIr 3 11
right esa tk,xk &
tree vHkh Hkh
balanced gSA vc
gesa 2 dks -1 0 +1 0
1 4 8 12
tksM+uk -1
gSA ;g 1 ds right 5
esa tk,xk & 0 0
-1 2 7 +2
1
5 3 11

+1
ifj.kkeLo:i izkIr 0 -1 0 +2 0
3 11 1 4 8 12
tree vHkh Hkh
balanced gSA vc
gesa 7 dks 0 0 +1 0 0 +1
1 4 8 12 2 7
38 B.M.COLLEGE BALOTRA

0 0
7 6
 3BCA3 - Data Structure

ifj.kkeLo:i izkIr
tree vHkh Hkh
balanced gSA vc
gesa 6 dks
tksM+uk
gSA ;g 7 ds Left 0
esa tk,xk & 5

2
+1
3 11
ifj.kkeLo:i izkIr
tree vc balanced
gSA vc gesa 10 -1 0 -1 0
dks tksM+uk 1 4 7 12
gSA ;g 8 ds right
esa tk,xk & 0 0 -1
2 6 8

0
10
0
5

+1 0
+1
3 11 5
pw¡fd bf dk eku
2 gks x;k gS 0
0 +1
blfy;s ge tree -1 0 0 3 8
dks clockwise ? 1 4 7 12
kqek nsaxs &
0 0 -1 0 +1 0
0 6 8 1 4 7 11
2
39 B.M.COLLEGE BALOTRA

0 0 0 0
2 6 10 12
 3BCA3 - Data Structure
pw¡fd bf dk eku
2 gks x;k gS
blhfy, gesa tree
dks clock wise ?
kqekuk
gksxkA ;fn ge 7
dks Promote djrs
gSa] rks 7 ds
right okyk sub Insert into B+ Tree: - B Tree dh rjg gh B+ Tree eas Hkh ubZ Value
tree dkQh yEck dks Insert fd;k tkrk gSa tc Leaf Node dks 2 Nodes esa Split dj nsrs
gks tk,xk vkSj gSaA
gesa vusd ckj Delition from B+ Tree: - B+ Tree ds vUrZxr fdlh Hkh Key dks Delete
balancing djuh djuk B Tree ls vklku gSA tc fdlh Hkh Key Value dks Leaf ls Delete
iM+sxhA blhfy, fd;k tkrk gSa rks Index Set esa ls fdlh Key dks Delete djus dh
ge 8 dks promote vko';drk ugha gksrh gSaA
djsaxs &
B* Tree :– bl Data Structure dks Knuth }kjk cuk;k x;k Fkk bldks
cukus dk eq[; mn~ns'; Insertion vkSj Deletion esa gksus okys
Overhead dks Reduce djuk gSA ,d vU; Primary mn~ns'; Search
Performance dks Improve djuk Hkh Fkk B* Tree ,d B Tree gS ftlesa
bl izdkj izkIr tree gh vHkh"V Height Balanced Tree gSA gj Node Half Full u gksdj 2/3 Full gksrk gSaA B* Tree ds }kjk Node
Splitting dks Reduce fd;k tkrk gSaA tc Node Full gks tkrs gSa rks
B+ Tree mUgsa Split djus ls igys Re-Distribution Scheme dks Use esa ysrs
B+ Tree Data Structure B Tree dk Extension gSA bls Index File gSaA Insertion rFkk Deletion Operation B Tree dh rjg gh gksrs gSaA
Organization dh Technique dks Implement djus ds fy, Use esa fy;k
tkrk gSA B+ Tree ds 2 Parts gksrs gSaA
(1) Index Set
(2) Sequence Set

B+ Tree ds vUrZxr Leaf Node dk69

Right Pointer Next Leaf Node dks
Point djrk gSaA Index Set
69 43 110 136

40 B.M.COLLEGE BALOTRA
18 20 30 43 50 55 100 110 125 136 140 145 Sequence
Set
 3BCA3 - Data Structure
UNIT – IV (2) Stability: - tc dksbZ Hkh izkjfEHkd List ftlesa Element
Sorting: - fn;s x;s elements dks Ascending (vkjksgh) ;k descending gksrs gSaA tks fd Sequence esa ugha gksrs gSa
(vojksgh) Order esa tekuk sortring dgykrk gSaA ds }kjk dksbZ Hkh Sorting dks Use esa fy;k tk ldrk
Searching: - fn;s x;s Item esa ls fdlh ,d Item dks Findout djuk gSaA
Searching dgkykrk gSaA (3) Storage Requirement: - dqN Sorting rjhds, Original Array
Sorting vkSj Searching lkekU;r% file ds records ij Perform dh tkrh ds }kjk Re – Arrangement of Element ij fuHkZj djrs gSaA
gSaA blyh, dqN Standard Terminology dks Use esa ysrs gSaA
Insertion Sort: - bl Sorting esa Set of Value ls ugha cfYd miyC/k
Sorting Sort file esa Elements dks Fill djrs gSaA tSls Array ftlesa N Element
Sotring ,d Important Operation gS vkSj Normally blds fy, cgqr lkjh A[1], A[2].... AN Memory esa gS rks blds fy, fuEu izdkj ds Steps
Applications dks Use eas fy;k tkrk gSaA Sorting izk;% ,d List Of dks Follow fd;k tk;sxkA
Elements ij Perform dh tkrh gSaA ,slh List dh Sorting dks Internal Pass1: A[1] igys ls Sorted gS
Sorting dgrs gSaa ftlesa List ds NksVs%NksVs Hkkxksa dks Sort Pass2 : A[2] dks A[1] ls igys ;k ckn esa Insert fd;k tk;sxk bl izdkj
fd;k tkrk gSaA Array dks Sort djsaxsA
List iw.kZ :i ls Computer dh Primary Memory esa jgrh gSaA Pass3 : A[3] dk A[1] o A[2] ls Comparision fd;k tk;sxk ;fn A[3], A[1]
blds foijhr tc Sorting dks Secondary Memory esa Perform fd;k tkrk o A[2] ls NksVk gS rks A[3] dks lcls igys Insert dj fn;k
gSa rks bl izdkj dh Sorting External Sorting dgrs gSaA tk;sxkA ;fn A[3], A[1] ls cM+k vkSj A[2] ls NksVk gks rks
A[3] dks A[1] vkSj A[2] ds chp esa Insert dj fn;k tk,xkA ;fn
Classification of Sorting Methods: - Sorting dk lcls Easy rjhdk lcls A[3], A[1] vkSj A[2] nksuksa ls cM+k gS rks mls nksuks
NksVh Key ds lkFk ,d Element dks pquuk gksrk gSaa pquk x;k ds ckn Insert dj fn;k tk;sxkA vr%
Element Array ls vyx gks tkrk gSaA vkSj cps gq, element esa ls Pass4 : bl izdkj ;g Øe fujUrj pyrk jgsxA
Again NksVs Element dks pquk tkrk gSaA bl rjhds dks Choosing Pass5 : bl izdkj Array ds Elements dks Proper Place ij Insert dj fn;k
Element With Sorting dgk tkrk gSaA bl rjg ge dbZ Sorting Family tk;sxkA
tSls Sorting With Merging, Sorting with insertion o Sorting with exchange
dks esa esa ysrs gSaA bu lHkh rjhdksa dks Comparative Sort Example: - Insertion Sort dks le>us ds fy, fuEu Method dks Use esa
dgk tkrk gSaA Sorting ,d Alternate Approach gSaA ftlesa Elements ysrs gSaA
dks Arrays esa Collect fd;k tkrk gSaA fuEu Array fn;k x;k gSaA
77 33 44 11 88 22 66 55
Advantages of Sorting: - bl Array dks sort djus ds fy, fuEu Steps dks Follow djsaxsA
(1) Data Sensitiveness: - dqN Sorting dh rjhdks esa Sequence
dk /;ku j[kk tkrk gSaA bl rjhds ds }kjk data dh
Sensitiveness dks iznf'kZr fd;k tkrk gSaA ogha nwljh 1. lcls igys Array esa 77 dks Store fd;k tk;sA
vksj tks Data Sensitive ugha gksrk gSaA og Working
77 33 44 11 88 22 66 55
Type dk dqN le; Waste dj nsrk gSaA

41 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
2. vc 33 dks Array esa Insert djsaxs vkSj Check djsaxs fd 33, 77 ls
NksVk gS ;k cM+k vkSj comparision ds ckn mls mlds lgh
LFkku ij Insert dj fn;k tk;sxkA

77 33 44 11 88 22 66 55 7. vc 66 dks Array esa Insert djsaxs vkSj Check djsaxs fd 66- 11,
22, 33, 44, 77 vkSj 88 ls NksVk gS ;k cM+k vkSj comparision ds
ckn mls mlds lgh LFkku ij Insert dj fn;k tk;sxkA 66 Array esa
33 77 44 11 88 22 66 55 Inserted Value 44 ls cM+k vkSj 77 ls NksVk gS vr% bls 44 vkSj
77 ds chp esa Insert dj fn;k tk;sxkA
3. vc 44 dks Array esa Insert djsaxs vkSj Check djsaxs fd 44, 33
vkSj 77 ls NksVk gS ;k cM+k vkSj comparision ds ckn mls 11 22 33 44 77 88 66 55
mlds lgh LFkku ij Insert dj fn;k tk;sxkA
11 22 33 44 66 77 88 55
33 77 44 11 88 22 66 55
8. vc 55 dks Array esa Insert djsaxs vkSj Check djsaxs fd 55- 11,
33 44 77 11 88 22 66 55 22, 33, 44, 66, 77 vkSj 88 ls NksVk gS ;k cM+k vkSj comparision
4. vc 11 dks Array esa Insert djsaxs vkSj Check djsaxs fd 11- 33, 77 ds ckn mls mlds lgh LFkku ij Insert dj fn;k tk;sxkA 55 Array
vkSj 44 ls NksVk gS ;k cM+k vkSj comparision ds ckn mls esa Inserted Value 44 ls cM+k vkSj 66 ls NksVk gS vr% bls 44
mlds lgh LFkku ij Insert dj fn;k tk;sxkA vkSj 66 ds chp esa Insert dj fn;k tk;sxkA

33 44 77 11 88 22 66 55 11 22 33 44 66 77 88 55

11 33 44 77 88 22 66 55 11 22 33 44 55 66 77 88
5. vc 88 dks Array esa Insert djsaxs vkSj Check djsaxs fd 88- 33,
77, 44 vkSj 11 ls NksVk gS ;k cM+k vkSj comparision ds ckn Algorithm of Insertion Sort
mls mlds lgh LFkku ij Insert dj fn;k tk;sxkA 88 Array esa Algorithm - 1. Set K = 1
Inserted lHkh elements ls cM+k gSA vr% bls Array ds Last esa 2. For k = 1 to (n-1)
11 33
Insert fd;k tk;sxkA 44 77 88 22 66 55
3. Set temp=a (k)
4. Set j = (k-1)
While temp<1 (j) and (j>=0) perform the
6. vc 22 dks Array esa Insert djsaxs vkSj Check djsaxs fd 22- 33, following steps; set a(j+1) =a (j)
77, 44, 11 vkSj 88 ls NksVk gS ;k cM+k vkSj comparision ds ckn [End of loop structure]
mls mlds lgh LFkku ij Insert dj fn;k tk;sxkA 22 Array esa Assign the value of temp to a (j+1)
Inserted Value 11 ls cM+k vkSj 33 ls NksVk gS vr% bls 11 vkSj [End of for loop structure]
33 ds chp esa Insert dj fn;k tk;sxkA 5. Exit
11 33 44 77 88 22 66 55 42 B.M.COLLEGE BALOTRA
11 22 33 44 77 88 66 55
 3BCA3 - Data Structure

Selection Sort: - ;s Technique Minimum Maximum Element ij fuHkZj

djrh gSaA blds fy, lcls igys Minimum Value dks Select fd;k
tk;sxkA vkSj mls Array dh First Position ij j[k fn;k tk;sxkA mlds
ckn 2nd Minimu Element dks find djsaxs vkSj mlls 2nd Position ls
Exchange dj fn;k tk,xk 3. vc a[1] ls a[7] rd esa ls Minimum Element dks Find Out
Pass1 : Find the location LOC of the smallest in the list of elements djsaxsA Minimum Element 22 gSa mls a[1] ls Replace dj fn;k
A[1], A[2],....,A[N], and then interchange A[LOC] and A[1]. Then: tk,xkA
Pass2 : Find the location LOC of the smallest in the sublist of N – 1
elements 11 33 44 77 88 22 66 55
A[2], A[3],..., A[N], and then interchange A[LOC] and A[2]. Then: a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
A[1], A[2] is sorted, since A[1] < A[2].
Pass3 : Find the location LOC of the smallest in the sublist of N – 2
elements
A[3], A[4],..., A[N], and then interchange A[LOC] and A[3]. Then: 11 22 44 77 88 33 66 55
A[1], A[2],...., A[3] is sorted, since A[2] < A[3]. a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
... ..............................................................................................................
............................ 4. vc a[2] ls a[7] rd ds Minimum Element dks Find Out djsaxs
... .............................................................................................................. Minimum Element 33 gSaA bls a[3] ls Replace dj fn;k tk;sxkA
............................
Pass N – 1 Find the location LOC of the smaller of the elements A[N-1], 11 22 44 77 88 33 66 55
A[N], and then interchange A[LOC] and A[N-1]. Then: a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
Thus A is sorted after N – 1 passes.
11 22 33 77 88 44 66 55
Example: - Selection Sort dks le>us ds fy, fuEu Method dks Use a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
esa ysrs gSaA
fuEu Array fn;k x;k gSaA
77 33 44 11 88 22 66 55 5. vc a[3] ls a[7] rd ds Minimum Element dks Find Out djsaxs
bl Array dks sort djus ds fy, fuEu Steps dks Follow djsaxsA Minimum Element 44 gSaA bls a[3] ls Replace dj fn;k tk;sxkA
1. lcls igys Array ds Minimum Element dks Findout djsaxsA 11 22 33 77 88 44 66 55
2. Array dk Minimum Element 11 gSaA bls Array ds 0 Index ls
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
Replace dj fn;k tk,xkA

77 33 44 11 88 22 66 55 11 22 33 44 88 77 66 55
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
43 B.M.COLLEGE BALOTRA
11 33 44 77 88 22 66 55
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
 3BCA3 - Data Structure
3. [Interchange a[k])and a(loc)]
6. vc a[4] ls a[7] rd ds Minimum Element dks Find Out djsaxs Set temp : a (k) a (k) : = a (loc) and a (loc) : = temp.
Minimum Element 55 gSaA bls a[4] ls Replace dj fn;k tk;sxkA [End of step 1 loop]
11 22 33 44 88 77 66 55 4. Exit.

a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]

11 22 33 44 55 77 66 88 Heap Sort
Heap ,d Binart Tree gS] ftldh Parent Node ges'kk Child Node ls
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
cM+h gksxhA Heap Sorting esa ,d nh gqbZ List dks Heap esa
7. vc a[5] ls a[7] rd ds Minimum Element dks Find Out djsaxs cnyrs gq, bl izdkj ls Arrange djrs gSa fd og List Lor% gh Sort gks
Minimum Element 66 gSaA bls a[5] ls Replace dj fn;k tk;sxkA
tk,A
11 22 33 44 55 77 66 88
Heap Sort dh rduhd esa ge Element dks ,d&,d djds tree esa Insert
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
dj nsrs gSa vkSj ;fn Insert fd;k x;k Element, Parent Node ls cM+k
11 22 33 44 55 66 77 88 gS rks ml Node dks Parent Node ds lkFk swap dj nsrs gSaA bl
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] fof/k dks vPNh rjg le>us ds fy, ge ,d mnkgj.kdh lgk;rk ysaxsA
uhps ,d Unsorted List ds Elements dks n'kkZ;k x;k gS &
8. vc a[6] ls a[7] rd ds Minimum Element dks Find Out djsaxs
Minimum Element 77 gSaA ;g viuh LFkku ij gh gSaA vr% 44 30 50 22 60 55 77
bls Sort djus dh vko';drk ugha gSaA Heap Sorting ds fy, tree cukrs gq, Node dks preorder ds :i esa Insert
11 22 33 44 55 66 77 88 djrs gSa vFkkZr~ igyh Node dks root ij] nwljh Node dks Left esa]
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] rhljh Node dks Right esa rFkk blh Øe esa vkxs rd Nodes dks Tree
esa Insert djrs gSaA
Step 1 - 44 dks ge Tree esa Insert djsaxs] pw¡fd Tree vHkh
Algorithm of Selection Sort: - ;g ,YxksfjFke vklkuh ls izkjEHk dh rd gh ugha cuk gS blhfy;s 44 gh parent Node cu
tk ldrh gSaA tk,xhA
tSls & 1. Repeat steps 2 and 3 for k=1, 2 ..................... n-1:
2. Call min(a,k,n,loc). 44
44 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
vr% vc List –44A

Step 2 - vc gesas 30 dks Heap Tree esa Insert djuk gS pw¡fd

ge ;g igys gh crk pqds gSa Heap Tree esa Insertion vr% vc List – 50, 30, 44 A
djrs gq, igys Root, fQj Left esa Node dks Insert djrs
gSaA blhfy;s ge 30, 44 ds Left esa MkysaxsA Step 4 - vc gesa izkIr Tree esa 22 dks Insert djuk gSA pwafd
Root (50) ds nksuksa vksj (left ,oa right esa) Data
44
Save gS blhfy, ge Root ds Left child dks ,d sub-tree dk
root ekudj blds Left esa 22 dks Insert djsaxsA

50
30

vr% vc List – 44, 30A

30 44
Step 3 - vc gesa 50 dks Heap Tree esa Insert djuk gS] Insertion
ds fu;e ds vuqlkj root vFkkZr~ 44 ds right esa Insert
djsaxsA
22

44

30 50 Step 5 - ;gka ij gesa 60 dks Insert djuk gS] pwafd ge ;gka

Root ds Left Tree esa Insertion dj jgs gSa blhfy, 60
dks 30 ds Right esa Save djsaxsA
;gk¡ ij geus ns[kk fd mijksDr Tree ds Child Node dk
eku Parent Node ds eku ls cM+k gS blhfy, ge bu 50
nksuksa dh Swapping dj nsaxsA

44 50 30 44

30 50 30 44 22 60
45 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
blhfy, vc ge Root ds Right sub-tree ds Left esa Node
dks Insert djsaxsA

;gka ij geus ns[kk child node dk eku parent Node ds

eku ls cM+k gks x;k gS blhfy, ge bu nksuksa dh
Swapping dj nsaxsA

50 50

30 44 30 44

;gka ij geus ns[kk child node dk eku Parent Node ds

eku ls cM+k gks x;k gS blhfy, ge bu nksuksa dh
22 60 22 30
Swapping dj nsaxsA
77 77
nksckjk geus ;gka ns[kk fd child node (60) dk eku
Parent Node (50) ls cM+k gS blhfy;s ge bu nksuksa
dh Swapping dj nsaxsA
50 44 50 55
50 60

22 30 55 22 30 44
60 44 50 44

vr% vc List – 60, 50, 55, 22, 30, 44A

Step 7 - vc gesa 77 dks Insert djuk gS] pwafd ge root ds right
22 30 22 30
sub-tree ds Left esa Insertion dj pqds gSa blhfy, vc
60 60
ge root ds Right sub-tree ds right esa Node dks Insert
vr% vc List – 60, 50, 44, 22, 30 A djsaxsA
Step 6 - vc gesa 55 dks Insert djuk gS] pwafd ge Root ds
Left sub-tree ds nksuksa vksj Insertion dk pqds gSa
50 44 50 55

46 B.M.COLLEGE BALOTRA

22 30 55 22 30 44 77
 3BCA3 - Data Structure

vr% vc List – 77, 50, 60, 22, 30, 44, 55A

vc] pwafd List dks Increasing/Accending Order esa sort djuk gS] vr
% gesa List ds igys Element (77) vkSj vfUre Element (55) dh
Swapping djuh gksxhA
vr% vc List – 55, 50, 60, 22, 30, 44, 77A
vc 77 Sort gks pqdk gS] List ds vU; element dks Sort djus ds fy,
List ds bl Sorted Element dks NksM+dj] vU; Unsorted Elements ij
;gka ij geus ns[kk child node dk eku Parent Node ds mijksDr izfØ;k iqu% nksgjkbZ tkrh gSaA
eku ls cM+k gks x;k gS blhfy, ge bu nksuksa dh Step 1- set in R, root, par, son, temp (R, root, par, son o temp dks
Swapping dj nsaxsA initialize djsaA)
60 60
Step 2- Reapeat for k = n, k<=1 (k dk eku n lqjf{kr djsa
vkSj step 3 ls ste 15 rd
nksgjk,a tc rd k dk eku 1
50 55 50 77 ds cjkcj ;k cM+k gksA)
Step 3- call wapt with &A[1], &A[k]
(A[1] o A[k] dks Swap djus ds fy, function dks dkWy
djsaA)
22 30 44 77 22 30 44 Step
55 4- set par = 1 (part dk eku 1 lqjf{kr
djsaA)
Step 5- set son = par x 2 (Son Variable esa par dk
nqxquk eku lqjf{kr djsaA)
nksckjk geus ;gka ns[kk fd Child Node (77) dk eku Step 6- set roo = A[1] (root variable esa A[1]
Parent Node (60) ls cM+k gS blhfy;s ge bu nksuksa vFkkZr~ array dk igyk
dh Swapping dj nsaxsA element lqjf{kr djsaA]
60 77
Step 7- check whether (son + 1) < l (tkaps fd D;k (son + 1) dk
eku K ls NksVk gSA)
if yes then (;fn gka rks
50 77 50 60 check whether A[son+1] > A[son] (tkaps fd D;k
A[son+1] dk eku A]son] ls
cM+k gSA)
if yes then
22 30 44 55 22 30 44 55 son++ (;fn gka rks son esa 1
Increment djsaA)
Step 8- Repeat while [son < = (k-1) and A[son] > root]
47 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(step 9 ls step 15 rd nksgjk,a tc rd son dk eku k-1 ls Bubbles Sort
NksVk ;k cjkcj gS vkSj A[son] dk eku root ls cM+ Algorithm – ekuk fd n Elements dk ,d Linear Array gS] temp Element
gSA dh Interchanging ds fy;s vLFkk;h Variable gS &
Step 9- set A[par] = A[son] (A[par] esa A[son] dk eku 1. Input n elements of an array a.
lqjf{kr djsaA) 2. Initialize i=0
Step 10- set par = son (par esa son dk eku lqjf{kr 3. Repeat through step 6 while (i<n)
djsaA) 4. Set i=0
Step 11- set son = par x 2 (son esa par ds nqxqus 5. Repeat through step 6 while (i<n-i-1)
eku dks lqjf{kr djsaA) 6. If (a[i]>a(j+1)
Step 12- Check whether (son+1)<k (tkaps fd D;k (son+1) k ls (i) temp = a (j).
NksVk gSA) (ii) a [j] = a (j+1).
if yes then (;fn gka rks (iii) a (j+1) = temp.
Perform Step 13 Step 13 dk vuqlj.k djsa 7. Display the sorting elements of array a.
else vU;Fkk 8. Exit.
Perform step 14 Step 14 dk vuqlj.k djsaA) For Example:- The following array is given:-
Step 13- check whether A[son+1] > A[son] bl izdkj ds Array esa adjacent number dks compare fd;k tkrk gSA
(tkaps fd D;k A[son+1] dk eku A[son] ls cM+k ;fn a[i]>a[i+1]=exchange
gSA) if a[i]<a[i+1]=no change
if yes then 11 15 2 13 6
son ++ (;fn gka rks son esa ,d dk a[0] a[1] a[2] a[3] a[4]
increment djsaA)
Step 14- check whether son > n (tkaps fd D;k son dk eku n blesa vyx vyx passes dks perform fd;k tkrk gSA tc rd array ds last
ls cM+k gSA) element rd uk igqWap tk,A
if yes then PASS 1:
set son = n (;fn gka rks son esa n 1.fn, x, Array a[0] dks a[1] ls compare djok,saxsaA
lqjf{kr djsaA) if a[0]>a[1]=exchange and if a[0]<a[1]=no change
[End of If condition] 11,15 ls NksVk gSAvr% no change
Step 15- set A[par] = root (A[par] esa root dk eku
lqjf{kr djsaA) 11 15 2 13 6
[End of loop of step 8] a[0]<a[1]=no change
[end of loop of step 2]
2. fn, x, Array a[1] dks a[2] ls compare djok,saxsaA
Step 16- Exit
if a[1]>a[2]=exchange and if a[1]<a[2]=no change
15,2 ls cM]k gSAvr% exchange

48 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
11 15 2 13 6 2 11 13 6 15
a[1]>a[2]=exchange a[1]<a[2]= no change

11 2 15 13 6 3. fn, x, Array a[2] dks a[3] ls compare djok,saxsaA

3. fn, x, Array a[2] dks a[3] ls compare djok,saxsaA if a[2]>a[3]=exchange and if a[2]<a[3]=no change
if a[2]>a[3]=exchange and if a[2]<a[3]=no change 13,6 ls cM]k gSAvr% exchange
15,13 ls cM]k gSAvr% exchange 2 11 13 6 15
11 2 15 13 6
a[2]>a[3]=exchange
a[2]>a[3]=exchange
2 11 6 13 15
11 2 13 15 6 4. fn, x, Array a[3] dks a[4] ls compare djok,saxsaA
4. fn, x, Array a[3] dks a[4] ls compare djok,saxsaA if a[3]>a[4]=exchange and if a[3]<a[4]=no change
if a[3]>a[3]=exchange and if a[3]<a[4]=no change 13,15 ls NksVk gSAvr% no change
15,6 ls cM]k gSAvr% exchange 2 11 6 13 15
11 2 13 15 6 a[3]<a[4]=no change
PASS 3:-
a[3]>a[4]=exchange
Now the array is:
11 2 13 6 15 2 11 6 13 15
PASS 2: a[0] a[1] a[2] a[3] a[4]
Now the array is: 1.fn, x, Array a[0] dks a[1] ls compare djok,saxsaA
11 2 13 6 15 if a[0]>a[1]=exchange and if a[0]<a[1]=no change
a[0] a[1] a[2] a[3] a[4] 2,11 ls NksVk gSAvr% no change
1.fn, x, Array a[0] dks a[1] ls compare djok,saxsaA
if a[0]>a[1]=exchange and if a[0]<a[1]=no change 2 11 6 13
11,2 ls cM]k gSAvr% exchange 15
a[0]<a[1]=no change
11 2 13 6
15 2. fn, x, Array a[1] dks a[2] ls compare djok,saxsaA
if a[1]>a[2]=exchange and if a[1]<a[2]=no change
a[0]>a[1]=exchange
11,6 ls cM]k gSAvr% exchange
2 11 13 6
15 2 11 6 13 15
2. fn, x, Array a[1] dks a[2] ls compare djok,saxsaA a[1]>a[2]= exchange
if a[1]>a[2]=exchange and if a[1]<a[2]=no change
11,13 ls NksVk gSAvr% no change 2 6 11 13 15
3. fn, x, Array a[2] dks a[3] ls compare djok,saxsaA
49 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
if a[2]>a[3]=exchange and if a[2]<a[3]=no change (1) fn, x;sa array esa 25 dks left vkSj pivot nksuksa
11,13 ls NksVk gSAvr% no change point djsaxsa rFkk right pointer array ds last element dks point
2 6 11 13 15 djsaxk vc pivot dks right lsa compare djsaxs ;fn pivot right ls
a[2]<a[3]=no change
NksVk gS rks no change ughs rks element dks exchange dj fn;k
tk;sxk
4. fn, x, Array a[3] dks a[4] ls compare djok,saxsaA 25 10 30 15 20
if a[3]>a[4]=exchange and if a[3]<a[4]=no change 28
13,15 ls NksVk gSAvr% no change
2 6 11 13 15 Pivot Pivot or left < right = no change right
a[3]<a[4]=no change left

Now the Array is sorted.

(2) right pointer dks vkxs c<k;saxs vkSj mls pivot ls
compare djsaxs
QUICK SORT
If ( pivot or left is less than right then no change)
(1) fn, x, Array dh left boundary ij left pointer rFkk right boundary
if (pivot or left is greater than right then exchange the element with
ij right pointer assign djsaxsaA pivot)
(2) Array ds 1st element dks pivot ekusaxsa vkSj bls bldh lgh 25 10 30 15 20
position ij igqWpk,saxsaA vr% Pivot ds left esa Pivot ls 28
NksVs Element vkSj Pivot ds right esa Pivot ls cMssa
element Pivot right
(3) blds fy, lcls igys Pivot vkSj left pointer nksuks ,d gh left
element dks iksabV djsaxs vc left dk comparision right pointer
ls djsaxs 20 10 30 15 25
If ( pivot or left is less than right then no change) 28
if (pivot or left is greater than right then exchange the element with
pivot) left Pivot
(4) ;fn Pivot Right esa igqWap x;k gS rks left dks increase right
djsaxsa
if pivot or right is less then left then exchange (3) D;ksafd pivot right side esa vk pqdk gS vr% pivot ds left esa
if pivot or right is greater then left then no change pivot lsa NksVh values vkuh pkfg, vr% vc left pointer dks vkxs
c<k;sasxs A
for example :- 20 10 30 15 25
25 10 30 15 20 28
28 Pivot or right > left = Nochange Pivot
left right
50 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
20 10 15
(4) D;ksafd pivot right side esa vk pqdk gS vr% pivot ds left esa
pivot lsa NksVh values vkuh pkfg, vr% vc left pointer dks vkxs Pivot right
c<k;sasxs A left
20 10 30 15 25
28 (8) mijksDr array ess 20 dks pivot ekuk gS vc Pivot vkSj Rght
Pointer dks Compare djsaxsA
left Pivot ;fn Right Pointer Pivot ls NksVk gS rks Right okys Element
Pivot or right < left = Exchange right dks Pivot ls Exchange dj fn;k tk;sxkA

20 10 15

20 10 25 15 30
Pivot right
28
left
(5) D;ksafd pivot left side esa vk pqdk gS vr% pivot ds right esa
pivot lsa cMh values vkuh pkfg, vr% vc right pointer dks vkxs Pivot, right Pointer ls
cM+k gS vr% bls Exchange djsaxsA
c<k;sasxs A 15 10 20
20 10 25 15 30  
28 Left Pivot
Right
Pivot right (9) bl izdkj Pivot Right esa vk pqdk gSaA vkSj Right ds Left
left okyh lHkh values right ls NksVh gksuh pkfg, vr% Left dks
vkxs c<+k,xsaA
Pivot or left >right = Exchange
15 10 20
 
20 10 15 25 30 Left Pivot
28 Right
(6) vr% vc pivot viuh lgh position ij vk pqdk gS A pivot ds left Left Pointer okyk Element Pivot ls NksVk gSaA vr% No
esa lkjh pivot ls NksVh values gS vkSj pivot ds right esa pivot ls Exchange vc bls Pivot okys Array esa Add dj nsaxsA D;ksafd tc
cMh values gS Avr% vc array dks rhu parts esa divide dj nsaxs A Left dks vkxs c<+k,xsa rks Left Pivot vkSj right rhuksa ,d gh
first array esa pivot ls NksVh values dks j[ksaxs second array esa element dks Point djsaxsA vr% Array Sorted gSaA
pivot dks j[ksaxs rFkk third array es pivot ls cMh values dks j[kk 15 10 20 25
tk;sxk A vc first vkSj third array dh vyx vyx sorting djsaxs vkSj
mls ckn esa pivot ds lkFk add dj fn;k tk;sxk A (10) vc Pivot ds right side okys Array dks sort djsaxs
(7) pivot ls NksVs elements ds array dks sort djsaxs A Pivot ls 30 28
NksVs elements dk array fuEu gS %&
51 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(11) 30 dks Pivot ekusaxs vkSj Left Pointer Hkh 30 dks Point (i) Temp = a (left)
djsxkA Right Pointer 28 dks Point djsxkA (ii) a(left) = (Right)
(iii) a (Right) = temp
30 28 (iv) left = left +1
  (v) Right = Right + 1
Pivot Right Step 8 : If (l, right) quick_sort (a, l , right)
Left Step 9 : If (left<R) quick_sort (a, left, r)
vc Pivot dks right Pointer ls Compare djsaxsA ;fn Pivot right ls cM+k Step 10: Exit
gS rks mls exchange dj fn;k tk,xkA Searching
28 30 Searching dk vFkZ gS <wa<ukA Searching }kjk fdlh Hkh List esa
  lqjf{kr fdlh element dks <wa<k tk ldrk gSaA Searching fdlh Hkh
Left Pivot List vFkkZr+ dqN Elements dk leqg gSa tks Link ds }kjk tqM+s
Right jgrs gSa esa ls fdlh Element dh Location dks <wa<us ds fy, dh
D;ksafd Pivot Right esa vk pqdk gSa vr% Pivot ds Left esa Pivot tkrh gSaA Searching dk Successful ;k Unsuccessful gksuk iw.kZr%
ls NksVh Values gksuh pkfg, vr% Left dks vkxs c<+k,xsaA Element ds feyus ;k u feyus ij fuHkZj djrk gSa vFkkZr~ ;fn
28 30 element list esa fey tkrk gSa rks Searching successful dgykrh gSa
 vkSj ;fn element list esa ugha feyrk gSa rks Searching Unsuccessful
Left dgykrh gSa Searching dh algorithm list esa stored elements ds Data
Right Structure ds type ij fuHkZj djrh gSaA vr% ;fn ,d array esa searching
Pivot djrs gSa rks mldh algorithm vyx gksxh vkSj ;fn ,d List esa
vr% Array Sorted gSa vc bls Pivot ds lkFk Pivot ds right esa add dj Searching djrs gSa rks mldh algorithm vyx gksxhA Fast Searching
nsaxsA ds fy, nks Searching methods dks Use esa fy;k tkrk gSaA
15 10 20 25 28 30 (1) Linear ;k Sequential Search (2) Binary Search
(12) bl izdkj quick sort ds }kjk Array dks sort fd;k tkrk gSa
Algorithm For Quick Sort (1) Linear ;k Sequential Search: - ;g lcls Easiest Searching Method
Step 1 : [Initially] gSa Sequential Search dh rqyuk single key ds mij dh tkrh gSaA
Left = l Linear Search esa ge Øe ls ,d&,d djds Array ds gj Element rd
Right = R igq¡prs gSa vkSj ns[krs gSa fd og element fn;k x;k element
Pivot = a[(l+r)/2] gSa ;k ugha ;fn element fey tkrk gSa rks og Successful Search
Step 2 : Repeat through step 7 while (left <= high) dgyk,xh vkSj ;fn Element ugha feyrk gSa rks og Unsuccessful
Step 3 : Repeat step 4 while (Left<=Right) Search dgyk,xhA ;g ,d ,slh rduhd gSa tks fn, x, Item dks Locate
Step 4 : Left = Left + 1
djus ds fy, Squentially Array dks Traverse djrk gSaA
Step 5 : Repeat step 6 while (a {[Right] < pivot})
Effeciency of Sequential Search: - blesa fn;k x;k le; vFkok
Step 6 : Right = Right – l
comparision ds No. Searching esa Record cukrs gSa tks Technique
Step 7 : If (left < = Right)
dh Capacity ij vk/kkfjr gksrk gSa ;fn fn;k x;k element first position ij
52 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
gSa rks dsoy ,d Search Table dk Comparision cusxkA ;fn fn;k x;k (iii) vc Begning vkSj end okys Index ls Middle Value dks
Element Last esa gS rks N Comparisions gksaxs vkSj ;fn element Find out fd;k tk,xkA
array ds chp esa dgha ij gSa rks (N+1)/2 comparision gksaxsA (iv) vc Check djsaxs fd ftl Item dks Search djuk gSa
blds fy, fuEu algorithm gSa og Middle Value ls c<+k gSa ;k NksVkA
Algorithm - ;g Algorithm a esa Item ds Loc, Location dks izkIr djrk (v) ;fn fn;k x;k Item Middle Value ls NksVk gSa rks
gSa] ;k Sets loc = 0 ;fn Search vlQy gSaA mls Middle ls igys okys Array esa Search djsaxsA
1. [insert item at the end of data] set data [n+1] = item (vi) ;fn fn;k x;k Item Middle Value ls cM+k gSa rks
2. [initialize counter] set loc = 1. mls Middle ls ckn okys Array esa Search djsaxsA
3. [search for item] bl izdkj gj ckj Begning vkSj End dks Set fd;k tk,xk vkSj Specific
Repeat white data [loc] = item; element dks Find out djsaxsA
set loc = loc+1. Example: - ,d Sorted Array fn;k x;k gSa ftlesa ls 15 Element dks
4. [successfull] if loc = n+1, then set loc = 0 Search djuk gSa
5. Exit. Array = 3, 10, 15, 20, 35, 40, 60
Binary Search: - ;g Data Structure Sorted Array vkSj Link List nksuksa Solution: -
dk Combination gSa bl Search ds dqN Important Points fuEu gSaA 3 10 15 20 35 40 60
(1) Bianry Search Recursive gSaA ;g fu/kkZfjr djrk gSa fd Search a[0] a[1] a[2] a[3] a[4] a[5] a[6]
Key Array ds uhps ;k mij okys vk/ks Hkkx ij fLFkr gSa ;k  
ugha Beg End
(2) ;gka ,d Termination Condition gSa mid = (beg + end)/2
(i) ;fn Low > high rc partition ;g Search djrk gSa fd (0 + 6)/2 = 3
dksbZ element blesa ugha gSaA (1) vr% mid a[3] Element dks point djsxkA vc ;g Check djsaxs fd
(ii) ;fn ;gka ij Current Partition ds e/; esa Element ds a[3] ij tks element gSa og 15 ls NksVk gS ;k cM+k
lkFk ,d Match gSa rks Easily Element ls okil tk (i) ;fn a[3] ij tks Element gS og 15 ls NksVk gS rks
ldrs gSaA 15 ds right okys array esa search djsaxsA
(3) Array dks rc rd Search djuk tc rd fd lgh Point }kjk Insert (ii) ;fn a[3] ij tks element gS og 15 ls cM+k gS rks 15
djok;k x;k u;k Item izkIr u gks tk,A ds Left okys Array esa Search djasxsA
(4) lHkh Items dks ,d LFkku ij Move djuk (2) a[3] ij 20 gS tks 15 ls cM+k gS vr% 15 dks mlds left esa
(5) u;s Item dks [kkyh LFkku esa Insert djukA search fd;k tk,xk blds fy, end esa mid – 1 dks Assign
(6) Binary Search dks Static ?kksf"kr fd;k tkrk gSa ;g ,d Local djsaxsA vkSj iqu% Begning vkSj End ds Middle Value dks
Function gSaA tks lHkh Programs ds }kjk Access fd;k tk ldrk find djsaxsA
gSaA 3 10 15 20 35 40 60
(7) fn;s x, Element dks Array esa Search djus ds fy, fuEu Steps a[0] a[1] a[2] a[3] a[4] a[5] a[6]
dks Follow djsaxsA   
(i) Beg Array ds first element dks Point djsxkA Beg End mid
(ii) End Array ds Last Element dks Point djsxkA mid = (beg + end)/2
53 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
(0 + 2)/2 = 1
(3) a[1] ij 10 gS tks 15 ls NksVk gS vr% 15 dks mlds Right esa
search fd;k tk,xk blds fy, Beg esa mid + 1 dks Assign
djsaxsA vkSj iqu% Begning vkSj End ds Middle Value dks
find Out djsaxsA
3 10 15 20 35 40 60
a[0] a[1] a[2] a[3] a[4] a[5] a[6]
 
Beg End
mid = (beg + end)/2
(1 + 2)/2 = 2
(4) Begning vkSj end nksuks a[2] dks point djsaxs vr% vc check
djsaxs fd 15 a[2] ij rks ugha gSa array ns[kus ls irk pyrk
gSa fd a[2] position ij 15 gSA bl izdkj Binary Search Perform
fd;k tk,xkA
Algorithm for Binary Search
Begin
set beg = 0
set end = n – 1
set mid = (beg+end)/2
while ( (beg < end) and (a[mid] # item ) ) do
if (item < a [mid]) then
set end = mid-1
else
set beg = mid + 1
endif
set mid = (beg + end) / 2
endwhile
if ( beg > end) then
set loc = -1
else
set loc = mid
endif
End.

54 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
UNIT - V Hash Table dh complexity (okLro esa bl Cell esa fdrus Percent
Hash Table:- Memory esa dqN Data dks Store djus ds fy, cgqr ls Element dks Include fd;k x;k gSaA) Example: - Hash Function ges'kk
Program dh vko';drk gksrh gSaA Data Structure dks dbZ izdkj ds fdlh Hkh Element ds fy, Return gksxk rks ;g ns[kk tkrk gSa fd ,d
Operations Perform djus ds fy, cuk;k x;k gSA tSls Array, Linked List, Link Lised dh rjg Hash Table ds dk;Z ls feyk gS tks Operation dks
Binary Search Tree vkfn ds vUrZxr fdlh Hkh Element dks vklkuh ls <+w<us esa T;knk Important ugha gSaA Key dks Use esa ysus
Add ;k Delete fd;k tkrk gSaA ,d Hash Table mu Target dks Include dj dk General Item ;g gSa fd fdlh Hkh Record ds Address dks Store dj
ldrs gSa ftuds ikl Key vkSj Value gS rFkk tks Objects dks Hkh fy;k tk;sA ysfdu blh Modify fd;k tkuk pkfg;s rkfd T;knk Memory
Include djrs gSaA blesa Hash Table dk ,d Array cukk; tkrk gSa tks Waste u gks bl Modification ds fy;s ,d Function H dks K Set of Keys
fd Hashing Function gksrk gSaA Hash Function ,d Argument ds :i esa ij Define fd;k tkrk gSaA ;g Function fuEu izdkj gSaA
Key ysrk gSa vkSj Table ds Array dh Range esa dqN Index dh H : K L
Calculation djrk gSaA bl Function dks Hash Fu`nction dgk tkrk gSa gks ldrk gSa fd nks
tc ge Hash Table esa ,d element dks Include djuk pkgrs gSa rks Keys K1 rFkk K2 nksuks Same Hash Address dks Point djrh gSaA bl
lcls igys bldh Hash Value dh Calculation dh tkrh gSaA ge Array izdkj dh Condition dks Collision dgykrh gSa vkSj bl Collision dks
esa Location dks rc rd Findout djrs gSa tc rd bldk index hash value nwj djus ds fy, dqN Methods dks Use fy;k tkrk gSaA Hashing dks
ds cjkcj ugha gks tkrk vkSj ogka Item Insert dj fn;k tkrk 2 Parts esa Divide djrs gSaA
gSaA ;fn Location Table esa igys ls gh use esa vk jgh gSa rks ikl (1) Hash Function
okyh Free Location dks Check djrs gSaA bl izdkj dh hashing simple (2) Collision Resolution
hashing dgykrh gSaA
tc Array esa ,d Element dks iznf'kZr djuk pkgrs gSaA rc lcls igys (1) Hash Function: - Hash Function dks Select djus ds fy, 2
Hash value dh x.kuk dh tkrh gS vkSj rc Location ij Table dh principles dks Use esa fy;k tkrk gSaA ,d Function H cgqr Easy
Checking Start gksrh gSa ftudh Index bl hash value ds cjkcj gksrh rFkk Quick Computation dks Perform djrk gSaA Hash Function
gSA Hash Addresses dks Uniformly distribute djrk gSaA ftlls de ls de
;fn Hash Table ls element dks Delete djuk pkgrs gSa rks lcls igys Collision Occur gksrs gSaA
ml Element dh Location dks Find out fd;k tkrk gSaA tc Element fey (2) Collision Resolution: - ekuk fd ge ,d u;s Record R dks Key K
tkrk gSa rks ml ij Mark yxk fn;k tkrk gSa fd Location Free gksA ds lkFk File F esa Add djuk pkgrs gSa ysfdu Memory Location
;fn dksbZ Element "C" dks Findout djus dh dks'kh'k djrs gSa tgka ij u;s Record dks Add djuk gS og Full gSa rks bl izdkj dh
rks lcls igys bldh Hash Value dh Calculation dh tkrh gSaA fQj condition Collision dgykrh gSaA Collision dks nwj djus ds fy,
bl Location esa tkdj ns[krs gSa ;g Location 2 gSA tc C fey dqN Techniques dks Use esa fy;k tkrk gSaA
tkrk gSa rks bldh Hash Value dh calculation djrs gSaA ;fn Normally Collision dks Avoid djuk Impossible gS tSls ,d Class esa
fdlh Element dks Hash Table ls gVk;k x;k gks rks mlds LFkku 24 Studnets gSa vkSj ,d Table esa 365 Records dk Space gSaA ,d
ij ,d Mark yxk nsrs gSaA tSls fuEu fp= esa B dks gVk;k x;k gS Random Hash Function ds }kjk Student ds Birthday dks Choose
rks mls fuEu izdkj iznf'kZr fd;k tkrk gSaA fd;k tkrk gSaA
a * c
Hash Table ij Operations dks Find rFkk View fd;k tk ldrk gSaA ;g Hash Function dh Efficiency dks Collision ds Solution ds Procedure ds
nks Factor dk Function gSA vk/kkj ij Major fd;k tkrk gSaA blds fy, Key Comparision dh
55 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
vko';drk gksrh gSaA ftlls Specific Record dh Location Find fd;k
tkrk gSaA Efficiency Load Factor ij fuHkZj djrh gSaA Collision Record : A, B, C, D, E, X, Y, Z
Resolution ds fy, 2 Procedure dks use esa fy;k tkrk gSaA H(k) : 4, 8, 2, 11, 4, 11, 5, 1

(1) Open Addressing: - ekuk ,d u;s Record R dks Key K ds lkFk Chaining dks Use esa ysdj Records dks Memory esa fuEu izdkj ls
Memory Table T esa Add djuk gS ysfdu Memory Address ;k Memory Represent fd;k tk ldrk gSaA
Location With Hash Address igys ls Hkjh gqbZ gSaA bl izdkj ds 1 8 1 A0B0C0D0E1X4
Collision dks nwj djus ds fy, R dks First Available Location esa 2 3 2 Y0Z010111213140
Assign dj fn;k tk;sxkA blds fy, lcls igys Record R dks Search fd;k 3 0 3
tk;sxk blds fy, Linear Search dks Use esa ysrs gSaA bl izdkj ds 4 5 4
collision resolution dks linear probing dgk tkrk gSaA 5 7 5
Example: - ekuk ,d Table T esa 11 Memory Locations gSaA T[1].... 6 0 6
T[11] rFkk File F esa 8 Records gSaA A, B, C, D, E, X, Y rFkk Z ftlds 7 0 7
Hash Address fuEu gSaA 8 2 8
9 0 9
Record : A, B, C, D, E, X, Y, Z 10 0 10
H(k) : 4, 8, 2, 11, 4, 11, 5, 1 11 6 11
12
ekuk 8 Records dks Table T esa mijksDr Order ds vk/kkj ij Enter dj
fn;k x;k gSaA vc File F dks meory esa fuEu izdkj ns[kk tk ldrk 13
gSaA 14
AVAIL = 9
Table T: X, C, Z, A, E, Y, __, B, _, _, D
Address: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 GRAPHS
Graph Hkh ,d Non-Linear Data Structure gSA bl v/;k; esa ge Graph
Linear Probing dk Main Disadvantage ;g gSa fd Records dk ds lkFk fd, tk ldus okys lHkh Operations ds ckjs esa tkudkjh
Clusterization gks tkrk gSaA tc Load Factor > 50% gks Clustering izkIr djsaxsA
fdlh Hkh Record ds Average Search Time dks Increase dj nsrh gSaA ,d G Graph Vertices (Nodes) ds Set V vkSj Edges ds Set E, ls fufeZr
gksrk gSA bls ge bl izdkj Hkh dg ldrs gSa fd Vertices (Nodes) dk
(2) Chaining: - Chaining Memory esa 2 Tables dks Maitain djrh Set V vkSj edges dk Set E feydj ,d Graph cukrs gSaA ge Graph =
gSaA ,d Table T Memory esa F Records dks Contain djrh gSaA T ,d (V,E) fy[krs gSaA V, Nodes dk ,d lhfer vkSj Hkjk gqvk Set gS
Additional Field dks Maintain djrk gSa ftlesa Links dks j[kk tkrk vkSj E, Nodes ds tksM+ksa dk Set gS] ;s tksM+s gh Edges
gSa lHkh records tks Table T esa gSa Same Hash Address H dgykrs gSaA
ds }kjk ,d nwljs ls Linked jgrs gSaA For Example: - ,d Data Table T
esa 8 Records gS ftudk Hash Address fuEu Records gSaA Graph dks ifjHkkf"kr djuk

56 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
V(G) dks Graph dh Nodes i<+k tkrk gS vkSj E(G) dks Graph dh
Edge i<+k tkrki gSA A B
,d Edge E=(V,W) nks Nodes, V vkSj W dk ,d tksM+k gSA tgka V
vkSj W Incident gSA
bu nksauks Sets dks le>us ds fy, fupa fp= esa n'kkZ, Graph dk E
v/;;u djsaA
bl fp= esa ,d lk/kkj.k ;k fn'kkghu Graph dks n'kkZ;k x;k gS] C D
ftlds Nodes dks Øe'k% A, B, C, D vkSj E uke fn;k x;k gS blfy, &
A B mijksDr fp= esa n'kkZ, x, Graph ds fy, &
V (G) = (A,B,C,D,E,)
E E (G) = {(A,B), (A,C), (A,D), (C,D), (B,E), (B,D), (D,E)}

C D

V(G) = (A, B, C, D, E) vk/kkjHkwr ifjHkkf"kd 'kCnkoyh

E(G) = {(A,B), (B,D), (D,C), (C,A), (A,D) (B,E), (D,E)} (Graph Terminology)
vki ns[k ldrs gSa fd ,d Edge A vkSj B dks tksM+rh gS vkSj fn'kkghu vkSj fufnZ"V Graph ge igys gh crk pqds gSa] dqN
geus bls (A,B) fy[kk gS] bls (B,A) Hkh fy[k tk ldrk FkkA ;gh ckr Graphs fuEufyf[kr gSa &
ckdh lHkh Edges ij Hkh ykxw gksrh gSA blhfy, ge dg ldrs gSa ,d Graph G, iw.kZ Graph dgk tk,xk] ;fn Graph dh izR;sd Node
fd pwafd Graph esa Nodes dks Øe ugha fn;k x;k gS] ;g ,d Graph dh izR;sd nwljh Node ls tqM+h gksA ,d iw.kZ Graph
fn'kkghu xzkQ ds fy;s lgh gSA ftlesa n Vertices gSa mlesa] n(n-1)/2 Edges gksaxhA ,d iw.kZ
,d fn'kkghu Graph esa Nodes dks tksM+k ,d fcuk Øe dh Edge Graph dks fuEukafdr fp= esa n'kkZ;k x;k gS &
dks izLrqr djrk gSA blhfy, (V,W) vkSj (W,V) nksuksa ,d gh Edge A
dks izLrqr djrs gSaA
,d fn'kk okys Graph esa izR;sd Edge, Nodes dk ,d Øfed tksM+k
gksrk gS] vFkkZr~ izR;sd edge ,d fn'kk okys tksM+s ls izLrqr
gksrh gSA B
;fn E = (V,W) rks Edge, V ls izkjEHk gksxh vkSj W ij lekIr gks jgh
gSA ;gka V dks Tail vFkok Initial Vertex rFkk W dks Head vFkok C
Final Node Vertex dgk tk,xkA vr% (V,W) vkSj (W,V) nks fHkUu
Edges dks iznf'kZr djsaxhA
,d fn'kk okyk vFkok fufnZ"V Graph fuEukafdr fp= esa n'kkZ;k D E
x;k gS &
57 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure

,d Vªh] ftlesa cycle cuh gks] mls Graph dgrs gSaA bls bl izdkj
Hkh dg ldrs gSa fd ;fn ,d tree dh fdlh Node dks nks izdkj ls
accesds fd;k tk ldrk gS] ;g tree ugha cfYd Graph gksrk gSA ,slk
,d Graph ftldh Edges ij /kukRed vad fy[ks gksrs gSa] mUgsa
gh ,d Graph fuEukafdr fp= esa n'kkZ;k x;k gS &
Weighted Graphs dgrs gSaA ,slk gh ,d Graph fuEukafdr fp= esa
2
A n'kkZ;k x;k gS & B C

2 4 2
2 5
B E
4
A D E 6 H

C D F G 3 3
2 1

,d tqM+k gqvk Graph ftlesa cycle u gks] mls Tree Graph vFkok
F G
Free Tree vFkok lk/kkj.k Tree dgk tkrk gSA ,slk gh ,d Graph 5
fuEukafdr fp= esa n'kkZ;k x;k gS &
A B

E og Graph ftlds gj Node dh Degree leku gksrh gS] Regular Graph

dgykrs gSaA ,slk gh ,d Graph fuEukafdr fp= esa n'kkZ;k x;k
gS &
C D

,d Graph ftldh Edges ij Data fy[kk gksrk gS] Labeled Graph dgykrk B C
gSA ,slk gh ,d Graph fuEukafdr fp= esaA1 n'kkZ;k x;k gS &
A B
A2
A5 A4
D 58 B.M.COLLEGE
E BALOTRA
C D
A3
 3BCA3 - Data Structure

os Edges ftudk Intial vkSj End Point leku gksrk gS] mUgsa
Parallel Edges dgrs gSa rFkk og Edge ftldk Intial vkSj End Point ,d
gh gksrk gS] mls Self Loop dgrs gSaA
,slk Graph, ftlesa u rks Self Loop gks ;k fQj Parallel Edge gks
vFkok nksuksa gh gksa, Multigraph dgykrk gSA ;gka V1 vkSj V2 adjacent gSa, V1 vkSj V3 adjacent gSa, V2 vkSj V3
A B adjacent gSa, V3 vkSj V4 adjacent gSa rFkk V4 vkSj V5 adjacent
gSa D;ksafd ;s lHkh vertices fdlh u fdlh edge ds }kjk vkil esa
tqM+s gq, gSaA izR;sd Vertex dks mlls lEc) edges ds vk/kkj ij
fMxzh (Degree) iznku dh tkrh gSA ;gk¡ ij V1 Vertex, nks Vertices
V2 vkSj V3 ls tqM+k gqvk gS, vr% V1 dh fMxzh 2 gksxhA
C D blh izdkj Vertex V2 dh fMxzh = 2
Vertex V3 dh fMxzh = 3
Vertex V4 dh fMxzh = 2
,slk Graph, ftlesa u rks Self Loop gks vkSj uk gh Parallel Edge gks, Vertex V5 dh fMxzh = 1
Single Graph dgykrk gSA bls bl izdkj Hkh dgk tk ldrk gS fd og Vertex ftldh fMxzh dsoy 1 gksrh gS, mls Pandent Vertex dgk
dksbZ Graph, tks fd Multigraph ugha gS, Single Graph dgykrk gSA tkrk gSA
,slh Vertex, tks fdlh vU; Vertex ds Contact esa ugha gksrh, og og Vertex ftldh fMxzh 'kwU; (0) gS, mls Isolated Vertex dgk tkrk
Isolated Vertex dgykrh gSA ,slk Graph ftlesa, Isolated Vertex gksrh gSA fiNs fn, x, fp= esa blh izdkj dh Vertex dks n'kkZ;k x;k gSA
gS, mls NULL Graph dgrs gSaA ,slk gh ,d Graph fuEukafdr fp=
esa n'kkZ;k x;k gS &
Path: - closed path og Path gS tgka Path ds End Points Same gks
Adjacent Vertices (Neighbours) og Path Simple Path dgykrs gSa ;fn lkjs Vertices ,d Sequence esa
fuEukafdr fp= esa vertex V1, vertex V2 ds adjacent dgyk,xh, ;fn ,d gks vkSj lHkh vyx&vyx gksA
edge (V1, V2) vFkok (V2, V1) gS &
e1 Connected Graph: - ,d Graph G Connected dgykrk gSa ;fn 2 Vertices
V1 V2
ds chp esa ,d Path gks
e3 e2
Multigraph: - ,d Graph ftldh Multiple Edges gksrh gSaA mUgsa
V3 e4 V4 Multigraph dgk tkrk gSaA
Out Degree & In Degree of vertex: - ,d Vertex ls ftruh Edges ckgj dh
rjQ fudyrh gSaA mUgsa Vertex dh Outdegree dgk tkrk gSaA ,d
e5
59 B.M.COLLEGE BALOTRA

V5
 3BCA3 - Data Structure
Vertex ij ftruh Edges vkdj [kRe gksrh gSaA mUgsa Vertex dh In esa n'kkZ, x, Graph dk Adjacency Matrix Representation fp= ds
Degree dgk tkrk gSaA uhps n'kkZ;k x;k gS &

In Degree Out Degree

Source & Sink: - ,d Vertex Source dgykrk gSa tc mldh Outdegree

Greater than 0 gks rFkk In degree = 0 gksA
,d Vertex Sink dgykrk gSaA tc ml Vertex dh In Degree Greater than 0
vkSj Out degree = 0 gksA
Parallel Edges: - vyx&vyx Edges E rFkk E- Parallel Edges V1 V2 V3 V4
dgyk,saxs ;fn os same source rFkk Terminal Vertices ls Connected
gksA V1 0 1 0 1
Direct Acyclic Graph: - Directed Acyclic Graph ,d Directed Graph gS
ftlesa Cycles ugha curh gSaA V2 1 0 1 0
V3 0 1 0 1
Incedency
,d Edge ftu Vertices dks tksM+rh gS os Vertices ml Edge dh V4 1 0 1 1
Incedent gksrh gSA
Edge e1 dh incident – Vertices V1 vkSj V2
Edge e2 dh incident – Vertices V2 vkSj V3 ;gka geus mu vertices ds uhps 1 fy[kk gS, tks lkeus fy[kh vertex
Edge e3 dh incident – Vertices V1 vkSj V3 dh adjacent gSaA 'ks"k ds uhps 0 fy[kk gSA tSls V1, V2 vkSj V4
Edge e4 dh incident – Vertices V3 vkSj V4 dh adjacent gS blfy, geus V2 vkSj V4 ds uhps 1 fy[kk gS vkSj V1
Edge e5 dh incident – Vertices V4 vkSj V5 vkSj V3 ds fy;s 0 fy[kk gSA
Representation of Graph in Memory Indedency Matrix
Graph dks Memory esa Representation djus ds fuEufyf[kr rjhds bl izdkj ds izLrqrhdj.k esa Vertex dk fofHkUu Edges ls Relation
gSa & dks ,d Matrix ds }kjk izLrqr djrs gSaA fuEu fp= esa n'kkZ, x,
(i) Adjacency Matrix Graph dk Incedency Matrix Representation dks uhps n'kkZ;k x;k gS
(ii) Incedency Matrix &
(iii) Adjacency List Representation e1
(iv) Multilist RepresentationV1 V2 e1 e2 e3 e4
Adjacency Matrix
bl izdkj ds Representation esa vertex dk nwljh vertex ls lEcU/k V1 1 0 0 1
e5 e2
(Relation) dks ,d Matrix ds }kjk izLrqr djrs gSaA fuEukafdr fp= V2 1 1 0 0
V3 0 160 B.M.COLLEGE
1 0 BALOTRA
V4 V3
e3 V4 0 0 1 1
e4
 3BCA3 - Data Structure

;gka geus mu Vertices dks vkxs 1 fy[kk gS, tks mij nh xbZ Edge
ds Incedent gS & tSls V1, e1 vkSj e5 dh Incident gS, blfy, e1 vkSj 35
ds uhps 1 fy[kk x;k gS vkSj e2, e3 vkSj e4 ds uhps 0 fy[kk gSA

Adjacency List Representation

fuEu fp= esa n'kkZ, x, Graph ds fy, ge Adjacency List izLrqrhdj.k
djsaxsA blds fy, loZizFke ,d Table cuk,axs, ftlesa izR;sd Node
dh Adjacent Node, mlds lkeus fy[kh gks &

A B
;gka ij ftl Node dh adjacent Node crkbZ xbZ gS] mlesa nks Pointer

E iz;qDr fd, gSa, igyk Pointer rks vxyh Node dks n'kkZ jgk gS vkSj
nwljk Pointer Adjacent Node dksA
C D

A B C D
B C E
A C B C D A
D C
E C Multilist Representation
B C E bl izdkjB ds Representation esa ge List ds }kjk gh Graph dks izLrqr
djrs gSa, ijUrq Adjacent Node esa mudh lwpuk ugha cfYd muds
vc bl Table dks fuEu :i esa List esa ifjofrZr djsaxs & Pointer dks j[kk tkrk gSA
C C

D C D
61 B.M.COLLEGE BALOTRA

E C E
 3BCA3 - Data Structure

Step 1- Graph dh lHkh Nodes dks visit ds fy, rS;kj j[ksaA

(Status1)
Step 2- Start Vertex A dks Queue esa Mkydj bldk Status
Waiting djsaA

(Status 2)
Step 3- Step 4 ls Step 5 rd nksgjk;s tc rd Queue [kkyh u gks
tk,A

Step 4- Queue dh igyh Node n dks Queue ls Remove djds n dks

Process dj nsaA

(Status 3)
Step 5- Queue ds vUr esa n ds lHkh Adjacent Vertices tks fd
ready – state esa gS] dks Mky nsaA
Graph Traversal (Status 1)
Graph Traversal dk vFkZ gS & Graph dh izr;sd Node dks Visit Step 6- Step 3 dk ywi [kRe gqvkA
djukA ,d Graph dh Vertices dks Visit djus ds vuds rjhds gks ldrs Step 7- Exit
gSaA tks nks rjhds ge vkidks ;gka crkus tk jgs gSa] oks cgqr
gh izpqj ek=k esa iz;ksx fd, tkrs gSa vkSj ;s rjhds Traversal ds bl iwjs Process dks le>us ds fy, uhps fn, x, mnkgj.k dk v/;;u
vR;Ur ljy rjhds fl) gq, gSaA ;s rjhds fuEufyf[kr gSa& djsa &
(1) Breadth First Search (BFS)
(2) Depth First Search (DFS) A

Breadth First Search (BFS) B C

tSlk fd uke ls izrhr gksrk gS fd bl rjhds esa Nodes dks
pkSM+kbZ ls Visit djuk gSA BFS esa igys ge Start Vertex dh leLr
Vertices dks Visit djrs gSa vkSj fQj budh lHkh Unvisited Vertices
dks Visit djrs gSaA D E
blh izdkj vkxs rd leLr Vertices dks Visit fd;k tkrk gSA BFS ds fy,
fuEufyf[kr Algorithm dks /;ku esa j[krs gSa & F
status 1 = ready
status 2 = waiting
status 3 = process bl fp= ds fy, igys Adjacent Table cuk ysrs gSa &
62 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
vc gesa D dh cph Adjacent Vertices dks Hkh Queue esa Mkyuk gS
A B C &
B A C D
C A B E Queue E F
D B E F Origin B D
E C D F B A C D E F
F D E
vc tSlk fd ge ns[k ldrs gSa fd Graph dh leLr Nodes Visit gks
vc ge fdlh Hkh Vertex dks Start Vertex cukdj dk;Z 'kq: dj ldrs pqdh gSaA vr% Graph dk traversal lEiUu gks pqdk gS vkSj Queue
gSaA ds uhps fy[kh List gh fn, x, Graph dk BFS gSaA
bl mnkgj.k esa geus B dks Start Vertex ekuk gSA vc gesa bls
Queue esa Mkyuk gSaA ,d Graph BFS fHkUu gks ldrk gS pw¡fd ;g Start Vertex ij
fuHkZj djrk gSA
Queue B
Origin 0 Depth First Search (DFS)
blds uke ls gh izrhr gks jgk gS fd ;g rjhdk Graph dks xgjkbZ ls
bl Queue ds nks Hkkx gS & igyk Hkkx rks lk/kkj queue gS Visit djrk gSA DFS esa ge lcls igys Start Vertex dks Stack ds }kjk
ftlesa ge Vertex dh Adjacent Vertices Mkysaxs] tcfd nwljs Visit djrs gSa] fQj bldh leLr Adjacent Vertices dks Stack esa
Hkkx esa ;g Entry dh xbZ gS fd os fdldh Adjacent Vertices Mkydj] Stack ds Top ij fLFkr fØ;k rc rd nksgjkrs gSa tc rd fd
gSaA tks&tks Vertices, visit gks tk, mUgsa Queue ds uhps Stack [kkyh u gks tk,A DFS djus ds fy, vxzfyf[kr Algorithm
fy[k ysaA vc gesa B dh leLr Adjacent Vertices dks Queue esa dks /;ku esa j[krs gSa &
Mkyuk gS &
Queue A C D status 1 = ready
Origin B B B status 2 = waiting
B A C D status 3 = process
vc bu Vertices dh Unvisited Adjacent Vertices dks Visit djuk gSA Step 1- Graph dh lHkh Nodes dks visit ds fy, rS;kj j[ksaA
tSlk fd ge ns[k ldrs gSa fd A dh leLr Adjacent Vertices Visit gks (Status 1)
pqdh gSa] blfy, vc ge C dh cph Adjacent Vertices dks Queue esa Step 2- start vertex dks stack esa Mkydj bldk status Waiting dj
MkysaxsA nsaA (Status 2)
Step 3- Step 3 ls 5 rd rc rd nksgjk,a tc rd fd Stack [kkyh u
gks tk,A
Queue D E Step 4- Stack ds Top esa ls Node dks fudkydj mls Process
Origin B C djsaA (Status 3)
B A C D E Step 5- n dh Adjacent Vertices dks Stack esa Mkydj mudk
Status 1 ls 2 djsaA
63 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
Step 6- Step 3 dk Loop [kRe gqvkA
Step 7- Exit C
A
bl iwjs process dks le>us ds fy, uhps fn, x, mnkgj.k dk v/;;u A
djsa &

B C vc iqu% Top of the Stack dks stack ls ckgj fudkydj bldh Adjacent
dks Stack esa Mky nsa vkSj blh izdkj rd vkxs djrs jfg, tc rd
stack [kkyh uk gks tk,A

D E :EB :F :D :B :
AC D B
F B

ACE ACEF ACEFD ACEFDB

bl fp= ds fy, igys Adjacent Table cuk ysrs gSa & vc tSlk fd ge ns[k ldrs gSa fd stack iwjk [kkyh gks pqdk gS vr
A B C % DFS lEiUu gks pqdk gSA [kkyh Stack ds uhps list gh Graph dk
B A C D DFS gSA
C A B E ,d Graph DFS Hkh fHkUu gks ldrk gS pw¡fd ;g Hkh Start
D B E F Vertex ij fuHkZj djrk gSA
E D D F
F D E Shortest Path Problem
geus Graph dks Traverse djrs le; ns[kk fd ge Graph dks Graph dh
vc Start Vertex dks Stack esa Mky nsa &
Edges ds }kjk travel djrs gh fdlh & fdlh case esa ,slk Hkh gks
:
ldrk gS fd bu Edges ij dqN Weight fn;k x;k gSA ;g Weight dh
2 3
nwfj;ksa ds mij vlj Mky ldrk
A gSA B C
A
vc lcls igys Visited Node dks stack ds uhps fy[k ysaA Visited 1 2 1
Node dh leLr Adjacent Nodes dks Stack esa Mky nsa &
: E D
1 64 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
ge ns[k ldrs gSa fd A B E D Path dh dher (cost) lcls de
gS] blfy, ge blh jkLrs dks viuk,axsA
fdlh Hkh Graph esa Shortest Path dks [kkstus ds fy, iz;ksx fd,
tkus okyk rjhdk Dijkastra dk Method dgykrk gSA bl rjhds dks
iz;ksx djus ds fy, fuEufyf[kr Algorithms dks /;ku esa j[krs gSa &
fuEu fp= esa n'kkZ, x, Graph dk v/;;u djsaA ge Graph dh izR;sd
status 1 = ready state
Node ls Graph dh nwljh izR;sd Node ij tk ldrs gSaA ekuk gesa A
status 2 = coloured state
Node ls C Node ij tkuk gS rks gekjs ikl nks jkLrs gS & ABC ;k
AEDCA ns[kus esa rks nwljk jkLrk yEck yxrk gS] ijUrq ;fn
Step 1- Graph dh lHkh Nodes dks ready state esa initialize djk
ge edge ij fy[ks Weight ls x.kuk djsa rks nwljs jkLrs dks
nsaA (Status 1)
pqusaxsA bl izdkj ge lnSo ,d NksVs&NksVs Path dks gh
Step 2- Starting Vertex dk Status cny nsaA
pqusaxsA
(Status 2)
;gk¡ ij gesa Graph dks nkgjk ysuk pkfg,A Graph esa Path, Vertices
Step 3- Loop 4 dks rc rd nksgjk,a tc rd fd lHkh Nodes
dk ,d Øe gS] ftl izdkj os Edge esa gSaA Path dh yEckbZ mldh
Coloured Status esa ugh ifjofrZr dj nsaA
Edge ij fy[ks Weight ds tksM+ ds cjkcj gksrh gSA Path dh igyh
Step 4- n dh Adjacent Node, ftldk lcls de Weight gks] dk Status
Vertex, Path dh Source Vertex rFkk vfUre Vertex, Path dh Destination
cnydj Coloured Status dj nsaA
Vertex dgykrh gSaA
Step 5- Step 2 dk Loop [kRe gqvkA
2 Step 6- Exit
A B

1 2 bls vc mnkgj.k dh lgk;rk ls le>saxsA

1 3
A B C D E F G H I
5 { 2 1 3 3
F G E C
ge ;gka ns[k ldrs gSa fd lcls de Weight okyh Univisited Edge
AB gS] blfy, ge bldh Unvisited Incedent Vertices dks iqjkuh
2 2 1 1 2
'krksZa ds vuqlkj gh Table esa tksM+ nsaxsA
H I D A B C D E F G H I
1 { 2 4 3 1 3 3
ge ;gk¡ ns[k ldrs gSa fd lcls de Weight okyh Unvisited Edges
AE, AG vkSj AH gSaA bu rhuksa esa ls fdlh Hkh Edge dks
vc ge mijksDr fp= esa n'kkZ, Graph ds fy, Shortest Path
igys pquk tk ldrk gSA ;gka ge AE ys jgs gSa vkSj bldh
fudkysaxsA
Unvisited Incedent Vertices dks iqjkuh 'krksZa ds vuqlkj
;gka ij ge ns[k ldrs gSa A ls D rd tkus ds vusd jkLrs gSa &
Table esa tksM+ ysaxsA
igys Path dh yEckbZ A B C D 2 + 2 + 2 = 6
A B C D E F G H I
nwljs Path dh yEckbZ A G I D 3 + 1 + 1 = 5
{ 2 4 4 3 1 3 3
rhljs Path dh yEckbZ A B E D 2 + 1 + 1 = 4

65 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
vc ge AG dh lkjh unvisited incident vertices dks iqjkuh 'krksZa ds Minimal Spanning Tree
vuqlkj fyLV esa tksM+ nsaxsA Spanning Tree og Tree gS] tks fd ,d Graph }kjk cuk;k tkrk gS
A B C D E F G H I vkSj ,d Minimal Spanning Tree , og Spanning Tree ftldh Edges dh
{ 2 4 4 3 1 3 3 4 dher (Cost lcls de gSA
vr% ge ns[k ldrs gS ;fn A dks I ij igqapkuk gS] rks mldh dher ftl Graph (G) ls Spanning Tree dk fuekZ.k fd;k tk jgk gS] mldk
(Cost) dsoy 4 gSA A ls vU; Nodes ij igqapus ds fy, Path fuEufyf[kr Connected gksuk vko';d gSA ;fn Graph Connected ugha gS] rks
gSa & mlls Spanning Tree dk fuekZ.k ugha fd;k tk ldrk D;ksafd
A B  Unconnected Graph ,d Tree dgykrk gSA
A B G  ;fn dksbZ Tree (T) tks fd fdlh Connected Graph dk Spanning Tree gS]
A F  rks &
A G  (1) Graph (G) dh izR;sd Vertex Tree (T) dh Edge dks Belong
A F H  djsxh] vkSj
A G   (2) Tree (T) esa Graph (G) dh Edges gh Tree cuk,saA
A G E D  ge fdlh Graph dks Minimal Spanning Tree esa fuEufyf[kr nks
A B E  Methods ls ifjofrZr dj ldrs gSa &
(1) Krushkal's Method
(2) Prim's Method
A B (A, 2) Kurushkal's Method
J. Krushkal dk lu~ 1957 esa izfrikfnr ;g Method, Minimal Cost
Spanning Tree cukus dk cgqr gh tkuk ekuk rjhdk gSA ;g Method
(A, 1) (A, B, 3)
Graph dh Edges dh ,d List ij dk;Z djrk gSA
F (A, 3) G E C (A, B, 4) ;gka ij Input ,d Connected Weight Graph G gS] ftlesa n Vertices gSaA
Step 1- Graph dh Edges dks c<+rs Øe esa O;ofLFkr dj ysaA
Step 2- Graph G dh Vertices ls 'kq: gksdj ckjh & ckjh ls
Process djsa vkSj izR;sd Edge dks tksM+s tks ,d
(A, F, 3) H I D
Cycle ugha cukrh vFkok tc rd n-1 Edges ugha tqM+
(A, G, 4) (A, G, E, 5)
tkrhA
Step 3- Exit
;gka ij izR;sd Node ml ij A Node ls igqapus dk jkLrk (Path) o dher
;g rjhdk rc rd rks ykHknk;d gs tc rd fd Graph Nksvk gS D;ksafd
(Cost) crk jgh gSA
bl izdkj ls Tree cukus esa 'kq: esa Nodes Unconnected jgrh gSaA
bls vc mnkgj.k dh lgk;rk ls le>saxsA

Step 1- Graph dh Edges dks c<+rs Øe esa O;ofLFkr dj ysaA

AF 1
66 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure
BE 1 Edge BE dks
ED 1 A tksM+ fy;k gSA
ID 1
GI 1 1
AB 2 F B
BC 2
CD 2
1
HG 2 (3) ;gka ij Tree
FH 2
A Eesa ,d vU; 1
AG 3 Weight okyh
GE 5 1
BEdge ED dks
vc igyh Edge ls 'kq: djrs gq, Tree dks rc rd cuk,as] tc rd fd n-1 tksM+ fy;k gSA
F
vFkkZr~ (9-1=8) Edges ugha gks tkrh rFkk mUgha Edges dks 1
tksM+saxs tks fd Cycle ugha cukrh gSaA
A E

(1) ge Tree dk 1
1
fuekZ.k fdlh
F
Hkh 1 Weight (4)D;gka ij Tree
okyh Edge ls esa ,d vU; 1
izkjEHk dj ldrs BWeight okyh
gSaA ;gka ij Edge D1 dks
geus AF Edge A 1 tksM+ fy;k gSA
ls ;g fuekZ.k 1
izkjEHk fd;k E
gSA F
1

1 D
1
B
A (5) ;gka ij tree
(2) ;gka ij Tree esa ,d vU; 1
esa ,d vU; 1 1 1
Weight okyh
Weight okyh Edge IG dks
F E
G tksM+ fy;k gSA
1 67 B.M.COLLEGE BALOTRA
1
1 D
 3BCA3 - Data Structure

(8) ;gk¡ pw¡fd CD ,d cycle cuk jgh gS blfy;s ge bls ugh

tksMsaxsA

2
A B

1 1 2

(9) ;gka ij tree G E C

2 esa ,d vU; 2 F
(6) ;gka ij Tree A B
Weight okyh 2 1 1
esa ,d 2 Weight
okyh Edge AB 1 1 Edge GH dks H I D
dks tksM+ fy;k tksM+ fy;k gSA 1
G E
gS] D;ksafd 1 F
Weight okyh 1 1
lHkh Nodes Visit
gks pqdh gSaA I D
1
tSlk fd ge ns[k ldrs gSa fd n-1 (8) Edges tqM+ pqdh gSA bl Tree
dh dher (cost) = 1+2+2+1+1+1+1+2=11 gSaA

Prim's Method
Prim dk Method Hkh connected graph dks Spanning Tree esa ifjorZu
djus ds fy, iz;ksx gksrk gSA
2 blesa ,d Vscy lkFk & gh & lkFk iz;ksx dh tkrh gS]
(7) ;gka ij Tree A B Step 1-
esa ,d vU; 2 ftlesa izR;sd Vertex dh Adjacent Vertices muds Weight
1 1 2 ds lkFk fy[kh tkrh gSaA
Weight okyh
Edge BC dks Step 2- Step 3 dks rc rd nksgjk,a tc rd fd n-1 Edges u tqM+
G E C tk,aA
tksM+ fy;k gSA F
1 1 Step 3- lcls de Weight okyh Edge dks Tree esa tksM+s] ijUrq
;g /;ku j[kk tkuk pkfg, fd dksbZ Hkh edge cycle uk
I D cuk,A
1
Step 4- Step 2 dk Loop lekIr gqvkA
Step 5- Exit

68 B.M.COLLEGE BALOTRA
 3BCA3 - Data Structure

69 B.M.COLLEGE BALOTRA