DSN Ain Hindi

Data Structure and Algorithms with C in Hindi
Data Structure
a nd
Algorithms
with C
in Hindi
Kuldeep Chand
Betalab Computer Center

Falna
http://www.bccfalna.com/

Copyright 2011 by Kuldeep Chand
All rights reserved. No part of this work may be reproduced or transmitted in any form or by any
means, electronic or mechanical, including photocopying, recording, or by any information
storage or retrieval system, without the prior written permission of the copyright owner and the
publisher.
Trademarked names may appear in this book. Rather than use a trademark symbol with every
occurrence of a trademarked name, we use the names only in an editorial fashion and to the
benefit of the trademark owner, with no intention of infringement of the trademark.
Lead Editors: Kuldeep Chand
Distributed to the book trade worldwide by Betalab Computer Center, Behind of Vidhya Jyoti
School, Falna Station Dist. Pali (Raj.) Pin 306116
e-mail bccfalna@gmail.com, or visit http://www.bccfalna.com.
For information on translations, please contact Betalab Computer Center, Behind of Vidhya
Jyoti School, Falna Station Dist. Pali (Raj.) Pin 306116
Phone 97994-55505
The information in this book is distributed on an as is basis, without warranty. Although every
precaution has been taken in the preparation of this work, the author shall not have any liability
to any person or entity with respect to any loss or damage caused or alleged to be caused
directly or indirectly by the information contained in this book.
This book is dedicated to those who really wants to learn the subject rather than those
who only wants to earn the marks in exams.
Contents
Contents .................................................................................................................................... 4
Data Structure Fundamentals and Arrays .................................................................................. 8
Introduction of Data - Field, Record and File........................................................................... 8
Data Structures .................................................................................................................... 10
Linear Data Structure ........................................................................................................ 10
Non-Linear Data Structure ................................................................................................ 10
Algorithm : Time Space Tradeoff and Complexity .............................................................. 11
Algorithms ............................................................................................................................ 13
Analysis of Algorithm ........................................................................................................ 14
Rate of Growth .................................................................................................................. 14
Time Analysis ................................................................................................................... 16
Complexity ( Big O Notation ) ............................................................................................ 16
Properties of O Notation ................................................................................................. 17
CPU Time...................................................................................................................... 18
Input / Output ................................................................................................................ 19
Analyzing Algorithms ............................................................................................................ 21
Inserting and Deleting........................................................................................................... 26
Algorithm of Inserting ........................................................................................................ 27
Sorting .................................................................................................................................. 29
Bubble Sort ....................................................................................................................... 29
Selection Sort ................................................................................................................... 30
Insertion Sort .................................................................................................................... 31
Searching ............................................................................................................................. 34
Internal Search ................................................................................................................. 34
External Search ................................................................................................................ 34
Linear Searching ............................................................................................................... 34
Binary Searching............................................................................................................... 37
String Operations and Data Structure ................................................................................... 41
Pattern Matching Algorithms ................................................................................................. 44
Algebra of Matrix .................................................................................................................. 46
Addition of Matrixes .......................................................................................................... 46
Subtraction of Matrixes ..................................................................................................... 47
Multiplication of Matrix....................................................................................................... 48
Transpose of Matrix .......................................................................................................... 50
Orthogonal Matrix ............................................................................................................. 50
Symmetric Matrix .............................................................................................................. 51
Sparse Matrix .................................................................................................................... 51
Linked Lists .............................................................................................................................. 52
Linked List ............................................................................................................................ 54
Creating Linked List .............................................................................................................. 60
Memory Allocation ................................................................................................................ 61
Garbage Collection ............................................................................................................... 63
Overflow and Underflow ....................................................................................................... 63
INSERTING New NODE at the End of the LIST ................................................................... 64
INSERTING New NODE at the BEGINNING of the LIST ...................................................... 71
INSERTING New NODE at any MIDDLE Position of the LIST .............................................. 74
Searching in a Linked List..................................................................................................... 78
LIST is Unsorted ............................................................................................................... 78
LIST is Sorted ................................................................................................................... 80
Sorting .................................................................................................................................. 81
Inserting into a Sorted Linked List......................................................................................... 89
Deleting from a Linked List ................................................................................................... 90
Deletion of First Node ....................................................................................................... 91
Deletion of Last Node ....................................................................................................... 92
Deletion Any NODE from a Linked List ............................................................................. 94
Deleting the Node with a Given ITEM of Information ......................................................... 96
Header Linked List................................................................................................................ 99
Grounded Header .................................................................... Error! Bookmark not defined.
Circular Header ....................................................................... Error! Bookmark not defined.
Creating a Circular Linked List ............................................. Error! Bookmark not defined.
Traversing a Circular Linked List .......................................... Error! Bookmark not defined.
Two Way Lists OR Doubly Linked List .................................. Error! Bookmark not defined.
CREATION of Doubly Linked List ........................................ Error! Bookmark not defined.
INSERTING NODE After Specific Node Number ................. Error! Bookmark not defined.
DELETION In Doubly Linked List ......................................... Error! Bookmark not defined.
DELETION of Specified NODE of the Doubly Linked List ..... Error! Bookmark not defined.
Circular Doubly Linked List ...................................................... Error! Bookmark not defined.
Stacks and Queues ..................................................................... Error! Bookmark not defined.
STACK .................................................................................... Error! Bookmark not defined.
PUSH................................................................................... Error! Bookmark not defined.
POP ..................................................................................... Error! Bookmark not defined.
Postponed Decisions ........................................................... Error! Bookmark not defined.
ARRAY Representation of Stack .......................................... Error! Bookmark not defined.
PUSH Algorithm For Array Stack ......................................... Error! Bookmark not defined.
POP Algorithm For Array Stack ............................................ Error! Bookmark not defined.
Linked List Representation of STACK .................................. Error! Bookmark not defined.
Arithmetic Expressions and POLISH Notations ....................... Error! Bookmark not defined.
Evaluation of a Postfix Expression ....................................... Error! Bookmark not defined.
Transforming Infix Expression into Postfix Expression ......... Error! Bookmark not defined.
Quick Sort ............................................................................... Error! Bookmark not defined.
Complexity fo the Quick Sort Algorithm ................................ Error! Bookmark not defined.
Queues.................................................................................... Error! Bookmark not defined.
Representation of Queues ................................................... Error! Bookmark not defined.
PUSH Algorithm For Array Queue ....................................... Error! Bookmark not defined.
POP Algorithm For Array Queue .......................................... Error! Bookmark not defined.
Linked Representation of Queues ........................................ Error! Bookmark not defined.
Circular QUEUE ...................................................................... Error! Bookmark not defined.
DEQUE ................................................................................... Error! Bookmark not defined.
Priority Queue ......................................................................... Error! Bookmark not defined.
Trees .......................................................................................... Error! Bookmark not defined.
Binary Tree .............................................................................. Error! Bookmark not defined.
Terminology............................................................................. Error! Bookmark not defined.
A Complete Binary Tree .......................................................... Error! Bookmark not defined.
Extended Binary Tree or 2 Tree............................................ Error! Bookmark not defined.
Representation of Binary Tree ................................................. Error! Bookmark not defined.
Sequential Representation ................................................... Error! Bookmark not defined.
Linked List Representation ................................................... Error! Bookmark not defined.
Traversing Binary Tree ............................................................ Error! Bookmark not defined.
Preorder Traversing ............................................................. Error! Bookmark not defined.
Inorder Traversing................................................................ Error! Bookmark not defined.
Postorder Traversing ........................................................... Error! Bookmark not defined.

CREATING Binary Tree .......................................................... Error! Bookmark not defined.
INSERTING in a Binary Tree ................................................... Error! Bookmark not defined.
Creating Binary Tree Array Representation ............................. Error! Bookmark not defined.
Binary Search Tree (BST) ....................................................... Error! Bookmark not defined.
SEARCHING and INSERTING in Binary Search Tree ......... Error! Bookmark not defined.
Complexity of the Searching Algorithm ................................ Error! Bookmark not defined.
DELETING from Binary Search Tree ................................... Error! Bookmark not defined.
Complexity of Binary Search Tree ........................................ Error! Bookmark not defined.
Balanced Binary Tree .............................................................. Error! Bookmark not defined.
AVL Tree ( Height Balanced Tree ) ...................................... Error! Bookmark not defined.
Tree Rotation ....................................................................... Error! Bookmark not defined.
Insertion a Node in AVL Tree ............................................... Error! Bookmark not defined.
Deletion From an AVL Tree ................................................. Error! Bookmark not defined.
M Way Search Tree.............................................................. Error! Bookmark not defined.
Searching in M Way Tree .................................................. Error! Bookmark not defined.
Insertion in M Way Tree .................................................... Error! Bookmark not defined.
Deletion from M Way Tree ................................................ Error! Bookmark not defined.
B Tree .................................................................................. Error! Bookmark not defined.
Graph.......................................................................................... Error! Bookmark not defined.
Basic Concepts and Definitions ............................................... Error! Bookmark not defined.
Path ......................................................................................... Error! Bookmark not defined.
Sequential Representation ...................................................... Error! Bookmark not defined.
Adjacency Matrix ..................................................................... Error! Bookmark not defined.
Path Matrix .............................................................................. Error! Bookmark not defined.
Shortest Path Algorithm ........................................................... Error! Bookmark not defined.
Warshall Algorithm .................................................................. Error! Bookmark not defined.
Warshalls Modified Algorithm ................................................. Error! Bookmark not defined.
Dijkstras Algorithm .................................................................. Error! Bookmark not defined.
Floyds Technique ................................................................... Error! Bookmark not defined.
Linked List Representation of Graph (Adjacency List) ............. Error! Bookmark not defined.
Operations on GRAPHS .......................................................... Error! Bookmark not defined.
Inserting in a GRAPH ........................................................... Error! Bookmark not defined.
Deleting From a GRAPH ...................................................... Error! Bookmark not defined.
Traversing A GRAPH ........................................................... Error! Bookmark not defined.
Breadth First Search................................................................ Error! Bookmark not defined.
Depth First Search................................................................... Error! Bookmark not defined.
Partially Ordered Set (POSETS).............................................. Error! Bookmark not defined.
Topological Sorting .................................................................. Error! Bookmark not defined.
Minimum Spanning Tree (MST) ............................................... Error! Bookmark not defined.
Kruskals Algorithm .................................................................. Error! Bookmark not defined.
Searching and Sorting................................................................. Error! Bookmark not defined.
Searching ................................................................................ Error! Bookmark not defined.
Data Modification ..................................................................... Error! Bookmark not defined.
Sorted Array......................................................................... Error! Bookmark not defined.
Linked List............................................................................ Error! Bookmark not defined.
Binary Search Tree .............................................................. Error! Bookmark not defined.
Linear and Binary Searching ................................................... Error! Bookmark not defined.
Hash Table .............................................................................. Error! Bookmark not defined.
Hashing ............................................................................... Error! Bookmark not defined.
Hash Function ...................................................................... Error! Bookmark not defined.
Collision Resolution ................................................................. Error! Bookmark not defined.

Open Addressing : Linear Probing(Key Comparisons) and Modifications ..... Error! Bookmark
not defined.
Clustering............................................................................. Error! Bookmark not defined.
Quadratic Probing ................................................................ Error! Bookmark not defined.
Double Hashing ................................................................... Error! Bookmark not defined.
Deletion ............................................................................... Error! Bookmark not defined.
Rehashing............................................................................ Error! Bookmark not defined.
Bucket And Chaining ........................................................... Error! Bookmark not defined.
Selecting Good Hash Function............................................. Error! Bookmark not defined.
File Structure .............................................................................. Error! Bookmark not defined.
File System ............................................................................. Error! Bookmark not defined.
Basic Concepts of File and File System................................... Error! Bookmark not defined.
File Data Storage and Retrieval ........................................... Error! Bookmark not defined.
File Naming and File Attribute Maintenance ......................... Error! Bookmark not defined.
File System Application Program Interface (API).................. Error! Bookmark not defined.
Disk Space Allocation .............................................................. Error! Bookmark not defined.
FAT File System (MS-DOS) .................................................... Error! Bookmark not defined.
Directory System ..................................................................... Error! Bookmark not defined.
UNIX File System .................................................................... Error! Bookmark not defined.
i-node File System (Flat File System) ................................... Error! Bookmark not defined.
Directory File System ........................................................... Error! Bookmark not defined.
Primary Key ......................................................................... Error! Bookmark not defined.
System Architecture ............................................................. Error! Bookmark not defined.
Primary and Secondary Structure ............................................ Error! Bookmark not defined.
Secondary Storage Devices .................................................... Error! Bookmark not defined.
Hard Disk Drives .................................................................. Error! Bookmark not defined.
Disk Capacity ....................................................................... Error! Bookmark not defined.
Disk Access ......................................................................... Error! Bookmark not defined.
Last Thing by Author ................................................................... Error! Bookmark not defined.
Data Structure Fundamentals and Arrays

Data - Field, Record and File
fdlh Hkh leL;k ds lek/kku ds fy, Computer dks fofHkUu izdkj ds ekuksa dh t:jr gksrh gSA Computer
esa fdlh eku ;k ekuksa ds lewg dks Data dgk tkrk gS vkSj ekuksa ds lewg ds fdlh Single Item dks Data
Item dgk tkrk gSA ftl Data Item dks Sub Item esa foHkkftr fd;k tk ldrk gS] ml Data Item dks
Group Item ;k Composite Data Item dgrs gSa vkSj ftl Data Item dks Sub Item esa foHkkftr ugha
fd;k tk ldrk] ml Data Item dks Elementary Data Item ;k Primary Data Item dgrs gSaA
mnkgj.k ds fy, fdlh School esa tks fofHkUu Students Study djrs gSa mu lHkh Students dk dksbZ uk
dksbZ uke gksrk gSA gj Student dk uke Computer ds fy, ,d Data gSA ge gj Student ds uke dks
rhu Sub Items First Name, Middle Name o Last Name foHkkftr dj ldrs gSaA blfy, Name ,d
Group Data Item gSA blh rjg tc Hkh dksbZ Student fdlh School esa Admission ysrk gS rks ml
Student dks ,d Unique Serial Number iznku fd;k tkrk gSA ,d Student dks tks Number Allot
fd;k tkrk gS og Number fdlh nwljs Student dks Allot ugha fd;k tkrkA ;s Number fdlh veqd
fo/kkFkhZ dh Unique igpku gksrh gSA fofHkUu Students dks fn, tkus okys Serial Number dks ge vU;
Data Items esa foHkkftr ugha dj ldrs gSaA blfy, Serial Number ,d Elementary Data Item dgykrk
gSA
Data ds fdlh lewg dks Fields, Records o Files dh Hierarchy ds :i esa Organize fd;k tk ldrk
gSA ge ftl fdlh Hkh pht dks Computer esa Manage djuk pkgrs gSa] mls ,d Entity ;k bdkbZ ds :i
esa ysrs gSaA nqfu;k dh gj pht Computer ds fy, ,d Object ;k Entity gSA tSls Table, Chair,
Computer, CPU, RAM vkfnA blh rjg ls fdlh Company ds fofHkUu Employees ml Company ds
fy, Entities ;k Objects gSa vkSj fdlh School ds fofHkUu Teachers, ml School ds Objects ;k
Entities gSaA blh rjg fdlh Class ds fofHkUu Students ml Class ds Objects ;k Entities gSaA ;kuh
nqfu;k dh gj oLrq Computer ds fy, ,d Object ;k Entity gS ftls Computer esa Data Item ds :i esa
Organize fd;k tk ldrk gSA gj Object ;k Entity dh dqN fokskrk,a gksrh gSa] tks mls vU; Object ;k
Entity ls vyx cukrh gSA tSls ,d Student dh fofHkUu fokskrk,a mldk uke] mldk Serial Number,
mldh mez] mldk Color mldk Sex vkfn gks ldrh gSaA blh rjg ls fdlh Company ds fofHkUu
Employees dh Hkh viuh fokskrk,a gks ldrh gSaA fdlh Hkh Entity ;k Object dh fofHkUu fokskrkvksa dks
Entity dh Characteristics ;k Properties ;k Attributes dgrs gSaA bu Attributes esa dksbZ uk dksbZ
eku Assign fd;k tk ldrk gSA ;s eku Numeric ;k Non - Numeric gks ldrs gSaA tSls fdlh Student
ds fofHkUu Attributes dks fuEukuqlkj eku iznku fd;k tk ldrk gS&
//=================================================================
Sr_No
Name
Age
Sex
Class
123
Amit Sharma
15
Male
10
234
Rahul Varma
16
Male
10
121
Salini Bohra
15
Female
9
544
Silpa Roy
14
Female
8
534
Prince Mishra
13
Male
6
532
Devendra Bhati
14
Male
9
//================================================================
Entity dk og lewg tks fd Similar Attributes dks Share djrk gS] Entity Set dgykrk gSA tSls Table
1 esa fofHkUu Students leku Attributes dks Share dj jgs gSa blfy, ;s lewg Students Entities dk
,d Set dgykrk gSA Entity ds gj Attribute dks iznku fd, tk ldus okys eku dh ,d Range gksrh gSA
ge Table 1 esa ns[k ldrs gSa fd gesa gj Row esa fdlh Students dh fofHkUu tkudkfj;ka izkIr gks jgh gSaA
;gka fdlh Attribute dks iznku fd;k tkus okyk eku ,d Processed Data gksrk gSA bl Table esa dbZ
Attributes feydj fdlh ,d Student ds ckjs esa iwjh Information iznku dj jgs gSaA
og rjhdk ftlesa Data dks Fields, Records o Files ds Hierarchy ds :i esa Organized djrs gSa]
Data, Entity o Entity Set ds chp esa ,d Relationship dks Represent djrk gSA Field fdlh Single
Entity ds fdlh Attribute dks Represent djrk gSA fdlh Entity ds fofHkUu Attributes dks iznku fd;k
tkus okyk eku Record dks Represent djrk gS vkSj fdlh Entity Set ds fofHkUu Entities dks File
Represent djrk gSA fdlh Record esa fdlh Entity ds dbZ Fields gks ldrs gSa ysfdu tks Field fdlh
Record dks Uniquely Identify djrk gS mls Primary Key Field dgrs gSaA tSls fdlh School ds
fofHkUu Students dks Uniquely Identify djus ds fy, gj Student dk ,d Serial Number gksrk gSA
Data dks Fields, Records o Files ds :i esa vPNh rjg Organized djus ds ckn Hkh Data dks
Maintain o Process djuk dkQh tfVy gksrk gSA bl otg ls Data dks vkSj vf/kd tfVy Structure esa
Organize fd;k tkrk gSA fdlh Hkh Data Structure dks le>rs le; gesa fuEu ckrksa ij /;ku nsuk gksrk
gS&
1
2
3
4
Structure dh Logical ;k Mathematical Description

Structure dh Computer ij Processing
Structure dk Analysis ftlds vk/kkj ij ;s r; fd;k tkrk gS fd dksbZ Data Structure
Memory esa fdruh Space ysxk vkSj Data dks Process djus esa fdruk le; yxsxkA
Memory esa lwpuk,a fdl izdkj ls laxfBr gks dj jgsaxhA
fdlh Hkh Program dh lkFkZdrk lwpukvksa ds laxBu ds vk/kkj ij fuHkZj gksrh gSA izksxzke dh ;ksX;rk bl ckr
ij fuHkZj djrh gS] fd Data Memory esa fdl izdkj ls laxfBr ( Organized ) gSa o mudk vkil esa D;k
lEca/k gSA ;fn Data lgh izdkj ls Memory esa laxfBr uk gksa] rks izkx
s zke ds Execution esa vf/kd le;
yxrk gSA vr% fdlh Hkh izksxzke ds Fast Execution ds fy;s mfpr Data Structure dk p;u cgqr gh
t:jh gSA Data dk og lewg] tks Memory esa de ls de LFkku ysrk gks vkSj lkeqfgd :i ls vkil esa
lEcaf/kr gksa rFkk izksxzke es Fast Execution esa lg;ksx djrs gks]a Data Structure dgykrs gaSA Data
Structure okLro esa Program cukrs le; viuk, tkus okys fofHkUu rjhdksa esa ls lcls ljy o vPNk
rjhdk mi;ksx esa ysuk gksrk gSA ;s mi;ksx esa fy;s tkus okys rjhds ij fuHkZj djrk gS fd gekjk Program o
ml Program ds Data Memory esa fdruk Space yssaxsA tSls fd ge ,d Array esa <sj lkjs Data j[k
ldrs gSa] ysfdu ;fn Array dh Size vf/kd j[kh tk,] rks Array }kjk Qkyrw esa gh Memory dk nq:i;ksx
gksrk gSA bl Array ds LFkku ij ;fn Dynamic Memory Allocation dk iz;ksx fd;k tk,] rks ;s mruh gh
Memory Use djrk gS] ftruh t:jr gksrh gSA bl izdkj ls Data] Array ds ctk; Dynamic Memory
Allocation ls Memory esa vf/kd vPNh rjg ls Organized jgrs gSaA blfy;s Dynamic Memory
Allocation ,d vf/kd vPNk Data Structure ;k Data ds lkFk izf;k djus dk ek/;e gSA
dksbZ Hkh Data Structure Data lnL;ksa ds chp Relationship Hkh iznfkZr djrk gSA tSls fd ,d
Telephone Directory esa mu lHkh O;fDr;ksa ds uke] irs o Phone Number fy[ks gksrs gSa] ftuds ikl
Phone gSA ;s lHkh ,d e esa gksrs gSaA ;s e Data Structure gS vkSj lHkh Phone Numbers dks mlds
ekfyd ds uke o irs ds lkFk fy[kk tkrk gS] ftlls fdlh Hkh Phone Number ls ml Phone ds ekfyd
dk uke irk vkfn tkuk tk ldrk gSA bl izdkj ls lHkh Phone Numbers dk mlds ekfyd ls lEca/k gSA
blfy;s ge dg ldrs gSa fd Data Structure ds lnL; vkil esa Related gksrs gSaA fdlh Hkh Program dks
nks dlkSfV;ksa ij vPNk ;k cqjk dgk tk ldrk gS% Program ds Execution }kjk fy;k tkus okyk le; vkSj
Program }kjk Memory esa fy;k tkus okyk LFkkuA ;fn Program Execute gksus esa dkQh le; yxkrk gS]
rks Program dks vPNk ugha dgk tk ldrkA lkFk gh ;fn Program Memory esa dkQh vf/kd LFkku ysrk
gS] rks ;s Program dh deh gSA ,d vPNk Program Memory esa de ls de LFkku ysrk gS vkSj de ls
de le; esa vPNk ls vPNk ifj.kke iznku djrk gSA ge ,d mfpr Data Structure dk iz;ksx djds ;kuh
,d ljy o mfpr rjhdk viuk dj ;s nksuksa t:jrsa iwjh dj ldrs gSaA
Data Structures
Data dks Organize djus ds dbZ rjhds gks ldrs gSaA Data dks Organize djus ds Logical ;k
Mathematical Model dks Data Structure dgk tk ldrk gSA ge fdl Data Structure dks Choose
djsa ;s ckr nks rF;ksa ij fuHkZj djrh gS%

1 Structure bruk l{ke gksuk pkfg, fd og mlh rjg ls Logically Data ds fofHkUu Elements ds
chp Relationship iznfkZr dj lds ftl rjg ls okLrfod thou esa fofHkUu Data Items vkil esa
Related gksrs gSaA
2 Data Structure bruk ljy gksuk pkfg, fd dksbZ Hkh Programmer fdlh Hkh Computer
Language esa Coding fy[k dj Data dks vklkuh ls Process dj ldsA
Linear Data Structure

tc fdlh Data Structure ds lHkh Items ,d Continuous Memory Locations ij miyC/k gksa] rks bls
Linear Data Structure ;k Linear List dgrs gSaA tSls fd ,d Array ds lHkh Elements yxkrkj
Memory Locations ij miyC/k jgrs gSaA fofHkUu Memory Locations ij miyC/k fofHkUu Data Items ds
chp Relationship Represent djus dk ,d rjhdk ;s gS fd ge Array dk iz;ksx djsAa Array ,d Linear
Data Structure gSA nwljs rjhds esa fofHkUu Data Items ds chp ds Relation dks ,d Linked List ds :i
esa Represent fd;k tkrk gSA bl rjhds ds Data Structure esa ge Linked Lists dk iz;ksx djrs gSaA
Non-Linear Data Structure
tc fdlh Data Structure esa lHkh bdkbZ;ka ,d Continues Memory Locations ij miyC/k uk gks]a rks ;s
,d Non-Linear Data Structure dgykrk gSA NonLinear Data Structures ds :i esa ge Trees o
Graphs dk iz;ksx djrs gSaA fdlh Hkh Data Structure ij ge fuEu f;k,a dj ldrs gSa&
//================================================================
1
2
3
4
5
6
ubZ bdkbZ tksMukA

fdlh bdkbZ dks Delete djukA
Processing ds fy;s gj bdkbZ ij Move djukA
fdlh eku dks lHkh bdkbZ;ksa esa [kkstukA
bdkbZ;ksa dh Sorting djukA
nks Structures dks tksM dj ,d Structure cukukA
//================================================================
tc ge fdlh Data Structure dks Choose djrs gSa rc fdlh Data Item ds lkFk fdl izdkj ls izf;k
djuh gS] ;s rF; ml Data Structure ij fuHkZj djrk gS fd geus fdl izdkj dk Data Structure
Choose fd;k gSA Array ,d lcls ljy Data Structure gS ftl ij fofHkUu izdkj ds Operations djuk
dkQh vklku gksrk gSA Array dk iz;ksx rc fd;k tkrk gS tc Data ds Permanent Collection ij
fofHkUu Operations djus gksrs gSaA D;ksafd Array dh Size ,d gh ckj esa Set djuh iMrh gS blfy, blesa
tks Hkh Data gksrs gSa os Permanent gksrs gSaA ysfdu tc Data Structure dh Size Changeable gksrh gS
rc ge Array ds LFkku ij Linked List dk iz;ksx djrs gSaA
Algorithm : Time Space Tradeoff and Complexity

fdlh leL;k ds lek/kku dks izkIr djus ds fy, fofHkUu Steps dh ,d Well Defined List dks Algorithm
dgrs gSaA Data dks Efficiently Process djus ds fy, ,d Efficient Algorithm dh vko;drk gksrh gSA
dksbZ Algorithm fdruk Efficient gS ;kuh fdlh leL;k ds lek/kku ds fy, Algorithm fdl rjg fy[kk
x;k gS vkSj Algorithm esa fy[ks x, Steps fdruh Efficiently Data dh Processing djrs gSa] bls nks rF;ksa
Time o Space ds vk/kkj ij r; fd;k tkrk gSA
gj Algorithm esa Data ij fofHkUu rjhds ls Processing dh tkrh gSA blfy, ge gesakk Data dks
Process djus ds fy, lcls Efficient Algorithm dks Use ugha dj ldrsA dksbZ Algorithm fdruk
Efficiently Data ij Processing djsxk ;s ckr dqN vU; rF;ksa ij Hkh fuHkZj djrh gSA tSlsfd ge fdl
izdkj ds Data ij Processing dj jgs gSa vkSj Data ij fofHkUu Operations djus ds fy, fdrus Steps
ysus iMrs gSaA
Time Space Tradeoff Use fd, tk jgs Data Structure ij fuHkZj djrk gSA ;kuh ;fn ge Data dks
Store djus ds fy, Space c<k nsa rks Data dh Processing esa yxus okyk le; de gks tkrk gS vkSj
;fn Data dks Store djus ds fy, Use gksus okys Space dks de dj nsa] rks Data dh Processing esa
yxus okyk le; c< tkrk gSA Time Space Tradeoff dks le>us ds fy, ge ,d mnkgj.k ysrs gSaA
ekuyks fd ,d File esa fofHkUu Students dh Information gSaA File dks Name Wise Sort djds vkSj
Binary Searching Algorithm dks Use djds ge cgqr Efficient rjhds ls bl File esa ls fdlh foksk uke
ds Record dks izkIr ldrs gSaA ysfdu ;fn gesa fdlh Student dk Serial Number fn;k x;k gks vkSj gesa
ml Serial Number okys Student ds Record dks Search djuk gks rks ge Binary Searching rjhds
dks Use djds Record dks ugha [kkst ldrs gSaA D;ksfa d Binary Searching Algorithm dks Use djus ds
fy, gesa Sorted Records dh t:jr gksrh gS vkSj fdlh File ds fofHkUu Records dks ;k rks Name Wise
Sort djds j[k ldrs gSa ;k Serial Number ds vuqlkjA ge Name o SR_No nksuksa dks ,d lkFk Sort
djds ugha j[k ldrsA blfy, ;fn gesa SR_No ds vuqlkj fdlh Record dks [kkstuk gks rks gesa File ds
gj Record dks fdlh veqd SR_No ds fy, Check djuk gksxkA ;fn Search dh tkus okyh File esa
dkQh vf/kd Records gksa rks bl rjg dh Searching esa cgqr Time yxsxkA bl leL;k dk ,d lek/kku
;s gks ldrk gS fd ge ,d vkSj File cuk, vkSj mls Serial Number Wise Sort djds j[ksAa ysfdu ,lk
djus ij leku izdkj ds Data dh nks File cu tk,axh ftlls Memory esa nqxquk Space Use gksxkA
blfy, bl rjhds dks Hkh ,d Efficient rjhdk ugha dgk tk ldrkA bl leL;k ds lek/kku ds :i esa ge
,d rjhdk vkSj viuk ldrs gSaA ge Main File dks SR_No Number ds vuqlkj Sort dj nsrs gSa vkSj ,d
vkSj Array ysrs gSa vkSj mlesa dsoy nks Columns ,d uke ds fy, o nwljk Pointer ds fy, ysrs gSaA bl
Array dks Name Wise Sort dj ysrs gSaA bl Array ds gj SR_No dk ,d Pointer Main File ds fdlh
Record dks Point djrk gSA bl rjhds esa gkykafd nwljs Array ds fy, Extra Space Use gks jgk gS
ysfdu fQj Hkh bl Array esa dsoy nks Fields gSa] blfy, bl rjhds esa de ls de Space Use gksxkA bl
rjhds ds Algorithm dks ge ,d Efficient Algorithm dg ldrs gSaA
fdlh Algorithm dh Complexity ,d Function gksrk gS tks fdlh Input Data ds vk/kkj ij Data dh
Processing esa yxus okyk le; ;k Space ;k nksuksa dks nkkZrk gSA ;kuh fdlh Algorithm dks Execute
gksus esa fdruk le; yxsxk vkSj og Algorithm Memory esa fdruk Space ysxk] bu nksuksa ;k nksuksa esa ls
fdlh ,d ckr dks nkkZus ds fy, ge ftl Function dks Use djrs gSa] og Function crkrk gS fd dksbZ
Algorithm fdruk Complex gS vkSj fdrus le; esa fdlh Data dh Processing djsxk rFkk Data dh
Processing ds fy, fdruk Space Use djsxkA bu Functions }kjk ge Mathematically ;s tku ldrs
gSa fd dksbZ Algorithm fdlh vU; Algorithm dh rqyuk esa fdruk Efficient gSA
Computer Science esa Algorithms dks Analyze djuk ,d cgqr gh cMk o tfVy dke gSA fdUgh
Algorithms dh rqyuk djus ds fy, gekjs ikl dqN Criteria gksuk cgqr t:jh gksrk gS] ftlls ge irk yxk
ldsa fd dksbZ Algorithm fdruk Efficient gSA ;fn fdlh Data Structure esa n Data gksa rks Algorithm M
ds Input Data dh Size n gksrh gSA Input Data dh Size fdlh Hkh Algorithm dk igyk Criteria gksrk
gSA ge fdlh Algorithm ls fdl izdkj ds Steps dk iz;ksx djds Data Process djrs gSa] mu Steps dh
la[;k fdlh Algorithm dh Efficiency Kkr djus dk nwljk Criteria gksrk gSA ;kuh dksbZ Algorithm
fdruk Efficient gS] ;s Input Data o Data dks Process djus ds fy, Use fd, tkus okys Steps dh
la[;k ;kuh Comparisons ij fuHkZj djrk gSA
dksbZ Algorithm fdlh leL;k dk lek/kku iznku djus ds fy, fdrus le; o Space dk mi;ksx djrk gS]
bu nksuksa rF;ksa ds vk/kkj ij ml Algorithm dh Efficiency dk irk pyrk gSA ekuyks fd M ,d
Algorithm gS vkSj mlds Input Data dh Size n gSA fdlh Searching ;k Sorting ds Algorithm esa
ftrus Operations ds ckn Data Process gksrk gS] mu Operations dh la[;k ds vk/kkj ij Algorithm
ds Time dk irk pyrk gSA tSls ekuyks fd ,d File esa 1000 Records gSa vkSj mu esa ls fdlh foksk uke
ds Record dks izkIr djuk gS] rks Algorithm dks okafNr Record izkIr djus ds fy, vf/kdre 1000
Comparisons djus iM ldrs gSaA bu vf/kdre 1000 Comparisons esa yxus okys le; dks Algorithm
}kjk Use fd;k tkus okyk le; dgrs gSa vkSj bu 1000 Comparisons esa Algorithm ftruh Memory dks
Use djrk gS] og Memory fdlh Algorithm }kjk Use dh tkus okyh Space gksrh gSA
fdlh Algorithm M dh Complexity Kkr djus ds fy, ,d Function f(n) dk iz;ksx fd;k tkrk gSA ;s
Function fdlh Algorithm dh Complexity iznku djrk gS tgka n Input Data dh Size gSA mnkgj.k ds
fy, fdlh File esa dsoy 1 Record gS rks ml Record ls fdlh uke ds Record dks Search djus ij
Algorithm dh Complexity de gksxh tcfd mlh File esa ;fn 100 Record gksa rks Use gksus okys
Algorithm dh Complexity vf/kd gksxhA ;fn okafNr Record iwjh File esa dgha izkIr uk gks rks Algorithm
dh Complexity vuUr gksxhA ekuyks fd tks Record Search fd;k tk jgk gS og File esa igys LFkku ij
gh miyC/k gks rks Algorithm dh Complexity fcYdqy de gksxh vkSj Algorithm dks Best Case
Algorithm dgk tk,xkA ;fn Search fd;k tkus okyk Record File ds e/; esa gks rks Algorithm dks
Average Case Algorithm dgk tk,xk vkSj ;fn tks Record Search fd;k tk jgk gS og Record iwjh
File esa dgha uk gks rks ,ls Algorithm dks Worst Case Algorithm dgk tkrk gSA
fdlh Worst Case Algorithm esa Record dks Search djus ds fy, mruh ckj Comparison dk
Operations djuk iMrk gS] ftrus File esa Records gSaA ekuyks fd File esa 100 Record gSa rks Algorithm
dks 100 ckj Comparison djuk iM ldrk gSA bls ge Mathematically fuEukuqlkj iznfkZr dj ldrs
gSa&
C(n) = n
tgka C = Comparisons dh la[;k gS vkSj n = Input Data dh Size gSA fdlh Linear Search
Algorithm dh Worst Case Complexity esa C(n) = n gksrh gSA
Average Case Algorithm esa fdlh Data ds gj Location ij feyus dh lEHkkouk 1/n gksrh gS tgka n
Data Items dh la[;k gSA ;kuh ;fn fdlh Data Structure esa n Data Items gksa rks Data 1 ls ysdj n
rd esa fdlh Hkh LFkku ij gks ldrk gSA blfy, fdlh Data Item dks fdlh List esa [kkstus ds fy,
Algorithm dks dqy n Comparisons djus iM ldrs gSaA bls ge fuEukuqlkj Mathematically nkkZ ldrs
gSa&
//================================================================
C(n) = 1 X 1/n + 2 X 1/n + ... n X 1/n
= ( 1 + 2 + ... + n ) X 1/n
= n( n + 1 )/2 X 1/n
= n + 1/2
//================================================================
bl Probability Equation ls ge ns[k ldrs gSa fd fdlh Data ds List esa feyus dh lEHkkouk yxHkx n/2
gksrh gS tgka n List ds dqy Data Items dh la[;k gSA
Algorithms
fdlh leL;k dk lek/kku Computer }kjk izkIr djus ds fy, gesa ,d foksk e esa fofHkUu Steps Use
djus gksrs gSaA Steps dh ,d Well Defined List ftlds vk/kkj ij fdlh Hkh Computer Language esa
Program Create djds fdlh Problem dks vPNh rjhds ls Solve fd;k tk lds] Algorithm dgykrk
gSA nwljs kCnksa esa dgsa rks ge dg ldrs gSa fd fdlh leL;k ds lek/kku ds fy, ftu Steps dks Use fd;k
tkrk gS] mu Steps dks ;fn ,d fufpr e esa ljy Hkkkk esa fy[k fy;k tk,] rks bu Steps dh List dks
Algorithm dgk tk ldrk gSA Algorithm dk gj Step ;s crkrk gS fd dc vkSj fdl dke ds ckn D;k
dke gks jgk gSA Algorithm fdlh Problem ds Solution dk ,d Specification gksrk gS ftlds vk/kkj ij
fdlh leL;k dks Solve fd;k tkrk gSA
fdlh Algorithm dks lhfer Instructions dh ,d Sequence ds :i esa ns[kk tk ldrk gS ftlesa fuEUk
xq.k gksrs gSa&
1 Algorithm kq: gksus ls igys mls dqN Initial eku iznku fd, tkrs gSaA bu ekuksa dks Input dgk
tkrk gS vkSj bUgha Input ij dksbZ Algorithm Processing djrk gSA
2 Algorithm ds fofHkUu Steps brus ljy o le>us ;ksX; gksrs gSa fd ml Algorithm dk iz;ksx djds
ge fdlh Hkh Computer Language esa ml Algorithm ds vk/kkj ij Program Create djds
fdlh leL;k dk lek/kku izkIr dj ldrs gSaA
3 Algorithm dk gj Step bruk Clear gksuk pkfg, fd dksbZ Hkh O;fDr ml Algorithm ds vk/kkj ij
,d lhfer le; esa ml leL;k dk lek/kku izkIr dj ys ftlds fy, Algorithm dks fy[kk x;k gSA
4 fdlh Algorithm }kjk fdlh leL;k ds lek/kku ds fy, fy[ks x, lHkh Steps ,d lhfer le; esa
iwjs gksus pkfg,A dbZ ckj fdlh leL;k ds lek/kku ds fy, Repetitive Steps Use fd, tkrs gSaA ;s
Steps ,ls gksus pkfg,a fd lhfer le; esa leL;k dk lek/kku iznku dj ldsa ;kuh Loop Infinite
ugha gksuk pkfg,A
5 ,d Algorithm dk de ls de ,d ;k ,d ls vf/kd Output gksuk pkfg,A Steps dk dksbZ Hkh ,lk
lewg tks fdlh izdkj dk dksbZ Result Provide uk djrk gks] mls Algorithm ugha dgk tk ldrkA
Analysis of Algorithm
tc Hkh ge dksbZ Algorithm fy[krs gSa rks ;s t:jh gks tkrk gS fd ge ;s Analyze djsa fd gekjs }kjk fy[kk
x;k Algorithm fdruk Efficient gSA Algorithm ds Analysis dk igyk rjhdk ;s gS fd ge ;s Check djsa
fd Algorithm lgh fy[kk x;k gS ;k ughaA blds fy, gesa fuEu dke djus gksrs gSa&
1 Algorithm dh Tracing djukA ;kuh Algorithm ds gj Step dks Check djuk fd tks dke tgka
gksuk pkfg, og ogha gks jgk gS ;k ughaA
2 Algorithm dh Reading djukA ;kuh ;s irk yxkuk fd Algorithm Logically Correct gS ;k
ughaA
3 Algorithm dh Implementing o Testing djukA ;kuh Algorithm ds vk/kkj ij fdlh Hkh
Programming Language esa Program cukuk rFkk Check djuk fd Program lgh Output
iznku dj jgk gS ;k ughaA ;k fQj Mathematical Techniques }kjk Algorithm dh Correctness
dks Prove djukA
Algorithm ds Analysis dk nwljk rjhdk ;s gS ge Algorithm dks Simplest Form esa Create djsAa ;fn
Algorithm dks Simplest Form esa fy[kk x;k gks rks mls Implement djuk ;kuh mlds vk/kkj ij
Program Create djuk o ml Algorithm ij vU; izdkj ds Analysis djuk ljy gksrk gSA fQj Hkh fdlh
leL;k dks Solve djus ds fy, Use fd;k tkus okyk ljy o lkQ&lqFkjk rjhdk dbZ ckj dqN T;knk vPNk
rjhdk ugha gksrk gSA ,lk rc gksrk gS tc Use fd;k tkus okyk ljy o lkQ&lqFkjk rjhdk ;k rks dkQh
vf/kd Memory dk mi;ksx djrk gks ;k Solution iznku djus esa dkQh T;knk le; yxkrk gksA bl fLFkfr
esa ;s t:jh gksrk gS fd ;s Analyze fd;k tk, fd tks Algorithm fdlh leL;k ds lek/kku ds fy, fy[kk
x;k gS og de ls de fdruk Time o Space Use djrk gSA mnkgj.k ds fy,] ;fn fdlh Company esa
120 Employees gSa vkSj gj Employee ds Record dks Memory esa Load gksus esa 3 feuV yxrs gSa rks
bl Algorithm dks Use ugha fd;k tk ldrk D;ksafd ;fn fdlh fnu Company ds lHkh Employees dks
Access djuk gqvk] rks lHkh Employees ds Records dks Memory esa Load gksus esa gh 4 ?k.Vs yx
tk,axs] fQj gj Record dh Processing esa rks vkSj Hkh vf/kd le; yxsxkA blfy, dksbZ Algorithm
fdruk vPNk gS bls Time o Space ds vk/kkj ij gh ukik tk ldrk gSA
Rate of Growth
dksbZ Algorithm Perform gksus esa fdrus le; dk mi;ksx djsxk ;s Analyze djus dk dksbZ lk/kkj.k rjhdk
ugha gSA fdlh Hkh Algorithm ds Time Requirement dks izHkkfor djus okyh lcls igyh Complexity rks
;s gS fd dksbZ Algorithm fdl Computer ij Perform gks jgk gS] ml Computer ij gh Algorithm ds
Perform gksus dk Time fuHkZj gksxkA ekuyks ;fn ge ,d gh Algorithm dks Pentium III Processor okys
CPU ij Execute djrs gSa vkSj mlh Algorithm dks Pentium IV ds Processor ij Execute djs]a rks
nksuksa Computer ij Algorithm ds Perform gksus ds le; esa vUrj jgsxkA ;kuh lcls igys rks dksbZ Hkh
Algorithm fdruk le; ysxk ;s ml Computer dh Speed ij fuHkZj djrk gS ftl ij Algorithm dks
Use fd;k tk jgk gSA
Algorithm ds Perform gksus ds Time dks izHkkfor djus okyh nwljh Complexity Input Data Items dh
la[;k ij fuHkZj djrh gSA mnkgj.k ds fy, ;fn fdlh Array esa 100 Data Elements dks tksMuk gks rks de
le; yxsxk tcfd ;fn Array esa 10000 Data Elements gks]a rks mu lHkh dh tksM djus esa 100 Data dh
rqyuk esa vf/kd le; yxsxkA ifj.kkeLo:i dksbZ Algorithm Perform gksus esa vuqekur% fdruk le; ysxk]
bls Input Data Size ds Qyu ds :i esa Express fd;k tk ldrk gSA mnkgj.k ds fy, ;fn fdlh Array
esa Data Items dh la[;k n gks rks Algorithm }kjk n Data dh Processing esa yxus okys le; dks Time
T(n) o Space S(n) ds Qyu ds :i esa Express fd;k tk ldrk gS] tgka T o S Input Data n ds
Qyu gSaA
blls igys fd ge fdlh Algorithm dks Analyze djds mldh Efficiency Kkr djs]a dqN Functions dks
le>uk Bhd jgsxk] ftudk iz;ksx T o S dks Express djus ds fy, fd;k tkrk gSA ;s dqN Standard
Functions gSa tks Input Data Item n dh Size ds vk/kkj ij Algorithm }kjk fy;k tkus okyk le; Kkr
djus ds fy, Use fd, tkrs gSaA mnkgj.k ds fy, eku yks fd fdlh Array esa 16 Data Items gSaA bu 16
Data Items dks vyx&vyx rjg ls vyx&vyx dkeksa ds fy, Process djus ds fy, vyx&vyx
Algorithms dh t:jr gksrh gSA ;fn bu 16 Items ij Processing djus ds fy, ge f(n) = 2n Qyu dk
iz;ksx djsa rks gesa Array ds 16 Elements dks Process djus ds fy, de ls de 216 Operations djus
iMsaxs] ;kuh gesa dqy 65536 Operations djus gksaxsA ;fn bl Qyu dk Graph cuk;k tk,] rks cuus okyk
Graph dkQh rsth ls c<sxkA ;kuh bl Qyus ds c<us dh nj lcls rst gksrh gSA ;s Qyu fdlh Hkh
Algorithm dh Complexity Kkr djus dk lcls igyk Qyu gS tks fdlh Algorithm ds Perform gksus esa
Algorithm }kjk fy, tkus okys lcls vf/kd le; dks nkkZrk gSA ;fn bl Qyu ds LFkku ij Algorithm
f(n) = n3 Qyu dk iz;ksx djs] rks dqy Operations dh la[;k 163 gksxhA ;fn bl Qyu dk Hkh xzkQ
cuk;k tk, rks ;s xzkQ Hkh dkQh rsth ls c<sxk ysfdu fQj Hkh ;s Graph igys okys Qyu dh rqyuk esa de
rsth ls c<sxkA fdlh Algorithm dh Complexity Kkr djus ds fy, Use fd;k tkus okyk rhljk Qyu
f(n) = n2 gSA ;fn blh 16 Element okys Array ds 16 Data dks Process djus ds fy, ;fn n2
Operations djus iMs rks] Algorithm dks dqy 256 Operation djus gksaxsA ;fn bl Qyu ds Growth dk
Graph cuk;k tk, rks ;s Graph Hkh dkQh rsth ls c<sxk ysfdu igys okys nksuksa Qyuksa dh rqyuk esa dkQh
de rsth ls c<sxkA ;fn Algorithm Perform gksus ds fy, f(n) = n log2 n Operations djrk gS rks bl
Qyu dk Growth Rate igys crk, x, lHkh Qyuksa ls de gksxkA ;kuh ;fn bl Qyu dk Graph cuk;k
tk, rks Graph dkQh /kheh xfr ls c<sxkA ;fn 16 Data Element ds Array ij Processing ds fy, n
log2 n Operations djus iMsa rks dqy Operations dh la[;k 16 X log2 16 = 16 X 4 = 64 gksxh tks fd
igys ds lHkh Qyuksa dh rqyuk esa dkQh de gSA ;fn tks Algorithm Use fd;k tk jgk gS og Algorithm
16 Elements dks Process djus esa dsoy 16 gh Operations djs] rks Algorithm dh Complexity f(n)
= n gksrh gSA ;fn bldk Graph cuk;k tk,] rks ,d Linear Graph curk gS tks fd Data Elements n
dh la[;k c<us ds lkFk c<rk gS vkSj ?kVus ds lkFk ?kVrk gSA fdlh Algorithm dh Complexity Kkr djus
dk vfUre Qyu f(n) = log2 n gS ftlesa 16 Item dks Process djus esa dsoy 4 Operations djus gksaxsA
;fn bu lHkh Qyuksa dk Graph cuk;k tk, rks ;s Graph e ls vf/kd Complex Algorithm dks nkkZ,axsA
bl Graph dks fdlh Algorithm dh Complexity dk Rate of Growth dgk tkrk gSA
dksbZ Algorithm Perform gksus ds le; fdl Qyu ds vuqlkj Operations djrk gS] blds vk/kkj ij
Algorithm dh Complexity fuHkZj djrh gSA ,d gh dke dks djus ds fy, fofHkUu rjhds gks ldrs gSaA tks
rjhdk de ls de Operations esa gesa gekjk Required Result iznku dj nsrk gS og Algorithm de
Complex vkSj vf/kd Efficient dgykrk gS tcfd blds foijhr gksus ij Algorithm vf/kd Complex o
de Efficient dgykrk gSA Algorithm dh Growth fuEu e esa gksrh gS&
log2 n
n log2 n
n2
n3
2n
fdlh Hkh Algorithm dks Analyze djds ;s irk fd;k tkrk gS fd Algorithm dh Complexity fdl Qyu
ds vuqlkj Grow gks jgh gSA gesa ;gh dksfkk djuh pkfg, fd fdlh Hkh Algorithm dh Complexity
Linear e esa c<sA ,lk Algorithm dkQh Efficient gksrk gS ftldk Graph Linearly c<rk gSA
Time Analysis
fuEu Algorithm }kjk fdlh Array ds N Elements dk TkksM fd;k tk ldrk gS&
//==================================================================
SUMMETION(LA, N)
Here LA is a Linear Array and N is the size of LA.
1 SUM = 0, LB = 0, UB = N-1
[
Initialization ]
2 REPEATE STEP 3 WHILE I <= UB STEP I = I + 1
3 SUM = SUM + LA[I]
[ Sum the Values of Arrays All Elements ]
4 EXIT
[ Finish ]
//==================================================================
tSlkfd geus igys crk;k fd fdlh Hkh Algorithm dks Perform gksus esa fdruk le; yxsxk ;s Kkr djuk
dkQh eqfdy gSA blfy, ge Algorithm dh Complexity dks Data Items dh Size ds Qyu ds :i esa gh
Kkr dj ldrs gSaA Algorithm ds Time dks ge fdlh Algorithm }kjk Perform gksus okyh Comparisons
la[;k ds vk/kkj ij Kkr djrs gSaA dksbZ Algorithm Perform gksrs le; dqy fdrus Operations djrk gS]
mUgha Operations dh la[;k dks ge Algorithm ds Perform gksus ds Time ds :i esa eku ysrs gSaA ;kuh
ftrus vf/kd Operations Algorithm }kjk Perform gksrs gSa ml Algorithm dks Perform gksus esa mruk gh
vf/kd le; yxrk gSA Time Algorithm esa ekuyks fd Data Item dh la[;k n = 10 gS rks nlksa la[;kvksa
dks tksMus ds fy, bl Algorithm esa dqy 10 Operations gksrs gSaA bl fLFkfr esa bl Algorithm dks
Perform gksus esa dqy 10 Operation djus iMrs gSa rks bl Algorithm dh Complexity dk Qyu f(n) = n
gksxkA ;kuh bl Algorithm dks Perform gksus esa ;fn Data Item dh la[;k N gS rks dqy Operation dh
la[;k Hkh N gksxh vkSj gj Operation esa 1/N le; yxrk gS vr% dqy le; Hkh N gh yxsxkA ekuyks fd
;fn Array ds izFke Element dks nwljs Element ls tksMus esa ,d lsd.M yxrk gS rks Data Item dh
la[;k 10 gksus ij dqy nl ckj tksM gksxh vkSj yxus okyk le; 10 lsd.M gksxkA
Complexity ( Big O Notation )

nks Algorithms esa ls dkSulk Algorithm vf/kd Efficient gS ;s Analyze djus ds fy, gesa nksuksa
Algorithms ls izkIr gksus okys Results dks Compare djuk gksrk gSA ge nks Algorithms ls izkIr gksus
okys Results dks Compare dj ldsa blds fy, gesa O Notation dks tkuuk t:jh gSA
dksbZ Algorithm fdrus Operations djus ds ckn Required dke dks iwjk djrk gS] ;s tkuus ds fy, ge
dqN Standard Function dk iz;ksx djrs gSa tks fd fuEukuqlkj gSa&
log2 n
n log2 n
n2
n3
2n
;s lHkh Functions Qyu fdlh Algorithm dk vk;ke Kkr djus ds fy, Use gksrs gSaA ;kuh n2 ls n3
dk vk;ke vf/kd gksrk gSA ;fn dksbZ ,d Algorithm n2 Operations ds ckn gesa Required Results iznku
djrk gS tcfd nwljk Algorithm n3 Operations ds ckn gesa Required Result Provide djrk gS] rks igys
okys Algorithm ls nwljk okyk Algorithm vf/kd Complex gksxkA ;s lHkh Function ,d fufpr e ds
vuqlkj Input Data n ds fy, vk;ke iznku djrs gSaA fofHkUu Functions tks vk;ke iznfkZr djrs gSa mu
lHkh vk;ke iznfkZr djus okys Functions dks Handle djus ds fy, ,d Notation dks Develop fd;k
x;k gSA ,d Function f(n) dks O(g(n)) ds :i esa ifjHkkfkr fd;k tk ldrk gSA ;kuh bls f(n) = O(g(n))
fy[k ldrs gSa vkSj bl Qyu dks g(n) dk e dgk tkrk gSA ;kuh ;fn fuEukuqlkj n0 o c Positive
Constant gks&
a
| f(n) | <= | g(n) | tcfd lHkh n > n0
rks ge bls O Notation ds vuqlkj fy[k ldrs gSaA tSls fuEu Qyuksa dk O Notation fuEukuqlkj fy[kk
tk ldrk gS&
100 n5
200n3 + 50n2 + 20n1 + 544n0
1 + 2 + . . . + (n-1) + n = n(n+1)/2 = n2 + O(n)
3223
dk O Notation O(n5) gksxkA

dk O Notation O(1) ;k O(n) gksxkA
ljy kCnksa esa dgsa rks ge dg ldrs gSa fd O(g) Qyuksa (Functions) dk ,d ,lk lewg gksrk gS tks fd g
ds vk/kkj ij Increase ;k Grow gksrk gS tgka Qyu g Qyu O(g) dk Upper Bound gSA ge O(g) ds
fofHkUu Qyuksa ds vk/kkj ij fofHkUu Algorithms dh Complexity Kkr dj ldrs gSa vkSj nks vyx&vyx
Algorithms dh Efficiency dh vkil esa rqyuk djds irk yxk ldrs gSa fd dkSulk Algorithm vf/kd
Efficient ;k de Complex gSA ;s Qyu Computer ;k Programming Language ij fuHkZj ugha gksrs gSa
blfy, fdlh Algorithm dks fcuk Implement fd, gq, ;kuh Algorithm ds vk/kkj ij fcuk Program
cuk, gq, gh bu Qyuksa }kjk ge ;s tku ldrs gSa fd dksbZ Algorithm fdruk Complex gSA
Properties of O Notation
fdlh Hkh O Notation dh dqN General fokskrk,a gksrh gSa ftUgsa ge fuEukuqlkj le> ldrs gSa&
1 fdlh Hkh Algorithm dks tc Mathematically Represent fd;k tkrk gS rks mlds ftrus Hkh
Constant Factors gksrs gSa mUgsa Ignore fd;k tk ldrk gSA mnkgj.k ds fy, ;fn fdlh Array esa
N Data Elements gSa vkSj dksbZ Algorithm Array ds lHkh Elements dks Process djrk gS
tcfd N dk eku 0 ls vf/kd gS rks bl Algorithm dh Complexity O(n) gksxhA ;kuh
For All N > 0 , N f is O(n)
mnkgj.k ds fy, xz2 o yn2 nksuksa dh Complexity leku gS vkSj nksuksa dks O Notation ds :i esa
O(n2) gh fy[ksaxsA
2 n dh Higher Power mPpre ?kkrkad Lower Power fuEu ?kkrkad ls vf/kd rsth ls
Grow gksrk gSA ;kuh
200n3 + 50n2 + 20n1 + 544n0
bl mnkgj.k esa ns[k ldrs gSa fd Qyu n0 Hkh gS vkSj n3 Hkh ysfdu bldk O Notation O(n3) gh
gS D;ksafd ;s mPpre ?kkrkad gS vkSj vU; lHkh ?kkrkadksa dh rqyuk esa bldk eku cgqr gh T;knk rsth
ls Grow gksxk vkSj ;s vU; ?kkrkadks dh rqyuk esa cgqr gh T;knk Operations dks Represent
djsxk] ftlls vU; ?kkrkadksa ds Operations dh la[;k dks Ignore fd;k tk ldrk gSA
3 dqy Operations ds ;ksx ds c<us dh nj ogh gksrh gS tks lcls vf/kd Growth Term dh gksrh gSA
;kuh ;fn fdlh Algorithm esa
an3 + bn4 + cn2 + dn1

Operations gksrs gSa rks bl Algorithm dh Complexity bn4 ds c<us dh nj ds cjkcj gksxhA ;kuh
bl Algorithm ds Operations dks O Notation ds :i esa ;fn fy[kk tk, rks O(n4) gh fy[kuk
gksxkA
4 ;fn Qyu f Qyu g dh rqyuk esa vf/kd rsth ls Grow gksrk gS vkSj Qyu g Qyu h dh rqyuk es
vf/kd rsth ls Grow gksrk gS rks Qyu f Qyu h dh rqyuk esa Hkh vf/kd rsth ls c<rk gSA
5 fdlh Qyu ds Upper Bound vf/kdre Operations dh la[;k dk fdlh vU; Qyu ls xq.kk
fd;k tkrk gS rks izkIr gksus okyk eku Upper Bound vf/kdre Operations dh la[;k dks
Represent djrk gSA tSls
IF f is O( g ) and h is O( r ) then fh is O( gr )
mnkgj.k ds fy,
IF f is O( n2 ) and h is O( log n ) then fh is O( n2 log n )
6 Exponential Qyu Power Qyu dh rqyuk esa vf/kd rsth ls c<rs gSaA tSls
nk is O(bn), tcfd b ds lkjs eku 1 ls cMs gksa vkSj k dk eku 0 ;k 0 ls cMk gksA ;kuh
nk is O(bn), For all b > 1 ; k >= 0
mnkgj.k ds fy,
n4 is O(2n), and n4 is O(exp(n))
7 Logarithms Powers dh rqyuk esa cgqr gh /kheh xfr ls c<rs gSaA tSls
Logb n is O(nk) for all b > 1 ; k > 0
mnkgj.k ds fy, log2 n is O(n0.5)

fdlh Algorithm dks Analyze djrs le; gekjs lkeus nks lcls cMh leL;k,a gksrh gSa%
CPU Time
CPU dh Speed eq[; :i ls Algorithm }kjk gh izHkkfor ugha gksrh gS cfYd dqN vU; rF; Hkh CPU dh
Speed dks izHkkfor djrs gSaA buesa ls dqN rF; fuEukuqlkj gSa&
1 ge tks Computer Use dj jgs gSa ml Computer ds CPU dh Actual Speed D;k gS vkSj ml
Computer ij fdruk Load gSA ftl Computer esa ftrus vf/kd Softwares Installed gksrs gSa]
Computer mruk gh vf/kd Loaded gksrk gSA
2 ge dkSulh Programming Language Use dj jgs gSa vkSj dkSulk Compiler Use dj jgs gSa bl
ij Hkh Algorithm ds Perform gksus dh Speed fuHkZj djrh gSA tSls ;fn ge ,ls Compiler dks
Use dj jgs gSa tks fd Directly Computer ds fofHkUu Hardware dks Access djus esa l{ke gS
rks Algorithm vf/kd rsth ls Perform gksxkA C ,d ,lh gh Language gS ftlesa ge
Computer ds fdlh Hkh Hardware dks Directly Access dj ldrs gSaA tcfd Visual Basic esa
;fn Algorithm dks Perform djus ds fy, Program fy[kk tk,xk rks ml Program dh Speed
C ds Program dh Speed ls de gksxhA
3 dqN vU; Factors Hkh gksrs gSa tks Algorithm dh Performance dks izHkkfor djrs gSaA tSls ;fn
Data Structure ds :i esa Array dks Use fd;k tkrk gS rks gesa gesa kk Algorithm esa ;s Check
djuk gksrk gS fd Array esa Data Insert djus ds fy, Space gS ;k ughaA ;kuh Array dh
Bounding dks Check djuk t:jh gksrk gS vU;Fkk Algorithm fdlh vU; Program ds Data dks
Corrupt dj ldrk gSA fdlh Array dh Indexing djus esa ;k fdlh Record dks Access djus
esa tks Extra le; yxrk gS og Algorithm dh Performance dks izHkkfor djrk gSA tc ge gekjs
Program esa cgqr ls Procedures ;kuh Functions Create djrs gSa] rks gj Function ds Call
gksus ij Program Control ,d LFkku ls nwljs LFkku ij Jump djrk gSA bl Jumping esa Hkh dqN
le; O;FkZ gksrk gSA ;s le; Hkh Algorithm ds Performance ij vlj djrk gSA
Input / Output
Constant Time ds Algorithms ifjHkkkk ds :i esa lHkh Input Data ij Processing ds fy, leku le;
ysrs gSaA ysfdu T;knkrj Algorithms Constant Time ugha gksrs gSaA ;kuh lHkh Data dh Processing esa
leku le; ugha ysrs gSaA bl fLFkfr esa ge ,d fufpr vad ds :i esa fdlh Algorithm dh Efficiency dks
ifjHkkfkr ugha dj ldrs gSaA blfy, gesa Algorithm dh Efficiency dks Input Data dh Size n ds Qyu
ds :i esa gh ifjHkkfkr djuk iMrk gSA
igyh leL;k dk lek/kku ;s gS fd gesa Algorithm dh Efficiency dks Analytically Measure djuk pkfg,
uk fd Experimentally, D;ksafd nks vyx Computer ij leku Algorithm Hkh vyx Time esa Perform
gksxkA vU; kCnksa esa dgsa rks gesa Algorithm dks mldh Efficiency o ml Algorithm dks izHkkfor djus okys
rRoksa ds vk/kkj ij ifjHkkfkr djuk gksrk gSA lkekU;r;k ge fdlh Algorithm dh Efficiency Kkr djus ds
fy, fuEu esa ls fdlh ,d dks Measure djrs gSa&
1 Numerical Algorithms ds fy, ge dqy Addition, Subtraction, Multiplication vkfn dh la[;k
Kkr djrs gSaA
2 Searching ;k Sorting ds Algorithm esa ge dqy Comparisons dh la[;k Kkr djrs gSaA
3 Assignment Statements o Parameters ds vk/kkj ij Data Movement dh dqy la[;k dks
Kkr djrs gSaA
4 fdlh Algorithm ds fy, Required dqy Memory Space dh Limit dks Kkr djrs gSaA
nwljh leL;k ds lek/kku ds fy, ge N Data Items ds fy, Algorithm dh Efficiency nkkZus okyk ,d
Qyu Kkr djrs gSa ftlls fdlh Algorithm dh Efficiency ;k Complexity dks Represent fd;k tkrk
gSA
fdlh Algorithm dh Complexity ;k Efficiency dks Kkr djrs le; gesa lcls igys ;s r; djuk gksrk gS
fd ge Input dh fdl Property dks Measure djus tk jgs gSaA fdlh Algorithm dh lcls vPNh
Property og gksrh gS tks Algorithm ds Efficiency Factor dks izHkkfor djrh gksA ge ;gka ij Algorithm
dh Key Property ds :i esa Input Size kCn dks Use djds Algorithm dks Analyze djsaxs vkSj Input
Size dks Variable N ls Represent djsx
a sA fQj Hkh ;s t:jh ugha gS fd ge dsoy ,d gh Property dk
iz;ksx djsAa ge fdlh Algorithm dh Efficiency dks dbZ Properties ds vk/kkj ij ,d Qyu ds :i esa
Express dj ldrs gSaA ysfdu dsoy ,d gh Property ds vk/kkj ij fdlh Algorithm dh Efficiency dks
Express djuk dkQh ljy rjhdk gksrk gS rFkk ,d gh Property dks lHkh Properties ds :i esa
Represent fd;k tk ldrk gSA blh rjhds dks lcls T;knk Use fd;k tkrk gSA
mnkgj.k ds fy, fdlh List ds fofHkUu Elements dks Sort djus ds fy, ftruk le; Use gksrk gS mls
List dh Length ds ,d Qyu ds :i esa fy[kk tk ldrk gSA Sorting ds fy, ge ftl Algorithm dk
iz;ksx djrs gSa og Typically ,d Quadratic Function gksrk gSA ;kuh
TIME(n) = n * n
MergeSort o QuickSort ds Algorithm vf/kd rst gksrs gSaA mudks Qyu ds :i esa fuEukuqlkj fy[kk tk
ldrk gS&
TIME(n) = n * log (n)
bl Algorithm dh Length Quadratic ls de ysfdu Linear ls vf/kd gksrh gSA

;s rjhdk vHkh Hkh nwljh leL;k dk tokc iznku ugha dj jgk gSA ekuyks ,d Algorithm fdlh List esa ls
fdlh Required eku dks Search dj jgk gSA ge ;s eku ysrs gSa fd tks Hkh eku Search fd;k tk jgk gS
og gesakk List esa miyC/k gksrk gSA ,lk dksbZ eku Search ugha fd;k tkrk tks fd List esa miyC/k gh uk
gksA bl fLFkfr esa Algorithm gesa kk Successful gksrk gSA vc bl Algorithm dh Speed dks izHkkfor djus
okyk Factor og LFkku gS tgka ij Search fd;k tkus okyk eku izkIr gksrk gSA ;fn Algorithm ogka ls kq:
gksrk gS tgka ij Search fd;k tkus okyk eku miyC/k gS rks Algorithm cgqr gh tYnh lekIr gks tk,xkA
tcfd ;fn Search fd;k tkus okyk eku List esa dgha vU; LFkku ij gS] rks Algorithm dks vU; LFkkuksa ij
Hkh Search fd, tkus okys eku dks [kkstuk gksxkA bl fLFkfr esa ge tks Qyu ;gka ij izkIr djuk pkgrs gSa
og iwjk ugha gSA ;s Qyu Input Size n ij fuHkZj gSA ;fn Search fd;k tkus okyk Data rqjUr izkIr gks
tkrk gS rks ;s Best Case fLFkfr gS ysfdu ;fn Search fd;k tkus okyk Data dkQh Comparisons ds
ckn izkIr gksrk gS] rks bls Worst Case fLFkfr dgsaxsA
gekjs bl Algorithm esa Best Case = Constant Time gksxk tcfd Worst Case = Length of List ;k N1 gksxkA Average Case esa Search fd;k tkus okyk Data List esa izFke o vfUre LFkku ds vykok dgha
Hkh izkIr gks ldrk gSA
vc tc ge nks Algorithms dks Compare djrs gSa rks gesa nks Algorithms ds Qyuksa dks Compare djuk
iMrk gSA bl Analysis esa gesa gesa kk lko/kku jguk gksrk gS D;ksafd ;s Qyu dbZ LFkkuksa ij ,d nwljs dks
Cross dj ldrs gSaA ;kuh fdlh ,d Input ds fy, igyk Algorithm mi;qDr yxrk gS tcfd fdlh nwljs
Input ds fy, igys ds LFkku ij nwljk Algorithm vf/kd mi;qDr yxrk gSA ;fn ,lk gksrk gS rks bldk
eryc gS fd nksuksa gh Algorithm lHkh Inputs ds fy, ,d nwljs ls vf/kd mi;qDr ;k Efficient ugha gSaA
nks Algorithms dh okLro esa mfpr Comparing djus ds fy, t:jh gS fd gekjs ikl nksuksa Algorithms ds
mfpr Qyu gksa vkSj ge ;s irk dj ldsa fd nksuksa Algorithm fdl Input ds fy, ,d nwljs dks Cross
djrs gSaA izk;ksfxd :i ls ;s irk djuk cgqr gh eqfdy dke gSA blfy, ge nksuksa Algorithm ds Input dk
yxHkx eku izkIr djrs gSa tgka ij nksuksa Algorithms ,d nwljs dks Cross djrs gSaA bl izf;k dks
Ballpark Estimate dgk tkrk gSA Ballpark Estimate fdlh Algorithm dk yxHkx Complexion
gksrk gS ftls Asymptotic Complexity dgk tkrk gSA Asymptotic Complexity fdlh Algorithm dk
eq[; Term gksrk gS ftlls fdlh Algorithm ds Qyu dh Limit dk irk pyrk gSA mnkgj.k ds fy, ekuyks
fd gekjs ikl nks Algorithms gSa%
1
2
A1 - Efficiency(n) = 29 [ Constant Time ]

A2 - Efficiency(n) = 3 + n/2 [ Linear Time ]
tc rd n = 52 gksrk gS rc rd A1(n) > A2(n) gksrk gSA ;kuh tc n dk eku 52 gksrk gS rc nksuksa
Algorithm dh Complexity leku gksrh gSA bl Limit ij nksuksa Algorithm ,d nwljs dks Cross djrs gSaA
gkykafd ,d cgqr gh NksVh List ds fy, A2 Algorithm dkQh Efficient gS ysfdu ;fn List cMh gks rks A1
Algorithm A2 Algorithm dh rqyuk esa vf/kd Efficient jgrk gSA Asymptotic Complexity ds ihNs ;gh
Idea gSA
ekuyks fd ,d Array esa 52 Items ds lkFk 29 Operations djus ij Required dke gks tkrk gSA bl
fLFkfr esa nksuksa gh Algorithms dks ,d nwljs ds LFkku ij Use fd;k tk ldrk gSA ysfdu ;fn Data
Items dh la[;k 52 ls de gks rks igyk Algorithm vf/kd Efficient gksxk tcfd ;fn Data Items dh
la[;k 52 ls vf/kd gks rks nwljk Algorithm igys dh rqyuk esa vf/kd Efficient gksxkA
Asymptotic Complexity esa Qyu ds lHkh Lower Order Terms o Constant Multipliers dks Ignore
dj fn;k tkrk gS] blfy, lHkh Linear Qyuksa dks O Notation esa O(n) fy[kk tkrk gS vkSj lHkh
Constant Time Qyu dks O Notation esa O(1) fy[kk tkrk gSA ;kuh A1 dh Asymptotic Complexity
O(1) gS tcfd A2 dh Asymptotic Complexity O(n) gSA LiB :i ls ge dg ldrs gSa fd Asymptotic
Complexity rHkh mi;qDr gS tc gesa cgqr cMs Input ds lkFk izf;k djuh gksA fdlh Application
Program esa gesa rc vf/kd lVhdrk ls Analysis djuk iMrk gS tc ge de Input Data ds lkFk izf;k
dj jgs gksrs gSaA

geus vHkh rd fofHkUu izdkj ds Qyuksa dks ns[kk gSA bu lHkh Qyuksa }kjk ge fdlh Algorithm dks Analyze
djrs gSa vkSj Algorithm dh Efficiency ;k Complexity Kkr djrs gSaA Efficiency ;k Complexity dks
iznfkZr djus ds fy, ge Capital Letter O dk iz;ksx djrs gSaA fofHkUu izdkj ds Qyuksa dks Represent
djus ds fy, ge O Notation dk iz;ksx djrs gSaA bl O Notation dks Use djds fdlh Qyu dh
Efficiency ;k Complexity dks Represent djus dh izf;k dks Big O Notation dgk tkrk gSA tc
ge Big O Notation }kjk fdlh Algorithm dh Complexity ds Qyu dks Represent djrs gSa rc Qyu
ds fofHkUu Low Order Terms, Dominant Terms o Constants Coefficients dks Ignore dj nsrs gSa o
dsoy Highest Power ;k Highest Value Represent djus okys Notation dks gh Big O Notation ds
:i esa O;Dr djrs gSaA tSls Efficiency(n) dks ;fn Big O Notation ds :i esa O;Dr djuk gks rks ge bls
dsoy O(n) fy[krs gSaA
Analyzing Algorithms
Analysis ds fy, gesa kk Simple Statements Sequence dks vk/kkj cukuk pkfg,A lcls igys ;s Note
djsa fd Statements dh ,d Sequence tks fd ,d le; esa dsoy ,d ckj Execute gksrh gS] mls Big
O Notation ds :i esa Represent djus ds fy, gesa dsoy O(1) fy[kuk gksrk gSA D;ksafd ,d Statement
Execute gksus esa ftruk le; yxkrk gS lHkh Statements Execute gksus esa mlh vuqikr esa le; yxk,axsA
mnkgj.k ds fy, ;fn fdlh Data Item dh Size n dks fdlh Loop }kjk fuEukuqlkj Solve fd;k tk
ldrk gS %
//==================================================================
for(i=0; i<n; i++)
{
Statement x;
}
//==================================================================
rks bl Loop esa Statement x ,d O(1) Sequence Statement gS blfy, bl Loop dh Time
Complexity n O(1) ;k O(n) gksxhA
;fn gekjs ikl fuEukuqlkj nks Nested Loop gksa rks
//==================================================================
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
{
Statement x;
}
}
//==================================================================
bl fLFkfr esa Loop i ds gj Iteration esa Loop j n ckj Iterate gksrk gSA ;kuh ;s Nested Loop n * n ckj
pysxk blfy, bl Loop esa yxus okyk le; O(n2) ds cjkcj gksxkA fuEu Loop rc rd pyrk gS tc rd
fd n dk eku h ds eku ls cMk ;k cjkcj jgrk gS&
//==================================================================
h = 1;
for(i=0; i<=n; i++)
{
Statement x;
h = 2 * h;
}
//==================================================================
bl Loop dh Complexity 1 + log n ds cjkcj gSA bls Big O Notation ds :i esa O( log2 n ) fy[k
ldrs gSaA
;fn Inner Loop Outer Loop ds Index ij fuHkZj gks rks Inner Loop esa j dk eku 0 ls n rd pyrk gSA
bl fLFkfr esa Loop dh Complexity fuEukuqlkj Kkr dh tk ldrh gS&
//==================================================================
for(i=0; i<=n; i++)
{
for(j=0; j<=i; j++)
{
Statement x;
}
}
//==================================================================
f( j )
=
=
=
=
0 to n
;kuh
1 + 2 + 3 + 4 + . . . (n-2) + (n-1) + n
;kuh
n * (n + 1) / 2
(n2 + n)/2
bl Algorithm dh Complexity dks Big O Notation ds :i esa ge O( n2 ) fy[k ldrs gSaA ;fn ge
fuEukuqlkj fdlh t:jr ds vuqlkj Loop pykrs gSa&
//==================================================================
h = n;
for(i=0; i<=h; i++)
{
for(j=0; j<=n; j++)
{
Statement x;
}
h = h/2;
}
//==================================================================
rks ;gka Outer Loop esa log2 n Iterations gksaxs vkSj Inner Loop dh Complexity O( n ) gksxhA bl fLFkfr
esa dqy Complexity O( n log n) gksxhA ;s Complexity igys okys Loop dh Complexity dh rqyuk esa
vf/kd Efficient gSA
pfy,] vc ge dqN Program ns[krs gSa vkSj mudh Complexity Kkr djus dh dksfkk djrs gSaA gkykafd bu
Programs dk okLro esa dgha dksbZ mi;ksx ugha gSA ;s dsoy dqN Pattern ek= Create djrs gSaA bu
mnkgj.kksa esa Programs dh Efficiency printf() Function ds dqy Executions dh la[;k ij vk/kkfjr gS
tks fd n dk Qyu gSA
Example
//==================================================================
main()
{
int i, j, n;
printf(Enter the limit of Pattern);
scanf(%d, &n);
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
{
printf(%4d, %4d\n, i, j);
}
}
getch();
}
//==================================================================
ge ns[k ldrs gSa fd nksuksa Loops esa dsoy Inner Loop esa gh Execute gksus okyk Statement gS vkSj
dsoy ,d gh Statement gSA gekjs Complexity Qyu gesa ;s crk,xk fd n ds Qyu ds :i esa printf()
Function fdruh ckj Execute gksxkA
bl iwjs Program dh Complexity Outer Loop dh Complexity ds cjkcj gS D;ksafd ;gh ,d Top Level
dk Statement gS ftlesa printf() Function Use fd;k x;k gSA fdlh Loop dh Complexity dks ge fuEu
lw= ls tku ldrs gSa&
Complexity of Loop =
( Number of Loops Repetitions ) * ( Complexity of each Iteration )
ge eku ldrs gSa fd Loop ds gj Iteration dh Complexity leku gSA ,lk ge Outer Loop ds fy, eku
ldrs gSa bl Loop dh Complexity dks fuEukuqlkj Big O Notation ds :i esa fy[k ldrs gSa&
O( n ) * O( Complexity of Inner Loop )
Inner Loop esa Hkh dsoy ,d gh printf() Statement gS blfy, Inner Loop ds fy, Hkh ;s ekuk tk ldrk
gS fd Inner Loop ds lHkh Iteration dh Complexity leku gSA ;kuh
Complexity of Inner Loop
O( n ) * O( printf )
Printf() Statement dsoy ,d gh ckj fy[kk x;k gS blfy, Lo;a printf() Statement dh Complexity
O(1) gSA lHkh ekuksa dks ,d lkFk fy[kus ij gesa bl Program dh Complexity fuEukuqlkj izkIr gksrh gS&
//================================================================
f( n )
=
=
=
O( n ) * O( n ) * O( 1 )
O( n * n )
O( n2)
//================================================================
pfy,] ,d vkSj Sample Program dh Complexity Kkr djrs gSaA Program fuEukuqlkj gS&
Example
//==================================================================
main()
{
unsigned int i, j, n;
printf(Enter a Nonzero Positive Value as a limit : );
scanf(%d, &n);
for( ; n>1; )
{
n = n/2;
printf(%d\n, n);
}
getch();
}
//==================================================================
bl Loop dh Complexity Kkr djus ds fy, Hkh ge ogh Formula Use dj ldrs gSa ftls fiNys
Program ds fy, Use fd;k gSA bl Loop ds gj Iteration dh Complexity leku gS blfy, bls ge
O(1) ds :i esa fy[k ldrs gSaA Loop fdruh ckj Iterate gksxk bls Kkr djus ds fy, gesa ;s Kkr djuk
gksxk fd ge fdlh Number n dks fdruh ckj nks Hkkxksa esa ckaV ldrs gSa tcfd n dk eku 1 ls cMk jgsA
ekuyks fd n ds gj eku dks K ckj nks Hkkxksa esa foHkkftr fd;k tk ldrk gS rks bls ge fuEukuqlkj fy[k
ldrs gSa&
2K <= n
;s rks fufpr gS fd tc ge 2K esa 2 dk Hkkx nsrs gSa rks K-1 ckj 2K dk eku 2 gksrk gS vkSj tc ge bls ,d
ckj vkSj 2 ls foHkkftr djrs gSa rks 2K dk eku 1 gks tkrk gSA 2K dk eku 1 gksrs gh Loop Terminate gks
tkrk gSA blfy, tc n dk eku 2K ds cjkcj gks ( n = 2K ) rc Loop K ckj Repeat gksxkA pwfa d n = 2K
gS blfy, ;s Loop n ds fofHkUu ekuksa ds fy, dbZ ckj Repeat gksxk ysfdu ;s Loop K + 1 Times
Repeat ugha gks ldrk D;ksafd K dk eku K + 1 ds eku ls de gksrk gSA blfy, ;fn n, K o ?kkr K+1 ls
Bounded gS rks ;s Loop K ckj pyrk gSA K o n ds chp esa ;s lEca/k gS fd K ml log dk Integer Part
gS ftldk vk/kkj 2 gSA blfy, bl mnkgj.k dh Complexity fuEukuqlkj gksxh&
O( log n ) * O( 1 ) =
O( log n )
;fn ge log ds vk/kkj 2 ds LFkku ij vk/kkj 10 dks Use djsa rks Hkh Complexity ij fdlh izdkj dk dksbZ
vUrj ugha iMrk gSA
Example
//==================================================================
main()
{
unsigned int i, j, n;
printf(Enter a Nonzero Positive Value as a limit : );
scanf(%d, &n);
for( i=1, m=n+66; i<=m; i++ )
{
printf(%d\n, i );
}
for( j=n/21, m=n/5; j<=m; j++ )
{
printf(%d\n, j );
}
getch();
}
//==================================================================
;gka nks Independent Loops esa nks printf() Statements gSaA blfy, bl Program dh dqy Complexity
nksuksa printf() Statements dh dqy Complexity ds ;ksx ds cjkcj gksxhA ;fn bl Program dks p ls
iznfkZr fd;k tk, rks bl Program dh Efficiency dks ge fuEukuqlkj Big O Notation ds :i esa
iznfkZr dj ldrs gSa&
Efficiency(p) = O( Outer Loop ) + O( Inner Loop )
Outer Loop dh Efficiency =
Inner Loop dh Efficiency =
Total Efficiency
=
=
O(n)
O(n)
O(n) + O(n)
O(n)
pfy,] ,d vkSj mnkgj.k ns[krs gSaA ;s mnkgj.k lcls igys mnkgj.k ds leku gh gS ysfdu blesa Loop ds
Iteration Complexity esa vUrj gSA Program fuEukuqlkj gS&
Example
//==================================================================
main()
{
int i, j, n;
printf(Enter the limit of Pattern);
scanf(%d, &n);
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
{
printf(%4d, %4d\n, i, j);
}
}
getch();
}
//==================================================================
bldh Efficiency ge fuEukuqlkj Kkr dj ldrs gSa&

Efficiency(Outer Loop)
=
=
=
=
=
SUM( i, 1, n ) of ( Efficiency of Ith Iteration )

SUM( i, 1, n ) of ( n-i )
n * ( n-1 ) / 2
O( n * n )
O( n2 )
Inserting and Deleting

fdlh Array esa ;fn txg miyC/k gks rks ubZ bdkbZ dks Array ds vUr esa tksMuk dkQh vklku gksrk gSA
ysfdu tc gesa Array ds fdlh foksk Index Number ij eku dks Insert djuk gksrk gS rks blds fy;s
Array ds ftl Element ds ckn ubZ bdkbZ tksMuh gS] mlls ckn ds lkjs Elements dks ,d&,d LFkku
vkxs izfrLFkkfir fd;k tkrk gSA fQj u, eku dks Array esa tksMk tkrk gSA ;fn ge Array esa eku Insert
djus ls igys ftl LFkku ij eku Insert djuk gS] mlls vkxs ds lHkh ekuksa dks izfrLFkkfir ugha djrs gSa rks
gekjk u;k eku iqjkus eku ij Over Write gks tkrk gSA
blh rjg ls fdlh Array ds vfUre Element dks Delete djuk dkQh vklku gksrk gS ysfdu tc fdlh
Array ds fdlh vU; Element dks Delete fd;k tkrk gS] rks Array ds ml Element ls vkxs ds lHkh
Elements dks ,d LFkku ihNs izfrLFkkfir djuk iMrk gSA ;fn ,lk uk fd;k tk, rks ftl LFkku ds eku dks
Delete fd;k x;k gS ml LFkku ij Garbage eku Store gks tkrk gSA
ekuyks fd Name ,d 10 Elements dk Linear Array gS ftlesa 6 uke Stored gSaA ge pkgrs gSa fd pkSFks
uke ds ckn ,d u;k uke Add djsAa bl fLFkfr esa gesa Array ds pkSFks Data item ds ckn ,d txg cukuh
gksxhA txg cukus ds fy, Array ds ikapos o NBs Data Item dks Move djds NBs o lkrosa LFkku ij
Mode djuk gksxkA mlds ckn u, Data Item dks pkSFks LFkku ij Insert djuk gksxkA bl iwjh izf;k dk
Algorithm ge fuEukuqlkj fy[k ldrs gSa&
ekuk ,d Array LArray[N] gS ftlesa N Items gSaA bl Array ds Index Number K ij ,d Element
ITEM dks Insert djuk gS tcfd ge ;s eku dj pyrs gSa fd bl Array esa vHkh bruk LFkku gS fd ge
blesa u;k Item Insert dj ldsAa pwfa d gesa Index Number K ij u;k ITEM Insert djuk gS blfy, gesa
Index Number K dks [kkyh djuk gksxk rkfd u;k Data blesa Store gks ldsA pwfa d u;k Data Store
djus ds fy, ge Index Number K ij txg cuk jgs gSa blfy, gesa Index Number K ls Array ds
vfUre Data Items rd ds lHkh Data Items dks ,d LFkku Right esa Move djuk gksxkA bl izf;k dks
ge fuEu fp= }kjk le> ldrs gSa&
10
25
32
45
95
75
ekuk K dk eku 4 gS rks gesa Index Number 4-1 = 3 dks [kkyh djuk gksxkA ,lk djus ij Index
Number 4 ds ckn ds lHkh Data Items dks ,d LFkku Right esa Move djuk gksxkA ,lk djus ij ;s
Array fuEukuqlkj fn[kkbZ nsxk&
10
25
32
45
45
95
75
vc ge Index number 4 ij u;k ITEM Insert dj ldrs gSaA Insert djus dk Algorithm fuEukuqlkj gks
ldrk gS&
Algorithm of Inserting
//===============================================================
1 START
2 DECLARE LArray[N], I, K, ITEM
3 REPEATE FOR I = N-1 TO I >= K STEP I = I - 1
4 SET LArray[I] = LArray[I-1]
[Shift Data Items to Right]
[End of the Loop]
5 SET LArray[K] = ITEM
[Insert Element]
6 END
//===============================================================
blh rjg ekuk fd ,d Array LArray[N] gS ftlesa N Items gSaA bl Array ds Index Number K ij fLFkr
Element dks Delete djuk gSA pwafd gesa Index Number K ij fLFkr Item dks Delete dj jgs gSa blfy,
gesa Index Number K ds ckn ds lHkh Data Items dks ,d LFkku ihNs dh rjQ Move djuk gksxkA bl
izf;k dks ge fuEu fp= }kjk le> ldrs gSa&
10
25
32
100
45
95
75
;fn ge K dk eku 5 ekusa rks Index Number 5-1 = 4 ds Data Item dks Delete djuk gSA tc ge
Index Number 4 ds Data Item dks Delete djuk pkgrs gSa rks gesa cl bruk gh djuk gS fd Index
Number 4 ds Data Item ij Index Number 5 ds Data Item dks Place dj nsaA ;kuh Index Number
4 ds ckn ds lHkh Data Items dks ,d LFkku vkxs ljdk nsaA ,lk djus ij ;s Array fuEukuqkj fn[kkbZ
nsxk&
10
25
32
100
95
75
fdlh Linear Array ls Deletion dk Algorithm fuEukuqlkj gks ldrk gS&

//===============================================================
1 START
2 DECLARE LArray[N], I, K
3 SET ITEM = LArray[K]
4 REPEATE FOR I = K TO N-1 STEP I = I + 1
5 SET LArray[I] = LArray[I+1]
[Shift Data Item to Left]
[End of the Loop]
6 END
//===============================================================
bu nksuksa Algorithms dk ge fuEukuqlkj iz;ksx djds Program cuk ldrs gSa&

//=================================================================
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define SIZE 10
main()
{
int Array[SIZE] = {1,10,20,0};
int i, j, item, id;
char choice;
while(1)
{
printf("\n1.
Insert Data Item");
printf("\n2.
Delete Data Item");
printf("\n3.
Display Data Item");
printf("\n4.
Exit");
printf("\n\nEnter Your Choice ");
scanf("%d", &choice);
switch(choice)
{
case 1: //Insertion Operation on the Array
printf("Enter Index Number [0 to 9] ");
Label:
fflush(stdin);
scanf("%d", &id);
if(id < 0 || id > SIZE-1)
{
printf("Index Number Must Be BETWEEN 0 to 9 ");
goto Label;
}
printf("Enter Value ");
scanf("%d", &item);
for(i = SIZE-1; i >= id; i--)
Array[i] = Array[i-1];
Array[i+1] = item;
break;
case 2:
//Deletion Operation on the Array
printf("Enter ID ");
scanf("%d", &id);
for(j=id; j<SIZE; j++)
Array[j] = Array[j+1];
Array[j-1] = 0;
break;
case 3: //Traversing Operation on the Array
for(i=0; i<SIZE; i++)
printf("Value at ID %d is %d \n", i, Array[i]);
break;
case 4:
exit(1);
}
}
}
//=================================================================
Sorting
fdlh Data Structure ds lHkh Data dks ,d O;ofLFkr e esa j[kuk Sorting dgykrk gSA ;s nks izdkj dh
gksrh gS] vkjksgh e esa ;k vojksgh e esAa vkjksgh e esa lcls de eku dk Data List dh kq:vkr esa o
lcls vf/kd eku dk Data List ds var esa Store gksrk gS] tcfd vojksgh e esa Bhd blds foijhr f;k
gksrh gSA ;kuh lcls vf/kd eku dk Data lcls igys o lcls de eku dk Data List esa lcls ckn esa
Store gksrk gSA Data Processing ds varxZr Sorting dks eq[;r% rhu Hkkxksa esa ckaVk x;k gS&
Bubble Sort
;g vR;f/kd dke esa vkus okyh lcls lk/kkj.k rduhd gSA blesa fdlh Hkh Array ds izFke eku dh rqyuk
Array ds nwljs eku ls djrs gSaA ;fn Array dk nwljk eku izFke eku ls cMk gS] rks vkjksgh e esa tekus ds
fy;s nwljs Data dks izFke LFkku ij j[k fn;k tkrk gS o izFke LFkku ds Data dks nwljs LFkku ijA fQj
Array ds nwljs eku dh rqyuk rhljs eku ls djrs gSa vkSj ;fn rhljk eku nwljs eku ls cMk gS rks rhljs eku
dh txg nwljk eku o nwljs eku dh txg rhljk eku j[k fn;k tkrk gSA ;fn nwljk eku rhljs eku ls cMk
ugha gS rks Array ds nwljs o rhljs ekuksa ds LFkku esa dksbZ ifjorZu ugha fd;k tkrk gSA ekuksa ds LFkku ifjorZu
dk ;s e rc rd pyk;k tkrk gS] tc rd fd lkjs eku vkjksgh e esa O;ofLFkr uk gks tk,A ;s e N-1
ckj pyk;k tkrk gS] tgka N Array ds dqy ekuksa dh la[;k gSA Bubble Sort dk Algorithm fuEukuqlkj gS&
//=====================================================================
Here LArray[N] is an Array with N Elements. This Algorithm SORTS the Data Items of the Array
1 START
2 REPEATE FOR I = 1 To N 1 STEP I = I + 1 [ Outer Loop]
3 REPEATE FOR J = 1 To N I STEP J = J + 1 [ Inner Loop ]
4 IF LArray[ J ] > LArray[ J + 1 ]
5 LArray[ J ] = LArray[ J + 1 ]
[ Interchange Data Items ]
[ End of Inner Loop ]
[ End of Outer Loop ]
6 End
//=====================================================================
Bubble Sort rc cgqr mi;ksxh gksrk gS tc List yxHkx Sorted gks vkSj dsoy dqN gh bdkbZ;ksa dh
Sorting djuh gksA tc bdkbZ;ksa dh la[;k vf/kd gksrh gS] rc bl fo/kh esa Program dh xfr dkQh de gks
tkrh gS] D;ksafd N-1 ckj List dks O;ofLFkr djuk iMrk gSA bl Algorithm dk iz;ksx djrs gq, ge
fuEukuqlkj ,d Function cuk ldrs gSa ftls fdlh Hkh Main Function esa Call fd;k tk ldrk gSA
Function fuEukuqlkj gS&
//====================================================================
void BubbleSort(int *Array, int size)
{
int i, j, temp;
for(i=0; i<size; i++)
{
for(j=0; j<size-i; j++)
{
if(Array[j]>Array[j+1])
{
temp = Array[j];
Array[j] = Array[j+1];
Array[j+1] =temp;
}
}
}
}
//====================================================================
bl Function esa nks Argument Calling Function ls vkrs gSaA igys Argument esa ,d Array dk Base
Address vkrk gS ftlds fofHkUu Elements dks Sorting Order esa j[kuk gS vkSj nwljs Argument esa
Array dh Size iznku dh tkrh gSA pwafd bl Function esa Array dk Base Address vkrk gS blfy, bl
Function }kjk tks Sorting gksrh gS og Calling Function ds Array dh Sorting gksrh gSA
Bubble Sort ds Algorithm ls ge le> ldrs gSa fd ;s Algorithm List esa ls lcls NksVs Data Item dks
Search djrk gS vkSj ml Data Element dks mldh Final Position ij Place dj nsrk gSA fQj nwljs
Iteration esa nwljs Element ls kq: djrk gS vkSj cps gq, Elements esa ls lcls NksVs Data Item dks [kkst
dj mldh Final Position ij Hkstrk gSA Algorithm esa ge ns[k ldrs gSa fd ;fn Data Items dh la[;k n
gks rks Outer Loop n ckj pyrk gS vkSj Outer Loop ds vk/kkj ij Smallest Data Find djus ds fy,
Inner Loop n-i ckj Comparison djrk gSA ;kuh dqy Comparisons dh la[;k fuEukuqlkj gksrh gS&
Elements E( n )
lkjkak esa dgsa rks
=
=
=
=
=
i = 1 To n SIGMA( n-i )
(n-1) + (n-2) + (n-2) + . . . + 2 + 1
n(n-1)/2
O(n2) O(n/2)
O(n2)
Bubble Sort Algorithm dh Complexity O(n2) gksrh gSA
Selection Sort
bl izdkj dh Sorting esa List dh izFke bdkbZ ls kq: djds iwjh List esa U;wure eku dks [kkstk tkrk gSS vkSj
ml eku dks List ds izkjaHk esa j[k fn;k tkrk gSA mlds ckn ksk List esa ls nwljs LFkku ds fy;s U;wure eku
dks [kkstk tkrk gS vkSj izkIr eku dks nwljs LFkku ij j[k fn;k tkrk gSA fQj rhljs LFkku ds fy;s ;gh e
viukrs gS vkSj rhljs LFkku ij ksk List esa ls izkIr U;wure eku dks j[k fn;k tkrk gSA ;s e rc rd pyrk
gS] tc rd fd iwjh List dh Sorting ugha gks tkrhA bldk Algorithm fuEukuqlkj gksrk gS&
//=====================================================================
1 START
2 REPEATE FOR I = 1 To N 1 STEP I = I + 1
[ Outer Loop]
3 REPEATE FOR J = I + 1 To N 1 STEP J = J + 1
[ Inner Loop ]
4 IF LArray[ I ] > LArray[ J ]
5 LArray[ I ] = LArray[ J ]
[ Interchange Data Items ]
6 End
//=====================================================================
bl Algorithm dh Complexity bl ckr ij fuHkZj djrh gS fd Data Structure esa Data fdl rjg ls
Organized gSaA ;fn Data yxHkx Sorted gks rks bl Algorithm dh Complexity de gksrh gSA ysfdu
fQj Hkh bl Algorithm dh Complexity O(n2) ls vf/kd ugha gks ldrhA ;kuh Data dk vf/kdre
2
Comparison n ckj gks ldrk gSA bl Algorithm dk iz;ksx djds ge fuEukuqlkj Sorting dk Function
cukdj vius Program esa Use dj ldrs gSaA
//====================================================================
void SelectionSort(int *Array, int size)
{
int i, j, temp;
{
for(j=i+1; j<size; j++)
{
if(Array[i]>Array[j])
{
temp = Array[i];
Array[i] = Array[j];
Array[j] =temp;
}
}
}
}
//====================================================================
Insertion Sort
bl Method esa lEiw.kZ List dks nks Hkkxksa Sorted Part o Unsorted Part es ckaVk tkrk gSA List ds
Unsorted Part ls ,d bdkbZ ysdj Sorted Part esa mi;qDr LFkku ij j[krs gSaA ;g izf;k rc rd pykrs
gSa tc rd fd Unsorted Part dh lHkh bdkbZ;kaa Sorted Part esa O;ofLFkr ugha gks tkrhA bldk
Algorithm fuEukuqlkj gksrk gSA bl Method esa nks in gksrs gSaA Sorted Hkkx dks i< dj ml LFkku dks
fpfUgr djuk gksrk gS tgka ij Unsorted Hkkx ls bdkbZ ykdj Insert djokuk gSA bl izf;k esa bdkbZ ds
fy;s LFkku cukus ds fy;s ksk bdkbZ;ksa dks Right Side esa Shift djuk gksrk gSA mlds ckn cuk, x, LFkku esa
bdkbZ dks izos k djok nsrs gSaA bl Method dk Algorithm fuEukuqlkj gksrk gS&
//=====================================================================
1 START
2 REPEATE FOR I = 1 To N 1 STEP I = I + 1
[ Outer Loop ]
3 REPEATE FOR J = 0 To I STEP J = J + 1
[ Inner Loop ]
4 IF LArray[ J ] > LArray[ I ]
5 TEMP = LARRAY[ J ]
6 LArray[ J ] = LArray[ I ]
7 REPEATE FOR K = I To J STEP K = K + 1
[ Inner Loop ]
8 LARRAY[ K ] = LARRAY[ K 1 ]
9 LARRAY[ K + 1 ] = TEMP
10 End
//=====================================================================
bl fof/k ls Sorting rc dh tkuh pkfg;s tc bdkbZ;kssa dh la[;k de gksrh gSA tc bdkbZ;ksa dh la[;k vf/kd
gksrh gS] rc ;s fof/k Bhd ugha jgrh D;ksafd bdkbZ;ksa ds fy;s txg cukus esa le; yxrk gS ftlls Program
dh xfr de gks tkrh gSA bl Algorithm dh Complexity esa de ls de n 1 ckj Comparison djuk
iMrk gSA bl Algorithm dk iz;ksx djds ge fuEukuqlkj ,d Function cuk ldrs gSa ftls fdlh Hkh
Program esa Use fd;k tk ldrk gS&
//====================================================================
void sort(int *Array, int size)
{
int i, j, k, temp;
{
for(j=0; j<i; j++)
{
if(Array[j]>Array[i])
{
temp = Array[j];
Array[j] = Array[i];
for(k=i; k>j; k--)
Array[k] = Array[k-1];
Array[k+1] = temp;
}
}
}
}
//====================================================================
Insertion Algorithm dk iz;ksx rc fd;k tk ldrk gS tc Data Items n dh la[;k de gksA bl

Algorithm dk Inner Loop i-1 Comparisons djrk gSA ;kuh
Elements E( n )
=
=
=
=
=
i = 1 To n SIGMA( i-1 )
1 + 2 + 3 + . . . + n-1
n(n-1)/2
O(n2) O(n/2)
O(n2)
Average Case esa bl Algorithm dh Complexity dks fuEukuqlkj nkkZ;k tk ldrk gS&
Elements E( n )
=
=
=
=
i = 1 To n SIGMA( i-1 )/2

(1 + 2 + 3 + . . . + n-1)/2
n(n-1)/4
O(n2)
ge ns[k ldrs gSa fd nksuksa gh fLFkfr;ksa esa bl Algorithm dh Complexity O(n2) gksrh gSA
,d izkxs zke cukvks tks nl vad Input ys vkSj mls vkjksgh dze esa Output esa Print djsAa
//================================================================
#include<stdio.h>
main()
{
int a[10], n, j, i;
clrscr();
for(i=0;i<10;i++)
{
printf("enter the a:");
scanf("%d", &a[i]);
}
for(i=0;i<10;i++)
{
for(j=0; j<=i; j++)
{
if(a[i]<a[j])
{
n=a[i];
a[i]=a[j];
a[j]=n;
}
}
}
for(i=0;i<10;i++)
printf("\n%d", a[i]);
getch();
}
//================================================================
,d izkxs zke cukvks tks nl vad Input ys vkSj mls vojksgh dze esa Output esa Print djsAa
//================================================================
#include<stdio.h>
main()
{
int a[10], n, i, j, sum = 0;
clrscr();
for(i=0; i<10; i++)
{
printf("Enter the a:");
scanf("%d", &a[i]);
}
for(i=0;i<10;i++)
{
for(j=0; j<=i; j++)
{
if(a[i]>a[j])
{
n=a[i];
a[i]=a[j];
a[j]=n;
}
}
}
for(i=0;i<10;i++)
printf("%d\n", a[i]);
sum = sum + a[j+i];
printf("sum = %d", sum);
getch();
}
//================================================================
Searching
ftl izdkj ls fdlh Telephone Directory esa fdlh uke ls Telephone Number [kkstrs gSa ;k fdlh
Telephone Number ls uke [kkstrs gSa] ;k fdlh student ds Roll Number }kjk Student dk Record
[kkstk tkrk gS] Bhd blh izdkj ls ,d Key }kjk fdlh Hkh Data Structure ls ml Key ls lEcaf/kr lkjh
tkudkjh izkIr dh tk ldrh gSA tSls ;fn gesa Telephone Directory ls 223344 Number fdl O;fDr
dk gS vkSj og O;fDr dgka jgrk gS] ;s tkuuk gkss] rks ge bl Number dks Telephone Directory ds gj
Number ls Compare djrs gSa] vkSj tgka ;s Comparison ,dne esy djrh gS] lEcaf/kr O;fDr dk uke
irk vkfn ge tku ysrs gSaA bl izdkj ls ;s Telephone Number ,d Key ds :i esa Use fd;k tkrk gS]
tks ckdh dh lEcaf/kr tkudkjh ns nsrk gSA ;gh izf;k ge Data Structure ds lkFk Hkh djrs gSaA
Computer esa Searching nks izdkj dh gksrh gS&
Internal Search
tc lHkh Records Computer dh Main Memory esa gksrs gSa] rks Main Memory ls dh tkus okyh
Searching Internal Search dgykrh gSA
External Search
tc Records cMs gksrs gSa o Records dh la[;k vf/kd gksrh gS] rc Records dks Hard disk ij laxzfgr
dj fy;k tkrk gSA fQj bl Hard Disk ls Searching dh tkrh gSA bl Searching dks External
Searching dgk tkrk gSA Internal Searching ds Hkh nks Hkkx gSaA
Linear Searching
fdlh vO;ofLFkr List esa ls Searching djus dh ;g lcls ljy fo/kh gksrh gSA tSls fdlh Data
Structure Array esa gesa ;s [kkstuk gks] fd vad 10 mifLFkr gS ;k ughaA ;g tkuus ds fy;s ,d Key
Variable ysaxs vkSj ml Key dk eku 10 dj nsaxsA fQj e ls bl Key ds eku dh rqyuk Array ds gj
Element ls djsaxsA Array ds gj Element ls Key ds eku dh rqyuk dk ;s e rc rd pyrk jgrk gS]
tc rd fd Array ds fdlh Element dk eku 10 izkIr uk gks tk, ;k fQj Array ds lHkh Elements dk
var uk gks tk,A bldk Algorithm fuEukuqlkj fy[k ldrs gSaA ekuk iq.kkZad ekuksa dk ,d Array
ARRAY[N] gSA
Algorithm
//===================================================================
1 LET COUNT = 1; and FOUND =0;
2 While ( COUNT < N ) DO
If ARRAY[COUNT] = VALUE then FOUND = COUNT
COUNT = COUNT + 1;
3 Print FOUND
4 END
//===================================================================
;g ,d vPNh rduhd gS] ysfdu bl rduhd esa Array ds gj Element dks Check djuk iMrk gS] ftlls
Program dh xfr de gks tkrh gSA bls fuEu fp= esa fn[kk;k x;k gS&
Array
10
30
20
41
10
Key
bl Algorithm ij vk/kkfjr ,d izksxzke ns[krs gSa] ftlesa ,d Array esa Store fofHkUu vadksa esa ls eupkgs vad
dks [kkstuk gS] fd veqd vad List esa miyC/k gS ;k ugha \
//=====================================================================
#include<stdio.h>
main()
{
int j, k[10] , key, found=-1;
clrscr();
for ( j = 0; j<10; j++)
{
printf("Enter %d digit ", j+1);
scanf("%d", &k[j] );
}
printf("\n Which Number Do you want to FIND ");
scanf("%d", &key);
for ( j = 0; j<10; j++)
{
if( k[j] == key )
found=key;
}
if(found > -1 )
printf("\n Number is present in The List ");
if(found < 0)
printf("\n The Number is not Present in the List ");

getch();
}
//=====================================================================
Output 1
//=====================================================================
Enter 1 digit 4
Enter 2 digit 344
Enter 3 digit 344
Enter 4 digit 34
Enter 5 digit 434
Enter 6 digit 434
Enter 7 digit 34
Enter 8 digit 555
Enter 9 digit 55
Enter 10 digit 5
Which Number Do you want to FIND 2
The Number is not Present in the List
//=====================================================================
Output 2
//=====================================================================
Enter 1 digit 1
Enter 2 digit 2
Enter 3 digit 3
Enter 4 digit 4
Enter 5 digit 5
Enter 6 digit 6
Enter 7 digit 7
Enter 8 digit 87
Enter 9 digit 89
Enter 10 digit 9
Which Number Do you want to FIND 9
Number is present in The List
//=====================================================================
bl izkx
s zke esa Linear Searching dh xbZ gSA lcls igys ,d Array esa ekuksa dks Input fd;k x;k gSA fQj
,d Key uke ds Variable esa oks vad ysrs gSa ftls List esa [kkstuk gSA bl vad dks Loop }kjk Array ds
gj Element ls Check fd;k tkrk gSA ;fn key dk vad Array esa izkIr gksrk gS rks if condition lR; gks
tkrh gS vkSj Found uke ds Variable esa key dk vad izkIr gks tkrk gSA ;fn key dk vad list esa izkIr
ugha gksrk gS] rks found dk eku -1 tks fd found dks Declare djrs le; gh ns fn;k x;k Fkk] jgrk gSA
;fn List esa key dk eku fey tkrk gS rks found dk eku -1 ls vf/kd jgrk gS vkSj Output esa Massage
feyrk gS fd List es vad miyC/k gSA ;fn List esa vad miyC/k ugha gksrk gS rks found dk eku -1 gksus ds
dkj.k 0 ls NksVk jgrk gSA blfy;s Output esa Massage izkIr gksrk gS fd tks vad [kkstk tk jgk gS og
vad List esa miyC/k ugha gSA bl izdkj ls Linear Searching dh tkrh gSA
Linear Search Algorithm dh Complexity dks Hkh ge f(n) Function dk iz;ksx djds irk dj ldrs gSaA
;fn fdlh Linear Data Structure esa n Data gksa rks ml Data Structure ls fdlh ITEM dks Find djus
ds fy, Worst Case Algorithm esa gesa vf/kdre n+1 ckj Comparisons djus gksaxs tcfd ;fn Data
ITEM Data Structure ds vUr esa gks ;k ITEM Data Structure esa uk gksA tcfd Average Case
Algorithm esa ITEM ds izkIr gksus dh lEHkkouk n+1/2 gksrh gSA
Binary Searching
;s vR;f/kd mi;qDr rduhd gS ysfdu bldk iz;ksx dsoy Sorted List ij gh fd;k tk ldrk gSA Linear
Searching dh rqyuk esa Binary Searching cgqr Fast xfr ls dke djrh gSA ekuk fd
Lowest
Highest
Mid
=
=
=
List dk U;wure eku

List dk vf/kdre eku
List dk e/;eku
Mid
Lowest + Highest / 2
bl izf;k esa Key ds eku dh List ds e/;eku ls rqyuk dh tkrh gSA ;fn e/;eku Mid Key ds eku ls
vf/kd gksrk gS rks Key ds eku dh rqyuk List ds Lowest Hkkx ls dh tkrh gSA
Highest = Mid - 1
rFkk Mid ds u, eku dks okil Mid = Lowest + Highest / 2 }kjk izkIr fd;k tkrk gSA ;fn Key dk eku
Mid ds eku ls vf/kd gksrk gS] rks Key ds eku dks List ds Highest Hkkx esa [kkstk tkrk gSA ;kuh
Lowest = Mid + 1
okil ls mijksDr lq= }kjk Mid dk u;k eku izkIr fd;k tkrk gSA ;s e rc rd pyrk jgrk gS tc rd
fd Key dk eku izkIr uk gks tk, ;k List lekIr uk gks tk,A Binary Search dh Algorithm fuEukuqlkj
gSA ekuk N Elements dh ,d Sorted List int X[N] gSA ;fn Key dk eku List esa fey tkrk gS] rks mls
FOUND esa Store djuk gSA fuEu fp= }kjk bls le>kus dh dksfkk dh tk jgh gSA ftlesa 1 dks [kkstk tk
jgk gSA ;kuh x = 1 gSA
Array[10]
low = 0;
high = n-1; so high = 10-1 = 9
mid = 0 + 9 / 2
mid = 4
Index Number 4 ij eku 5 gS blfy, x dk eku array[mid] ;kuh Array[4] ds cjkcj ugha gSA
1
Low
Mid
10
High
In First Iteration
x dk eku mid ls NksVk gS blfy, Key dk eku Array ds Lower Part esa gksxkA blfy, Loop ds Second
Iteration esa low dk eku 0 gh jgsxk ysfdu high dk eku Change gksdj mid+1 gks tk,xkA ;kuh
low = 0;
high = n-1; so high = 3-1 + 1 = 4
mid = 0 + 4 / 2
mid = 2
Low
Mid
10
High
In Second Iteration
Index Number 3 ij fLFkr eku Key x ds eku ds cjkcj ugha gS] blfy, x ds eku dks okil Check fd;k
tkrk gS fd x dk eku mid ds eku ls de gS ;k vf/kdA pwfa d x dk eku 1 gS vkSj mid eku 3 gS blfy,
okil x dk eku Array ds Lower Part esa gksxkA okil low ds eku esa dksbZ ifjorZu ugha gksxk ysfdu high
dk eku mid+1 gks tk,xkA ;kuh
low = 0;
high = n-1; ( mid + 1 )so high = 2-1 + 1 = 2
mid = 0 + 2 / 2
mid = 1
Low
10
High
Mid
In Third Iteration
vxys Iteration esa x dk eku Array ds izFke Element ij izkIr gks tk,xkA Binary Search dk
Algorithm ge fuEukuqlkj fy[k ldrs gSa&
Algorithm:
//=====================================================================
1 Let LOWEST = 0 ; HIGHEST = N; FOUND = 0; and flag = false;
2 WHILE [ ( LOWEST = HIGHEST ) .AND. ( flage = false)]
Perform steps 3 to 5
3 Mid
= Lowest + Highest / 2
4 IF X[MID] = (A) then [FOUND = MID; flage = true];
5 IF X[mid] < A then LOWEST = MID 1;
ELSE HIGHEST = MID 1;
6 IF ( flage = true ) then print FOUND
ELSE unsuccessful search;
7 END
//=====================================================================
Program
//=====================================================================
#include<stdio.h>
#include<conio.h>
main()
{
int j, n, x, found, count, a[10], low, high, mid;
clrscr();
printf(Number of Elements in the Array ( <=10): );
scanf(%d,&n);
for(j=0; j<n; j++)

{
printf(\n Enter The Elements:);
scanf(%d, &a[j]);
}
for(j=0; j<n; j++)
printf(\n The Entered Array is %d \t, a[j]);
printf(\n Enter The Element to be searched : );
scanf(%d, &x);
low = 0;
high=n-1;
found = -1;
while((low <= high ) && ( found == -1 ))
{
mid=(low + high ) / 2;
if(a[mid] == x )
found = mid;
else if(a[mid] < x )
low = mid + 1;
else
high = mid -1;
}
printf(\n);
if(found > -1)
printf(\n Position of the required element ( from 0 position ) is:
%d, found);
else
printf(\n Search Failed );
getch();
}
//=====================================================================
Output
//====================================================================
Number of Elements in the Array
Enter The Elements:1
The Entered Array is 1
<=10 : 10
The Entered Array

The Entered Array
The Entered Array
The Entered Array
Enter The Element
is
is
is
is
to
7
8
9
77
be searched : 77
Position of the required element is: 10

//=====================================================================
bl izkx
s zke esa Variables ds Declaration ds ckn ;s iwN
a k tkrk gS fd User fdrus Elements esa la[;k
Store djuk pkgrk gSA User tks la[;k nsrk gS og la[;k n uke ds Variable esa tkdj Store gks tkrh gS
vkSj Program esa tgka Hkh Loop pyk;k tkrk gS] Loop dks n rd gh pyk;k tkrk gSA D;ksafd geus tks eku
Input fd;s gSa] os n Elements esa gh fd;s gSaA eku Input djus ds ckn ekuksa dks loop }kjk print fd;k x;k
gSA fQj ,d Massage }kjk User ls iwN
a k tkrk gS] fd mls List esa ls dkSulh la[;k [kkstuh gSA User tks
la[;k Input djrk gS og la[;k x uke ds Variable esa tk dj Store gks tkrh gSA vc low uke ds
Variable dks 0 Assign fd;k x;k gSA ;s Array ds Index number 0 dks crkrk gS rFkk high uke ds
Variable dks n-1 fd;k x;k gS tks fd Array esa dqy Store gks ldus okys ekukas ds vafre Location dks
crkrk gSA ;kuh ;s Index number 9 dks crk jgk gS D;ksafd gekjs bl Array esa vafre eku Index
Number 0 ij gh Store gks jgk gSA vc found uke ds Variable dks eku -1 fn;k x;k gSA ge tkurs gSa
fd geus Array esa int izdkj ds gh eku Input fd;s gSaA blfy;s Array ds fdlh Element dk eku
_.kkRed ugha gks ldrk gSA blfy;s found uke dk Variable Use fd;k x;k gSA bl Variable esa ;fn
Search fd;k tkus okyk eku izkIr gks tkrk gS rks mls Store fd;k tk,xk vU;Fkk blesa -1 Store jgsxkA
vc while((low <= high ) && ( found == -1 )) statement }kjk ,d Loop pyk dj ;s Condition nh
xbZ gS fd loop rc rd pysxk tc rd fd found dk eku -1 jgrk gS vkSj lkFk gh Variable low dk eku
Variable high ds eku ls de ;k cjkcj jgrk gSA Variable low Array ds igys Element dks crkrk gS
vkSj Variable high Array ds vafre Element dks crkrk gS] ftlesa eku gSA ;gka Logical Operator &&
dk iz;ksx fd;k x;k gS] ftlls Loop esa nksuksa Conditions dk lgh gksuk t:jh gSA tSls gh dksbZ Condition
False gksrh gS rks Loop Terminate gks tkrk gSA tc Loop dh Condition lR; gksrh gS rc Program
Control Loop esa izos k djrk gSA ;gka mid=low + high / 2; statement }kjk Array ds e/; esa igqapk tkrk
gSA fQj if(a[mid] == x ) statement }kjk ;s irk fd;k tkrk gS] fd D;k Array a ds mid Index Number
ij fLFkr eku x ds eku ds cjkcj gS ;k ughaA ;fn x dk eku x ds cjkcj gksrk gS rks found ds mid dk
eku ns fn;k tkrk gSA found dk eku -1 ls cny dj mid gks tkrk gS blfy;s while loop dh condition
vlR; gks tkrh gS vkSj Loop Terminate gks tkrk gSA ysfdu ;fn Index Number mid dh location ij
tks eku gS] og eku x ds eku ds cjkcj ugha gS] rks if condition vlR; gks tkrh gS vkSj Program Control
else condition ds izFke statement if(a[mid] < x ) dks Execute djrk gSA ;gka ;s check fd;k tkrk gS
fd D;k Array dh mid Index Number dh Position ij tks eku gS] og eku x ds eku ls NksVk gS ;k
ughaA ;fn x a[mid] dk eku x ds eku ls NksVk gS rks if condition lR; gks tkrh gS vkSj low = mid + 1;
statement }kjk Variable low dk eku mid+1 dj fn;k tkrk gSA ;s statement crkrk gS fd x dk eku
Index Number mid ds Lower Part esa ugah gSA ysfdu ;fn Index Number mid ij fLFkr eku x ds
eku ls NksVk ugha gS rks high = mid -1; statement }kjk x ds eku dks Array ds Higher Part es [kkstk
tkrk gSA bl izdkj ls iqu% loop pyrk gS vkSj List ds ftl vk/ks Hkkx esa eku dks [kkstuk gS] mlh vk/ks Hkkx
esa eku dks [kkstk tkrk gSA tSls gh eku izkIr gksrk gS] found dk eku -1 ls cny dk x ds cjkcj gks tkrk gS
vkSj Loop Terminate gks tkrk gSA ;fn iwjs Array es eku izkIr ugha gksrk gS] rks Array dk low o high
Variable dk eku leku gks tkrk gS vkSj Loop dk var gks tkrk gS vkSj Loop Terminate gks tkrk gSA
;fn eku izkIr gks tkrk gS rks Array ds ml Location ds Index Number dks print fd;k tkrk gS vU;Fkk
;s Massage Print fd;k tkrk gS fd Search Fail gks xbZ ;kuh List esa lEcaf/kr eku ugha gSA
String Operations and Data Structure

ge tkurs gSa fd dksbZ String ,d 1-D Array esa Store gksrh gS blfy, ge fdlh String ds lkFk Hkh os lHkh
Operations dj ldrs gSa tks fdlh Integer izdkj ds ekuksa ds Array ds lkFk djrs gSaA ;kuh ge fdlh
String esa ubZ Sub String dks Insert dj ldrs gSa] String esa fdlh Sub String dks Delete dj ldrs gSa]
fdlh String dks Search dj ldrs gSa] vkfnA
vkt ge tks Hkh Word Processors tSls fd MS-Word, Open Office vkfn Use djrs gSa] muesa
Strings ij fofHkUu izdkj ds Operations fd, tk ldrs gSaA tc gesa fdlh String esa dksbZ vU; Sub
String Insert djuh gksrh gS] rks gesa lcls igys ml Memory Location ij tkuk iMrk gS] tgka String
dks Insert djuk gSA ge ftl String ds 1-D Array esa dksbZ Sub String Insert djuk pkgrs gSa ml
String ds Array esa Space gksuk pkfg,A ;fn Target String ds Array esa Space ugha gksxk] rks ge ;fn
dksbZ Source String ml Array esa Insert djsx
a s] rks Target String ds Last ds Characters Delete gks
tk,axsA gesa Insert dh tkus okyh Sub String dh Length dk Hkh irk gksuk pkfg,] rkfd ge ftl LFkku ij
String dks Insert djuk pkgrs gSa] ml LFkku ls Sub String dh Length ds cjkcj Space rd tks Hkh
Characters Target Array esa gSa] mUgsa mrus gh Characters Right esa Shift dj ldsAa bl tkudkjh ds
vk/kkj ij ge fuEukuqlkj ,d Algorithm fy[k ldrs gSa tks fdlh String esa Sub String Insert ds Steps
dks iznfkZr djsxkA
Algorithm
//===================================================================
Here TARRAY[SIZE] is an Array where SIZE is the size of the Array.
SARRAY[N] is an Array where N is the Size of the Array. POS is the Target
Position of the Sub String in the Source String. LENGTH is the Length of the
Sub String. X and I are the Variables of the Loop.
1 START
2 SET X = 0
3 REPEATE FOR I = SIZE-1 TO POS
4 TARRAY[I] = SARRAY[I - LENGTH] STEP I = I 1
[Right Shift Data Elements From Position I To I LENGTH Position ]
[End of the Loop]
5 REPEATE FOR I = POS to POS+LENGTH-1 STEP I = I + 1
6 TARRAY[I] = SARRAY[X]
7 SET X = S + 1
[End of the Loop]
8 END
//===================================================================
bl Algorithm ds vk/kkj ij ge fuEukuqlkj ,d Program cuk ldrs gSa ftlesa fdlh String esa ,d vU;
Sub String dks Insert fd;k x;k gSA Program fuEukuqlkj gS&
Program //===================================================================
#include <stdio.h>
#include <string.h>
#define SIZE 20
main()
{
char string[SIZE], substring[10], pos;
int i, x=0, Length;
clrscr();
printf("Enter Position");
scanf("%d", &pos);
fflush(stdin);
printf("\nEnter String");
gets(string);
printf("Enter Sub String");
gets(substring);
Length = strlen(substring);
for(i=SIZE-1; i>(int)pos; i--)
{
string[i] = string[i-Length];
}
for(i=pos; i<=pos+Length-1; i++)
{
string[i] = substring[x++];
}
printf("String is %s", string);
getch();
}
//===================================================================
bl Program dks Execute djus ij bldk Output fuEukuqlkj izkIr gksrk gS%
Output
//==================================================================
Enter Position 6
Enter String Rajasthan
Enter Sub String Pali
String is RajastPalihan
//===================================================================
ge ns[k ldrs gSa fd fdlh Integer Array esa fdlh eku dks Insert djuk o fdlh String Array esa Sub
String Insert djuk nksuksa esa dksbZ foksk vUrj ugha gSA ftl rjg ge fdlh String esa fdlh Sub String
dks Insert dj ldrs gSa mlh rjg ls fdlh String ls fdlh Sub String dks Delete Hkh dj ldrs gSaA
fdlh String ls fdlh Sub String dks Delete djus ds fy, gesa Array ds ml Location dh t:jr gksrh
gS tgka ls Characters dks Delete djuk gS vkSj ftrus Characters Delete djus gksrs gSa] mu
Characters ds Length dh t:jr gksrh gSA fdlh String ls dqN Characters Delete djus ds fy, ge
fuEukuqlkj Algorithm fy[k ldrs gSa%
Algorithm
//===================================================================
Here TARRAY[SIZE] is an Array where SIZE is the size of the Array.
POS is the Target Position of the Character From where we want to delete the
Specified Number of Characters. LENGTH is the Length of the Characters we
want to delete from the String. X and I are the Variables of the Loop.
1 START
2 REPEATE FOR I = POS TO SIZE-1 STEP I = I + 1
3 TARRAY[I] = TARRAY[I + LENGTH]
[Right Shift Data Elements From Position I LENGTH To I Position ]
[End of the Loop]
4 END
//===================================================================
bl Algorithm ds vk/kkj ij ge fuEukuqlkj Program cuk ldrs gSa&

Program
//===================================================================
#include <stdio.h>
#include <string.h>
#define SIZE 20
main()
{
char string[SIZE], pos;
int i, Length;
clrscr();
printf("Enter String");
gets(string);
fflush(stdin);
printf("Enter Position From where you want to DELETE Characters : ");
scanf("%d", &pos);
fflush(stdin);
printf("\nEnter Number of Characters you want to DELETE : ");
scanf("%d", &Length);
for(i=(int)pos; i<SIZE-1; i++)
string[i] = string[i+Length];
printf("String is %s", string);
getch();
}
//===================================================================
Output
//==================================================================
Enter String : India Rajasthan
Enter Position From where you want to DELETE Characters : 5
Enter Number of Characters you want to DELETE : 4
String is Indijasthan
//===================================================================
Pattern Matching Algorithms

Pattern Matching dk eryc ;s irk djuk gksrk gS fd D;k Input fd;k x;k Substring fdlh vU;
String esa miyC/k gS ;k ughaA ;s irk djus ds fy, gesa fdlh Array ds gj Characters dks Sub String ds
gj Character ls Match djokuk gksrk gSA fdlh Pattern dks Match djus ds fy, fofHkUu izdkj ds
Algorithms dk iz;ksx fd;k tkrk gSA ge ;gka ij lcls T;knk iz;ksx esa vkus okys o lcls ljy Algorithm
dk iz;ksx fdlh String esa Pattern dks Match djus ds fy, dj jgs gSaA bl Algorithm dks Brute Force
Algorithm dgk tkrk gSA ;s Algorithm fuEukuqlkj gS&
Algorithm
//===================================================================
Here ARRAY[N] and PATTERN[M] is a String of Size N and M. I, J and K are the
Variables For Looping. STRLEN1 is the Length of ARRAY[N] and STRLEN2 is the
Length of PATTERN[M]. This Algorithm Finds the Position of PATTERN[M] in
ARRAY[N].
1 START
2 SET POS = 0
3 REPEATE FOR I = POS TO STRLEN1 STRLEN2 STEP I = I + 1
4 SET J = 0
5 SET K = I
6 REPEATE STEP 7 and 8 WHILE ARRAY[K] == PATTERN[J] .AND. J<STRLEN2
7 K = K + 1
8 J = J + 1
9 IF J == PATTERN then BREAK
10 PRINT String is at the Position I
//===================================================================
bl Algorithm dk iz;ksx djds ge fuEukuqlkj ,d Program cuk ldrs gSaA ;s Program nks String User
ls ysrk gS vkSj nwljh String dks igyh String esa [kkstrk gSA ;fn igyh Sting esa nwljh String fey tkrh
gS rks ;s Algorithm igyh String ds ml Index Number dks Return djrk gS tgka ij String dk Patter
Match djrk gSA Program fuEukuqlkj gS&
Program
//===================================================================
#include <stdio.h>
#include <string.h>
#define SIZE 20
main()
{
char string[SIZE], substring[10],pos = 0;
int i, j, k, stringLength, subStringLength;
clrscr();
printf("Enter String : ");
gets(string);
fflush(stdin);
printf("Enter Sub String which you want to Find in String : ");
gets(substring);
fflush(stdin);
stringLength = strlen(string);
subStringLength = strlen(substring);
for(i=(int)pos; i<=stringLength-subStringLength; i++)
{
j = 0;
k = i;
while((string[k] == substring[j]) && (j<subStringLength))
{
k++;
j++;
}
if(j==substring)
break;
}
printf("Sub String Found at Index Number %d", i);
getch();
}
//===================================================================
Output
//==================================================================
Enter String : Indian Lata Mageskar
Enter Sub String which you want to Find in String : Mageskar
Sub String Found at Index Number 13
//===================================================================
;gka geus dqN mnkgj.k ns[ks tks fd fdlh String ls lEcaf/kr Operations djus ds lEca/k esa gSaA ge vkSj Hkh
dbZ izdkj ds String Operations dj ldrs gSaA blh izdkj ds Operations fofHkUu Word Processor
Softwares esa viuk, tkrs gSa vkSj String dks fofHkUu rjhdksa ls Process fd;k tkrk gSA gkykafd dqN vkSj
Hkh Algorithms gSa tks String Processing ds fy, dkQh mi;ksxh gksrs gSa ysfdu fdlh Patter Matching
ds fy, Brute Force Algorithm dks dkQh Use fd;k tkrk gSA
bl Algorithm dh Complexity esa Data dh Size String o Sub String dh tksM ds cjkcj gksrk gSA
;kuh ;fn fdlh String esa 20 Characters gksa vkSj Find fd, tkus okys Pattern esa 6 Character gks]a rks
dqy Input Data Items dh la[;k bu nksuksa ds tksM ds cjkcj gksrh gSA ;kuh ;fn String ds Data Items
dh la[;k s gks o Find fd, tk jgs String ds Data Items dh la[;k r gks rks dqy Input Data Items
dh la[;k fuEukulkj n gksxh :
n = s + r
fdlh Worst Case Complexity esa bl Algorithm dh Complexity C(n) = r(s r + 1) gksrh gSA ;fn n
dk eku Fixed gks tSlk fd gekjs Case esa s = n r gS] rks Complexity fuEukuqlkj gksxh&
C(n) = r( n 2*r + 1)
C(n) dk vf/kdre eku rc gksrk gS tc r = (n+1)/4 gksrk gSA ;fn bl Equation esa r dk eku Place
fd;k tk, rks Function fuEukuqlkj gksxk&
C(n) = (n + 1 )2 / 8 = O(n2)
Algebra of Matrix
,d 2D Array dks Industrial Area esa Table dgk tkrk gS tcfd Scientific Area esa Matrix dgrs gSaA
;fn fdlh Company ds fofHkUu Employees dh Information dks Manage djuk gks rks ge ,d 2D
Array dk iz;ksx djds Company ds fofHkUu Employees dh Information dks Manage dj ldrs gSaA
Employees dh bu Information ds lewg dks Table dgk tk ldrk gSA ysfdu tc ge Mathematical
Calculations ;k Scientific Expressions dks Handle djus ds fy, ,d 2D Array dk iz;ksx djrs gSa rks
mlh 2D Array dks Matrix dgk tkrk gSA ge fofHkUu izdkj ds Algebraic Operations dks ,d Array dk
iz;ksx djds Represent dj ldrs gSaA bl Section esa ge bUgh ds ckjs esa lh[ksaxsA
Addition of Matrixes
nks Matrix dk Addition rHkh lEHko gS tc nksuksa Matrix leku izdkj ds gksa ;kuh nksuksa Matrix ds Rows o
Columns dh la[;k leku gksA ekuyks A o B nks leku izdkj ds Matrix gSa] rks Matrix A o Matrix B dks
,d rhljs Matrix ds :i esa Define fd;k tk ldrk gS ftlesa nksuksa Matrix ds lHkh leku Locations dk
;ksx rhljs Matrix esa leku Location ij gksrk gSA mnkgj.k ds fy,
1
5
9
13
A=
A+B
2
6
10
14
1+91
5+50
9+90
13+13
3
7
11
15
4
8
12
16
2+12
6+61
10+10
14+14
3+63
7+79
11+11
15+15
B=
4+94
8+80
12+12
16+16
OR
91
50
90
13
92
55
99
26
12
61
10
14
14
67
20
28
63
79
11
15
66
86
22
30
94
80
12
16
98
88
24
32
nks Matrixes dk tksM djus ds fy, lcls igyh krZ ;s gS fd nksuksa Matrix ds Rows o Columns dh
la[;k leku gksA tc nks Matrix tksMus yk;d gksrs gSa rc igys Matrix ds 0,0 Location ds eku dks nwljs
Matrix ds 0,0 Location ds eku ls tksM dj rhljs Matrix ds 0,0 Location ij Store fd;k tkrk gSA
blh rjg ls igys Matrix ds 0,1 Location ds eku dks nwljs Matrix ds 0,1 Location ds eku ls tksMdj
rhljs Matrix ds 0,1 Position ij Store djuk gksrk gSA ;kuh fdUgh nks Matrix dks tksMus ds fy, ge
fuEu Algorithm dk iz;ksx dj ldrs gSa&
Matrix Addition Algorithm
//===================================================================
MATRIX_ADDITION(MATRIX1, ROW1, COL1, MATRIX2, ROW2, COL2, MATRIX3,
COL3)
ROW3,
Here MATRIX1 is a Matrix with Size ROW1 and COL1, MATRIX2 is a Matrix with
Size ROW2 and COL2, MATRIX3 is a Matrix with Size ROW3 and COL3.
1
IF ROW1 = ROW2 and COL1 = COL2 then
PRINT MATRIX ADDITION is Possible

REPEATE FOR I = 0 To M STEP SIZE 1 INCREMENT
REPEATE FOR J = 0 To N STEP SIZE J = J + 1
MATRIX1[I][J]=MATRIX1[I][J] + MATRIX2[I][J]
ELSE
PRINT MATRIX ADDITION is not Possible
2 EXIT
//===================================================================
Subtraction of Matrixes
ftl rjg ls ge nks Matrix dks vkil esa tksM ldrs gSa mlh rjg ls ge igys Matrix ls nwljs Matrix dks
?kVkdj rhljk Matrix Hkh izkIr dj ldrs gSaA ;gka ;s ckr /;ku j[kus okyh gksrh gS fd ;fn ,d Matrix A o
nwljk Matrix B gS rks A B vkSj B A dk ifj.kke leku ugha vkrk gSA bls fuEu mnkgj.k ls le> ldrs
gSa&
1
5
9
13
A=
2
6
10
14
3
7
11
15
4
8
12
16
B=
AB
1-91
5-50
9-90
13-13
2-12
6-61
10-10
14-14
3-63
7-79
11-11
15-15
4-94
8-80
12-12
16-16
BA
91-1
50-5
90-9
13-13
12-2
61-6
10-10
14-14
6-33
79-7
11-11
15-15
94-4
80-8
12-12
16-16
OR
OR
91
50
90
13
-90
-45
-81
0
12
61
10
14
63
79
11
15
94
80
12
16
-10
-55
0
0
-60
-72
0
0
-90
-72
0
0
90 10 60 90
45 55 72 72
81 0 0 0
0
0 0 0
fdlh ,d Matrix esa ls nwljs Matrix dks ?kVk dj rhljk ifj.kkeh Matrix izkIr djus ds fy, Hkh nksuksa
Matrix ds Rows o Columns dh la[;k leku gksuk t:jh gksrk gSA tc nks Matrix bl fLFkfr esa gksa fd
mUgsa ?kVk;k tk lds rks gesa igys Matrix dh 0,0 Location ds eku dks nwljs Matrix ds 0,0 Location ds
eku esa ls ?kVk dj rhljs Matrix ds 0,0 Location ij ifj.kke dks Store djuk gksrk gSA Bhd blh rjg ls
igys Matrix ds 0,1 Location ds eku dks nwljs Matrix ds 0,1 Location ds eku esa ls ?kVk dj rhljs
Matrix ds 0,1 Location ij ifj.kke dks Store djuk gksrk gS vkSj ;gh izf;k gesa Matrix ds vU; lHkh
Locations ds ekuksa ds lkFk viukuh gksrh gSA Matrix ds Subtraction ds fy, ge fuEu Algorithm dk
iz;ksx dj ldrs gSa&
Matrix Subtraction Algorithm
//===================================================================
MATRIX_SUBTRACTION(MATRIX1, ROW1, COL1, MATRIX2, ROW2, COL2, MATRIX3, ROW3,
COL3)
1
IF ROW1 = ROW2 and COL1 = COL2 then
PRINT MATRIX SUBTRACTION is Possible

REPEATE FOR I = 0 To M STEP SIZE I = I + 1
REPEATE FOR J = 0 To N STEP SIZE J = J + 1
MATRIX1[I][J]=MATRIX1[I][J] - MATRIX2[I][J]
ELSE
PRINT MATRIX SUBTRACTION is not Possible
2 EXIT
//===================================================================
Multiplication of Matrix
nks Matrix dk xq.kk djus dk rjhdk lkekU; xq.kk djus ds rjhds ls FkksMk vyx gksrk gSA nks Matrix dk xq.kk
mlh fLFkfr esa gks ldrk gS tc igys Matrix ds Rows dh la[;k N nwljs Matrix ds Columns dh la[;k
M ds cjkcj gksA bl izf;k dks fuEu mnkgj.k }kjk le>k tk ldrk gS&
1
5
9
A=
2 3 4
6 7 8
10 11 12
B=
12
9
6
3
11
8
5
2
10
7
4
1
ekuyks fd gekjs ikl A o B nks Matrix gSaA igys Matrix A esa Rows dh la[;k N = 3 gS vkSj nwljs Matrix
B esa Columns dh la[;k M = 3 gS] blfy, bu nksuksa Matrix dk xq.kk djuk lEHko gSA tc ge nks Matrix
dk xq.kk djuk pkgrs gSa rks gesa igys Matrix ds Rows ds ekuksa dk xq.kk e ls nwljs Matrix ds Columns
ds ekuksa ls djuk gksrk gSA bl dkj.k ls nks Matrix A o B dk xq.kk dHkh Hkh B o A ds xq.kk ds cjkcj ugha
gksrkA ;kuh
A . B <> B . A
A.B
1*12+2*9+3*6+4*3
5*12+6*9+7*6+8*3
9*12+10*9+11*6+12*3
1*11+2*8+3*5+4*2
5*11+6*8+7*5+8*2
9*11+10*8+11*5+12*2
1*10+2*7+3*4+4*1
5*10+6*7+7*4+8*1
9*10+10*7+11*4+12*1
OR
12 + 18 + 18 + 12
60 + 54 + 42 + 24
108+ 90 + 66 + 36
11 + 16 + 15 + 8
55 + 48 + 35 + 16
99 + 80 + 55 + 24
10 + 14 + 12 + 4
50 + 42 + 28 + 8
90 + 70 + 44 + 12
OR
60
170
300
50
154
258
40
128
216
and
B.A
12*1+11*5+10*9
9*1+8*5+7*9
6*1+5*5+4*9
3*1+2*5+1*9
12*2+11*6+10*10
9*2+8*6+7*10
6*2+5*6+4*10
3*2+2*6+1*10
12*3+11*7+10*11
9*3+8*7+7*11
6*3+5*7+4*11
3*3+2*7+1*11
12*4+11*8+10*12
9*4+8*8+7*12
6*4+5*8+4*12
3*4+2*8+1*12
OR
12
09
06
03
OR
157
112
067
022
+
+
+
+
55
40
25
10
+
+
+
+
180
136
082
028
90
63
36
09
213
160
097
034
24
18
12
06
+
+
+
+
66
48
30
12
+
+
+
+
100
070
040
010
36
27
18
09
+
+
+
+
77
56
35
14
+
+
+
+
110
077
044
011
48
36
24
12
+
+
+
+
88
64
40
16
+
+
+
+
120
084
048
012
246
184
112
040
ge ns[k ldrs gSa fd Matrix A dk Matrix B ls xq.kk djus ij tks Matrix izkIr gksrk gS og 3*3 dk Matrix
izkIr gksrk gS tcfd Matrix B dk Matrix A ls xq.kk djus ij gesa 4*4 dk Matrix izkIr gksrk gSA ;kuh nks
Matrix dk xq.kk fdl e esa fd;k tk jgk gS] Matrix ds xq.kuQy ij bl ckr dk izHkko iMrk gS vkSj gesa
nksuksa izdkj ds xq.kuQy Matrix vyx&vyx izkIr gksrs gSaA fdUgha nks Matrixes dk xq.kk djus ds fy, ge
fuEu Algorithm dk iz;ksx dj ldrs gSa&
Matrix Multiplication Algorithm
//===================================================================
MATRIX_MULTIPLICATION(MATRIX1, ROW1, COL1, MATRIX2, ROW2, COL2, MATRIX3,
ROW3, COL3)
1 IF COL2 = ROW1
[ When we are taking Column of first matrix and multiplying it with rows
of second matrix. ] then
REPEATE FOR I = 0 To ROW1-1 STEP SIZE I = I + 1
REPEATE FOR J = 0 To COL2-1 STEP SIZE J = J + 1
MATRIX3[I][J] = 0
REPEATE FOR K = 0 To COL1-1 STEP SIZE K = K + 1
MATRIX3[I][J] = MATRIX3[I][J] + MATRIX1[I][K] * MATRIX2[K][J]
ELSE IF ROW1 = COL2
[ When we are taking Rows of first matrix and multiplying it with
the columns of the second matrix. ] then
REPEATE FOR I = 0 To ROW1-1 STEP SIZE I = I + 1
REPEATE FOR J = 0 To COL2-1 STEP SIZE J = J + 1
MATRIX3[I][J] = 0
REPEATE FOR K = 0 To COL2-1 STEP SIZE K = K + 1
MATRIX3[I][J] = MATRIX3[I][J] + MATRIX1[I][K] * MATRIX2[K][J]
ELSE
PRINT Multiplication of MATRIXES is not possible
2 EXIT
//===================================================================
Transpose of Matrix
tc fdlh Matrix ds Rows ds fofHkUu Data dks Columns Wise O;ofLFkr dj fn;k tkrk gS] rks bl
izf;k dks Matrix dk Transposition djuk dgrs gSaA tSls fuEu Matrix A dks Transpose djds Matrix
AT dh rjg fd;k tk ldrk gS&
A =
157
112
067
180
136
082
213
160
097
AT =
157
180
213
112
136
160
067
082
097
fdlh Matrix dks Transpose djus ds fy, ge fuEu Algorithm dk iz;ksx dj ldrs gSa&
Matrix Transposition Algorithm
//==================================================================
MATRIX_TRANSPOSITION(MATRIX, ROW, COL, MATRIX_T, ROW_T, COL_T)
Here MATRIX is a Matrix with Size ROW and COL and MATRIX_T is a Transpose
Matrix with Size ROW_T and COL_T.
1 REPEATE FOR I = 0 To ROW-1
2 REPEATE FOR J = 0 To COL-1
3 MATRIX_T[I][J] = MATRIX[J][I]
4 EXIT
//===================================================================
Orthogonal Matrix
tc fdlh Matrix esa Rows o Columns dh la[;k leku gks rks bl izdkj ds Matrix dks Square
Matrix dgk tkrk gSA ,d Matrix A vkSj mldk Transpose Matrix AT nksuksa dk ;fn xq.kk fd;k tk, vkSj
gesa izkIr gksus okyk Result Matrix ogh gks tks Actual Matrix A gS] rks bl izdkj ds Matrix dks
Orthogonal Matrix dgk tkrk gSA fuEu fp= esa ,d Matrix A o mldk Transpose Matrix AT gSA
;fn bu nksuksa dk xq.kk fd;k tkrk gS rks gesa izkIr gksus okyk Matrix U mlh izdkj dk fn[kkbZ nsrk gS ftl
izdkj dk Original Matrix A gSA bl Matrix dks ge Orthogonal Matrix dgsaxsA
A =
1
0
0
0
1
0
0
0
1
AT =
1
0
0
0
1
0
0
0
1
1
0
0
0
1
0
0
0
1
U =
bls ;fn ge Mathematically fy[kuk pkgsa rks fuEukuqlkj fy[k ldrs gSa&
U =
A * AT
tc fdlh Square Matrix esa fod.kZ ds LFkku ij fLFkr lHkh Data Elements 1 gksa vkSj ksk lHkh Data
Elements dk eku 0 gks rks bl izdkj ds Matrix dks Identity Matrix dgk tkrk gSA D;ksafd bl izdkj ds
Matrix dk Transpose Matrix AT o Multiplication Matrix U nksuksa gh Actual Matrix A ds leku gh
gksrs gSaA
Symmetric Matrix
tc dksbZ Matrix A o mldk Transpose Matrix AT nksuksa ds lHkh Data Elements leku gksa rks bl izdkj
ds Matrix dks Symmetric Matrix dgk tkrk gSA ;kuh ;fn A = AT gks rks bl izdkj ds Matrix dks
Symmetric Matrix dgk tkrk gSA bls ge vxys fp= }kjk Hkh le> ldrs gSa&
A =
1
0
0
0
1
0
0
0
1
AT =
1
0
0
0
1
0
0
0
1
ge ns[k ldrs gSa fd Matrix A o mldk Transpose Matrix AT nksuksa ds fofHkUu Data Elements ,dne
leku gS] blfy, ;s ,d Symmetric Matrix gSA
Sparse Matrix
;fn fdlh Matrix esa T;knkrj Data Elements 0 gks]a rks bl izdkj ds Matrix dks Sparse Matrix dgk
tkrk gSA gkykafd ;s dHkh fufpr ugha gksrk gS fd fdl Matrix dks Sparse Matrix dg ldrs gSa vkSj fdls
ughaA ysfdu fQj Hkh ;fn fdlh Matrix ds dqy Data Elements esa 2/3 ls vf/kd Elements dk eku 0 gks
rks bl izdkj ds Matrix dks Sparse Matrix dh Category esa j[kk tkrk gSA mnkgj.k ds fy, fuEu Matrix
,d Sparse Matrix dk mnkgj.k gS&
11
0
0
0
21
0
0
0
31
;fn ge bl Matrix dks Memory esa Store djuk pkgsa rks gesa rks gesa dqy 9 Memory Locations ds fy,
Space Reserve djuk gksxkA tcfd ge ns[k ldrs gSa fd bl Matrix esa dsoy rhu gh Data Elements
mi;ksxh gSa tks fdlh Information dks Represent dj jgs gSaA bl fLFkfr esa ckdh ds 6 Space csotg
Memory Space dks Reserve j[ksaxsA
Sparse Matrix ds Data dks Represent djus ds fy, ,d ,lh O;oLFkk dk iz;ksx fd;k tkrk gS ftls 3
Tuple Representation dgk tkrk gSA bl O;oLFkk esa ,d ,lk Array Create fd;k tkrk gS ftlesa
Matrix ds gj eku dks ,d Row ;k Tuple ds :i esa Store fd;k tkrk gSA bl Row esa rhu Columns
gksrs gSaA igys Column esa ml Non Zero Data Element dh Row dk Index Number gksrk gSA nwljs
Column esa ml Non Zero Data Element dh Column dk Index Number gksrk gS vkSj rhljs
Column esa Matrix ds Data Element dk Actual eku gksrk gSA tSls ;fn mijksDr Matrix dks gh ge
Sparse Matrix ds :i esa Memory esa Store djuk pkgsa rks ge fuEukuqlkj ,d Array Create dj ldrs
gSa&
//====================================================================
int SparseMatrix[][] = {
0,0,11,
1,1,21,
2,2,31
};
//====================================================================
gekjs Actual Matrix esa Row Number 0 o Column Number 0 ij eku 11 gSA bls ,d Row ;k Tuple
ds :i esa fy[kus ds fy, SparseMatrix esa igys Index Number ij Row Number 0 dks Fill fd;k x;k
gSA nwljs Column esa Column Number 0 dks Fill fd;k x;k gS vkSj rhljs Column esa Actual eku 11 dks
Fill fd;k x;k gSA ;gka Hkh Sparse Matrix dh iwjh Information dks Store djus ds fy, gesa 9 Memory
Spaces dh vko;drk gksrh gS ysfdu ;fn fdlh Sparse Matrix dh Size 10 * 10 dh gks vkSj mlesa
dsoy 20 Data Elements ,ls gksa ftUgsa 3 Tuple esa Represent djuk gks rks gesa dsoy 20 Locations
dh gh vko;drk gksxh tcfd ;fn 10*10 dk Matrix Create fd;k tk, rks gesa 100 Memory Locations
dh t:jr gksxhA ;kuh fdlh 10*10 ds Sparse Matrix ds dsoy 20 Data dks Represent djus ds fy,
;fn ge 3 Tuple Representation dk iz;ksx djrs gSa rks ge 80 Memory Locations dks cpk ldrs gSaA
;gh Sparse Matrix dk Computer Science esa mi;ksx gSA
Linked Lists
Data ds ,d Linear Collection dks ge lkekU; thou esa List dgrs gSaA fdlh Hkh List esa ,d ;k ,d ls
vf/kd Data Items gksrs gSaA ge gekjh vko;drkuqlkj u, Item List esa Add djrs gSa vkSj fdlh Item dks
List ls Delete djrs gSa ;k fdlh Item dks Modify djrs gSaA mnkgj.k ds fy, ekuyks fd gesa dqN lkeku
[kjhnus ds fy, ,d List cukrs gSa ftuesa fuEu Items gSa tks gesa [kjhnus gSa&
//========================================================================
Pen
Floppy
CD Bag
Walkman
CD Player
Speaker Set
//=========================================================================
;fn ge pkgsa rks blesa dqN vkSj Items Hkh Add dj ldrs gSa ftUgsa ge [kjhnuk pkgrs gSaA fuEu List dks
nsf[k, ftlesa rhu u, Items Add fd, x, gSa&
//=========================================================================
Pen
Floppy
CD Bag
Home Theater
Walkman
CD Player
Color TV
Speaker Set
Diary
//=========================================================================
vki ns[k ldrs gSa fd bl List esa geus rhu u, Items Add fd, gSaA ekuyks fd gesa bl List esa ls fy[ks x,
Item CD Player dks Change djds DVD Player ysuk pkgrs gSa rks gekjh bl List dks gesa Modify djuk
gksxkA ;fn ge bl List dks Modify djrs gSa rks List fuEukuqlkj gks tkrh gS&
//=========================================================================
Pen
Floppy
CD Bag
Home Theater
Walkman
DVD Player
Color TV
Speaker Set
Diary
//=========================================================================
fdlh List esa Organized Data dks Store o Process djuk Data Processing dgykrk gSA Data dks
Computer Memory esa Store djus dk ,d rjhdk Array gSA ftl rjg ls ge ,d Array Linear rjhds
ls fofHkUu Data Items tks fd vkil esa Related gksrs gSa] Store djrs gSa] mlh rjg ls Data Items dks
Memory esa Physically Related :i esa Store dj ldrs gSaA fdlh Array esa gj Data Item vxys Index
Number ij Store gksrk gSA ;kuh Data Items Physically Hkh Memory esa Related gksrs gSaA ysfdu
Array dh dqN dfe;ka gSaA
1 fdlh Array esa ;fn fdlh Data Item dks Delete djuk gks ;k dksbZ Data Item Insert djuk gks]
rks Array ds yxHkx lHkh Data Items dks Left ;k Right esa Shift djuk iMrk gSA ;s fdlh Hkh
Array Data Structure dh igyh deh gSA
2 fdlh Array esa gesa ftrus Data Items Insert djus gksrs gSa gesa Array dh mruh Size dks igys gh
Define djuk iMrk gSA ,ls esa ;fn gesa vko;drkuqlkj vf/kd Data Insert djus gksa rks ge
Array dh Size dks c<k ugha ldrs gSaA ;kuh Array esa Store fd, tkus okys Data Permanent
gksrs gSa] blfy, Array dks Static Data Structure ;k Permanent Data Structure ;k Dense
List dgrs gSaA ;s Array dh nwljh deh gSA
Related Data Items dh fdlh List dks Memory esa Store djus dk ,d nwljk rjhdk vkSj gS ftls
Linked List dgrs gSaA Linked List esa gj Data Items ds lkFk vxys Data Item dk Link gksrk gSA ;kuh
gj vxys Data Item dk Address ;k Pointer fiNys Data Item ds lkFk gksrk gSA gkykafd Linked List
Hkh ,d Linear Data Structure gS ysfdu Linked List ds Data Items ekxr Memory Location ij
Store ugha gksrs gSaA blfy, fdlh List Item dks Add ;k Delete djuk ljy gksrk gSA bl Data
Structure esa gj Data Item vius vxys Data Item dks Point djrk gSA ;kuh gj vxys Data Item dk
Pointer ;k Link ;k Address fiNys Data Item esa gksrk gSA blfy, lHkh Data Items vkil esa Linked
gksrs gSaA bl rjg ds Data Structure dks Linked List dgk tkrk gSA bl Data Structure dh viuh dqN
fokskrk,a vkSj dfe;ka gSaA
Linked List ,d One Way List gksrh gS] tks fd Data Items dk Linear Collection dgk tkrk gSA
Linked List ds fofHkUu Data Items dks Node dgk tkrk gSA fdlh Linked List esa gesakk nks Hkkx gksrs gSaA
igys Hkkx dks Information Part dgk tkrk gS vkSj nwljs Part dks Pointer Part ;k Link Part dgk tkrk
gSA Information Part esa ge fofHkUu Data Items ds ,d Records dks Store dj ldrs gSa tcfd Linked
Part esa gesakk ,d Pointer gksrk gS ftlesa vxys Record dk Address ;k Pointer Variable gksrk gSA
bl Pointer Variable dks START dgk tkrk gSA tgka ij List Item dk vUr gksrk gS ml Last Link
Field esa NULL gksrk gSA tc fdlh List esa dksbZ Node ugha gksrk gS rks mls NULL List ;k Empty List
dgrs gSa vkSj bl fLFkfr esa START esa NULL gksrk gSA
Linked List
;s Dynamic Memory Allocation dk gh foLrkfjr :i gSA ,d Array Linked List dk vPNk mnkgj.k gS]
ftlesa lHkh Data One By One vkil esa tqMs jgrs gSaA ysfdu Array dh Size izkx
s zke dh kq:vkr esa gh
Declare djuh iMrh gS] ftlls Memory dk lgh rjg ls mi;ksx ugh gks ikrk gSA blh leL;k ls cpus ds
fy;s Dynamic Memory Allocation dk iz;ksx fd;k tkrk gSA Structure ds lkFk Dynamic Memory
Allocation dk iz;ksx fd;k tk ldrk gSA tc ge Structure ds lkFk Dynamic Memory Allocation dk
iz;ksx djrs gSa rks bl rjhds ls Memory esa Store gksus okys Data Items dh List dks gh Linked List
dgrs gSaA Linked List esa gesa kk ,d Structure gksrk gS] ftldk ,d Member gesa kk ,d Structure izdkj
dk Pointer Variable gksrk gS] ftlesa vxys Structure dk Address Store jgrk gSA gj Structure List
dks node dgk tkrk gSA gj Structure List esa de ls de ,d Member Data dk o ,d Member vxys
node ds Address dks Store djus okys Pointer Variable dk gksrk gSA Linked List ds lHkh Structure
mlh izdkj ls tqMs jgrs gS] ftl izdkj ls ,d Array ds lHkh Element vkil esa tqMs jgrs gSaA ysfdu Array
dh rjg budh Location ,d J`a[kyk esa ugha gksrh gS cfYd ;s Nodes Memory esa dgha Hkh gks ldrs gSaA ;s
vkil esa buds Address }kjk tqMs jgrs gSaA bls fuEu fp=kuqlkj nkkZ;k x;k gS&
Structure1
Structure2
Item1
Item2
Structure3
Item3
Next
Linked List
tSls ekuk ge ,d Structure iz;ksx djrs gSa] ftlds nks Members gSaA igyk ,d int izdkj dk Member gS
o nwljk mlh Structure izdkj dk ,d Pointer Member gS] ftlesa mlh Structure ds nwljs Data dk
Address gSA bls fuEukuqlkj crk;k x;k gS&
//======================================================================
struct stud
{
int roll_no;
struct stud *next;
}
//======================================================================
;g Structure Variable Memory esa fuEukuqlkj Store gksxk&

stud
Roll_no
Next
;fn ge nks ls vf/kd Members dh node cuk,a rks ml Structure dk Variable Memory esa fuEukuqlkj
Store gksxk&
//======================================================================
{
int roll_no;
char name[30];
int class1;
float grad;
struct stud *next;
}
//======================================================================
stud
roll_no
name
class1
grad
next
vkb;s vc ns[krs gSa fd Link List fdl izdkj ls cuk;k tkrk gSA ge okil ij crk, x, igys Structure
dks gh ysrs gSa] ftlesa nks Members gSaA bl Structure ds nks Variables node1 o node2 fuEukuqlkj
Declare djrs gSa&
struct stud node1,node2;
;s nksuksa Variables Memory esa fuEukuqlkj Space cuk,axs&

node1
Roll_no
Next
node2
Roll_no
Next
vc gesa bu nksuksa nodes esa fyad cukuk gSA Link cukus ds fy;s izFke node node1 ds next uke ds
Structure izdkj ds Pointer esa nwljs node node2 dh Storage Cell dk Address nsuk gksxkA Address
nsus ds fy;s ge & Operator dk iz;ksx djsaxs vkSj Dot ( . ) Operator dk iz;ksx djrs gq, node1 ds next
esa node2 dk Address nsaxsA blds fy;s fuEukuqlkj statement fy[kuk gksxk&
node1.next = &node2;
ekuk fd node1 Memory esa 2020 Location ij Stored gS vkSj node2 Memory esa 5020 Location
ij Stored gS] rks mijksDr Statement ds ckn node1 esa ;s Address fuEukuqlkj Store gksxk tks node2
dks Point djsxk&
node1
2050
Roll_no
Next
node2
Roll_no
Next
vc ;fn ge nksuksa Nodes esa dksbZ eku Input djsa] rks ;s eku fuEukuqlkj Store gksaxs&
node1.roll_no = 200;
node2.roll_no = 300;
node2.next = NULL;
node1
200
2050
Roll_no
Next
node2
300
Roll_no
Next
Null
Node2 ds next dks NULL eku fn;k x;k gS D;ksfa d vHkh bls fdlh vU; Variable ls Link ugha djuk gSA
;kuh ;s Linked List vHkh ;gha lekIr gks jgh gSA vc ;fn gesa node2 ds Members ds eku Screen ij
Print djus gksa rks geas Arrow Operator dk iz;ksx djuk iMrk gSA tSls node2 ds roll_no dk eku
Screen ij fn[kkus ds fy;s gesa fuEukuqlkj Statement fy[kuk gksxk&
printf( \n %d, node1.next->roll_no);
ge fdlh Hkh Pointer dks nwljh node dk Address nks izdkj ls iznku dj ldrs gSaA ,d rjhdk gS &
Operator }kjk ftls fiNys izk:i izkx
s zke esa Use fd;k x;k gSA nwljk rjhdk gS Dynamic Memory
Allocation }kjk ftls vc le>k;k tk jgk gSA
ge Dynamic Memory Allocation dk iz;ksx djrs gq, fiNys izk:i izksxzke dks gh ;gka le>k jgs gSa fd
fdl izdkj ls Dynamic Memory Allocation }kjk ,d node dks nwljh node dk Address fn;k tkrk
gSA ;kuh
//========================================================================
struct stud
{
int roll_no;
struct stud *next;
}
//========================================================================
vc Dynamic Memory Allocation ds fy;s ,d Pointer Variable ysrs gSa] tks Structure stud izdkj dk
gSA bls start uke nsrs gSaA ;kuh
struct stud *start;
vc blds fy;s Memory Allocate djrs gSa vkSj ml Allocated Memory dk Address bl start dks nsrs
gSaA ;kuh
start = ( struct stud * ) malloc ( sizeof ( struct stud ) );
malloc() Function Memory esa ,d Block cuk,xk] tks fd Structure izdkj dk eku Store dj ldrk
gSA bl Memory Block dk Address start esa fn;k x;k gSA bls fuEukuqlkj ns[k ldrs gSa&
start
Roll_no
Next
bl node esa ge fuEukuqlkj eku iznku dj ldrs gSa&

//========================================================================
start->roll_no = 200;
start->next = NULL;
//========================================================================
;s eku fuEukuqlkj store gksrs gSa&

start
200
Roll_no
0
Next
vc ge izFke node esa ,d nwljh node cuk dj mls tksMrs gSaA bls fuEukuqlkj fd;k x;k gS&
start->next = ( struct stud * ) malloc ( sizeof ( struct stud ) );
start ,d Pointer gS vkSj next Hkh ,d Pointer gSA Start esa Structure ds izFke Memory Block dk
Address gSA bl Memory Block esa ,d Pointer Variable next gSA ;fn bl next dks Hkh Memory esa
dksbZ Memory Block cuk dj mldk Address ns fn;k tk,] rks blesa Hkh ,d Memory Block dk
Address gksxkA bl Address }kjk ml Memory esa Hkh eku Store fd;s tk ldrs gSaA bl izdkj ds
Declaration ls ,d izdkj dh J`a[kyk cu tkrh gSA geus start dks ,d Structure izdkj ds Memory
block dk Address iznku fd;k gSA bl start }kjk ge ml Structure esa eku Store dj ldrs gSaA tSlk
fd start->roll_no = 200; and start->next = NULL; statement }kjk fd;k gSA ;fn bl Structure ds
Member next dks] tks fd ,d Pointer Member gS] NULL djus ds ctk; ,d Memory Block cuk dj
ml Memory Block dk Address ns fn;k tk,] rks bl Structure izdkj ds Pointer Variable es]a cuk,
x, Memory Block dk Address gksxkA bl Memory Block esa ge okil roll_no o next uke ds
Variable esa fdlh vU; Memory Block dk Address store dj ldrs gSaA bl izdkj ls ge pkgs ftruh
la[;k esa nodes cuk ldrs gSa vkSj ,d nwljs dks Link dj ldrs gSaA blh fu;e ij pyrs gq, start =
(struct stud *)malloc(sizeof(struct stud)); statement }kjk start dks Structure dk ,d
node cukdj ml node dk Address iznku fd;k gSA fQj bl Structure ds Member next dks ,d vkSj
Structure izdkj dk Memory Block (node) cuk dj] ml Memory Block dk Address start>next=(struct stud *) malloc(sizeof(struct stud)); statement }kjk next dks fn;k gSA
vc ;fn bl nwljs node ds next uke ds Member dks dksbZ Memory Block cuk dj mldk Address ns
fn;k tk,] rks ;s rhljk node cu tkrk gSA ;gh e vkxs ls vkxs pyk;k tk, rks ge vuUr rd nodes
cuk ldrs gSaA tc ge ;s nodes cuk ysrs gSa] rks budks eku nsus dk Hkh ,d foksk e gksrk gSA bl e esa
gesa izFke node ds Address ls gksrs gq, ml gj node ls xqtjuk iMrk gS] ftlesa eku Input djuk gSA
ekuk bl izf;k }kjk geus rhu node cuk, rks gesa rhuksa nodes esa eku Input djus ds fy;s e ls
fuEukuqlkj eku nsuk gksxk&
izFke node dks eku nsuk
//========================================================================
start->roll_no = 200;
start->next = NULL;
//========================================================================
u;k node cukuk vkSj bl node dk Address izFke node ds next dks nsuk&
start->next = ( struct stud * ) malloc ( sizeof ( struct stud ) );
nwljs node dks eku iznku djuk&

//========================================================================
start->next->roll_no = 251;
start->next->next = NULL;
//========================================================================
u;k node cukuk vkSj bl node dk Address nwljs node ds next dks nsukA
start->next->next = ( struct * ) malloc (sizeof (struct stud ) );
rhljs node dks eku iznku djuk&

//========================================================================
start->next->next->roll_no = 230;
start->next->next->next = NULL;
//========================================================================
Linked List dk var djus ds fy;s vafre node ds Member next dks NULL iznku djukA
bl izdkj ls node cuk dj ge gj node dks eku iznku dj ldrs gSaA Linked List esa eku Initialize
djrs le; ;fn dbZ nodes gksa rks dkQh cMs&cMs statements fy[kus iMrs gSaA bl vlqfo/kk ls cpus ds
fy;s ge ,d vkSj Pointer Variable dk iz;ksx djrs gSa vkSj Loop }kjk node cukus o eku Input djus dk
dke djrs gSaA ge ,d ckj esa ,d node cuk dj mlesa vU; nodes dks Insert djds vko;drkuqlkj
nodes cuk ldrs gSaA ge fdlh Hkh Linked List esa eq[;r% rhu izdkj ls nodes dks Insert dj ldrs gSa&
1
2
3
Linked List ds kq: esa u;k node tksM dj A

Linked List ds e/; esa u;k node tksM dj o
Linked List ds var esa u;k node tksM dj A
tc gesa fdlh Linked List dh kq:vkr esa u;k node tksMuk gks] rc gesa fuEu e esa dke djuk gksrk gS&
1 ;fn izFke Pointer start esa NULL gS rks bldk eryc gksrk gS] fd Linked List vHkh kq: gh ugha gqbZ
gSA blfy;s ,d node Create fd;k tkrk gS vkSj ml node dk Address Linked List ds Start esa ns
fn;k tkrk gSA ;s node Linked List dh izFke node gksrh gSA
2 ;fn izFke Pointer start esa NULL ugha gSa rks bldk eryc gS fd Linked List igys ls gh cuh gqbZ gSA
bl cuh gqbZ Linked List esa u;k node tksMus ds fy;s u, node dk Address Pointer start dks ns
fn;k tkrk gS vkSj u, node ds next Member dks start dk Address ns fn;k tkrk gSA ,lk djus ij
Start u, node dks Point djrk gS vkSj u, Node dk Pointer ml node dks Point djrk gS ftls
igys Start Point dj jgk FkkA
;fn Linked List kq: gh ugha gqbZ gS ;kuh
struct stud *start = NULL, *newnode;
rks u;k node cuk,saxs vkSj bl u, node dk Address start dks ns nssaxsA vc bl node dks eku Initialize
djsaxs lkFk gh bl newnode ds next Member dks NULL dj nsaxsA bldk eryc ;s gksxk fd bl
newnode ds ckn dksbZ node Linked List esa ugha gSA
newnode = ( struct stud * ) malloc ( sizeof ( struct stud ) );
newnode
Roll_no
Next
start = newnode;
start->roll_no =200;
start->next = NULL;
ekuk u, Node dk Address 2020 gS rks bl u, node dk Address start dks nsus ls start dk
Address 2020 gks tk,xk vkSj bl newnode ds Members dks start }kjk eku iznku fd;k tk ldsxkA
bl izdkj ls Linked List dh kq:vkr gks tk,xhA vc ekuk dh ij crkbZ xbZ fLFkrh ds ckn Linked List
dh kq:vkr gks pqdh gS vkSj blh Linked List esa ,d u;k node Linked List dh kq:vkr esa tksMuk gS] rks
blds fy;s ,d u;k node fuEukuqlkj cuk,axs&
newnode = ( struct stud * ) malloc ( sizeof ( struct stud ) );
vc bl u, node dks Linked List esa tksMus ds fy;s loZizFke bl node ds next Member dks Pointer
Variable start dk Address nsuk gksxk vkSj mlds ckn bl u, node dk Address start dks ns nsaxs
ftlls start vc bl u, node dks point djsxk vkSj bl u, node dk Member next igys okys node
dks point djsxkA ;kuh
newnode->next=start;
start=newnode;
;fn blh izdkj ls vkxs dk e c<k;k tk, rks vko;drkuqlkj Linked List dks rc rd c<k;k tk ldrk
gS] tc rd fd Memory Space lekIr uk gks tk,A
Creating Linked List

ge tkurs gSa fd fdlh Hkh Linked List ds nks Hkkx gksrk gSA igys Hkkx esa fdlh Record ds Data Items
gksrs gSa vkSj nwljs Hkkx esa ,d Pointer gksrk gS tks Linked List ls Linked fdlh Data Item dks Point
djrk gSA Data dks Memory esa Store djus ds bl rjhds esa ge Structures dk iz;ksx dj ldrs gSaA fuEu
Structure dks nsf[k,&
//========================================================================
struct LIST
{
//Information Part
int INFO;
//Link Part
struct LIST *LINK
};
//========================================================================
;gka geus bl Structure esa dsoy nks Data Items dks gh Member ds :i esa fy;k gSA ;fn ge pkgsa rks
Information Part esa fdlh Record ds fofHkUu Data Items ds fy, Member Variables Create dj
ldrs gSaA pwfa d ge tkurs gSa fd ftl Data Type dk Address gesa fdlh Pointer Variable esa Store
djuk gksrk gS gesa mlh Data Type dk Pointer Variable Create djuk iMrk gSA blhfy, geus Link
Part esa LIST izdkj dk ,d Pointer Variable LINK Create fd;k gSA ;s Pointer fdlh LIST izdkj ds
nwljs Data Item ds Memory Block ds Address dks Store dj ldrk gSA
tc fdlh Linked List dh kq:vkr ugha gqbZ gksrh gS rc ge dg ldrs gSa fd Linked List vHkh START
ugha gqbZ gSA ;kuh ;fn START ,d LIST izdkj dk Variable gks vkSj START dk eku NULL gks rks ge
dg ldrs gSa fd vHkh Linked List Start ugha gqvk gSA
fdlh Linked List dks Create djus dk eryc gksrk gS fd Linked List esa vHkh dksbZ Hkh Data Element
ugha gS ;kuh START esa NULL Store gSA bl fLFkfr esa ;fn ge LIST izdkj dk dksbZ Memory Block
Create djrs gSa vkSj mldk Address START esa ns nsrs gSa] rks Linked List dh kq:vkr gks tkrh gSA pwfa d
tks Linked List kq: gks jgh gS mlesa dsoy ,d gh Node gS] tks fd geus Currently Create fd;k gS]
blfy, bl Currently Created Node ds LINK esa gesa NULL Store djuk iMrk gS ftldk eryc gksrk
gS fd Linked List esa dsoy ,d gh Data Element ;k Node gSA bl iwjs Process dk Algorithm ge
fuEukuqlkj fy[k ldrs gSa] tgka LIST ,d Linked List gSA START LIST izdkj dk ,d Pointer Variable
gS tks Linked List ds Start dks Indicate djrk gSA PTR Create gksus okys u, Data Element ;k Node
dk Pointer gSA
Starting New Linked List Algorithm
//========================================================================
1 IF START = NULL then
PTR = CREATE NEWNODE
[ Create Newnode and Assign the Address to PTR of Created Newnode. ]
PTR[INFO] = ITEM
[ Insert the ITEM in the INFO Part of the newly Created Node. ]
PTR[LINK] = NULL
[ Insert NULL in the LINK Part of the newly Created Node which is
indicating the end of the Linked List. ]
START = PTR
[ Give the Address of newly created node PTR to START so that START
may point newly created first node PTR of the Linked List. ]
EXIT
//========================================================================
Memory Allocation
pwfa d tc Memory esa dksbZ Data Stored ugha gksrk gS] rc Hkh Memory dk gj Memory Location vkil
esa ,d Linked List ds :i esa Linked jgrk gSA ;s lHkh Locations Free gksrh gSa] ftuesa Garbage
Values gksrh gSaA bUgsa vko;drkuqlkj dksbZ vU; Linked List Use djrk gSA bl Memory Locations dh
Linked List dks AVAILABLE SPACE dgk tkrk gS vkSj AVAILABLESPACE fy[kk tkrk gSA blesa Hkh
,d Pointer gksrk gS tks vius vxys Free Space dk Address Stored j[krk gSA bl Pointer dks Hkh ge
LINK dg ldrs gSaA tc fdlh vU; Linked List }kjk bl AVAILABLESPACE uke dh Linked List esa
ls fdlh Free Memory Location dks Use fd;k tkrk gS rc ml Memory Location dk Link
AVAILABLESPACE Linked List ls VwV tkrk gS vkSj Create gksus okyh ubZ Linked List ls og
Location Linked gks tkrk gSA bls ge fuEu fp= }kjk iznfkZr dj ldrs gSa tgka gekjh Linked List esa
Add gksus okyk u;k Node AVAILABLESPACE Linked List ls VwVs gq, ,d Node dks fdlh izdkj ls
Use djrk gS] bls iznfkZr fd;k x;k gS&
bl fp= dks ns[k dj le>k tk ldrk gS fd tc ge fdlh Linked List esa u;k Node Add ;k Create
dj jgs gksrs gSa rks okLro esa gekjh RAM esa AVAILABLESPACE dh tks Linked List gS] mlesa ls ,d
Node Delete gksrk gS vkSj og Node ml Linked List esa Add gks tkrk gS ftlesa u;k Node Insert ;k
Add fd;k tk jgk gS ;k ubZ Linked List Create dh tk jgh gSA blh rjg ls tc fdlh Linked List esa ls
fdlh Node dks Delete fd;k tkrk gS rks okLro esa og Node AVAILABLESPACE Linked List esa Add
fd;k tk jgk gksrk gSA
tc fdlh Linked List esa u;k Node Create djds mls Point djus ds fy, mldk Address START dks
fn;k tkrk gS rks bldk eryc gksrk gS fd START esa ml Node dk Address fn;k tk jgk gS] ftls
Node Create djus ls igys AVAILABLESPACE uke Pointer Point dj jgk FkkA
Figure A esa ge ns[k ldrs gSa fd START ml Node dks Point dj jgk gS ftldk Address 5 gS vkSj
START dk igyk Node ml Node dks Point dj jgk gS ftldk Address 10 gSA blh rjg ls
AVAILABLESPACE Pointer ml Node dks Point dj jgk gS ftldk Address 10 gS rFkk
AVAILABLESPACE Linked List dk igyk Node ml Node dks Point dj jgk gS ftldk Address
100 gSA
tc AVAILABLESPACE Linked List ds igys Node dks START dh Linked List esa Add fd;k tkrk
gS] rc START dk igyk Node AVAILABLESPACE ds igys Node dks Point djus yxrk gS] ftldk
Address 10 gS vkSj AVAILABLESPACE dk igyk Node ml Node dks Point djus yxrk gS ftldk
Address 20 gSA blh izdkj ls vc AVAILABLESPACE Linked List igys Node dks NksM nsrk gS vkSj
ml Node dks Point djus yxrk gS ftldk Address 100 gSA bl izdkj ls AVAILABLESPACE
Linked List ls Node Delete gksus ij fdlh vU; Linked List esa u;k Node Insert gksrk gS vkSj fdlh
Linked List ls dksbZ Node Delete gksus ij AVAILABLESPACE Linked List esa u;k Node Insert
gksrk gSA bl iwjs Discussion ds vk/kkj ij ge pkgsa rks fdlh Linked List dks Start djus ds fy, fiNys
i`B ij tks Algorithm mls fuEukuqlkj Hkh fy[k ldrs gSa&
Starting New Linked List Algorithm
//========================================================================
IF START = NULL then

PTR = AVAILABLESPACE
[ Assign that Node to New Linked List which Currently Points
AVAILABLESPACE Linked Lists Pointer. ]
AVAILABLESPACE = AVAILABLESPACE[LINK]
[ Assign Next AVAILABLESPACE NODE to AVAILABLESPACE Pointer. ]
PTR[INFO] = ITEM
[ Insert the ITEM in the INFO Part of the newly Created Node. ]
PTR[LINK] = NULL
[ Insert NULL in the LINK Part of the newly Created Node which is
indicating the end of the Linked List. ]
START = PTR
[ Give the Address of newly created node PTR to START so that START
may point newly created first node PTR of the Linked List. ]
2 EXIT
//========================================================================
Garbage Collection
pwfa d ge tc Hkh fdlh Linked List ls fdlh Data Item dks Delete djrs gSa rks ml Data Item }kjk
Reserve dh xbZ Memory Free gks tkrh gSA bl Free Memory dks okil AVAILABLESPACE
Linked List esa Link djus ds fy, ,d rjhds dh t:jr gksrh gS] ftlls Free gksus okyk lkjk Space
okil fdlh vU; Data Item }kjk Use fd;k tk ldsA ;s dke lkekU;r;k Operating System gekjs fy,
djrk jgrk gSA ;s dke ftl rjhds }kjk gksrk gS ;kuh ftl rjhds }kjk Deleted Nodes ls Free gksus okyk
lkjk Space Reuse ds fy, okil AVAILABLESPACE Linked List esa Collect gksrk jgrk gS] ml
Free Space ds Collection dks Garbage Collection dgk tkrk gSA
Overflow and Underflow

dbZ ckj u;k Node Create djus ds fy, AVAILABLESPACE Linked List esa Space gh ugha gksrk gS
;kuh Free Space List Empty gksrk gSA bl fLFkfr dks lkekU;r;k Overflow dgk tkrk gSA bl fLFkfr esa
AVAILABLESPACE = NULL gksrk gSA
tc ge fdlh Empty Linked List ds Data Item dks Delete djrs gSa] rks ml fLFkfr dks Underflow
dgrs gSaA D;ksfa d bl fLFkfr esa Delete gksus ds fy, dksbZ Data Item ;k Node gksrk gh ugha gSA bl fLFkfr
esa START = NULL gksrk gSA
;fn ge fiNys Algorithm dks Implement djrs gq, dksbZ Program cukuk pkgsa rks gesa
AVAILABLESPACE Linked List dks Manage djus dh dksbZ t:jr ugha gksrh gSA gekjk Computer
Lo;a gh bl Linked List dks Manage o Update djrk jgrk gSA bl fLFkfr esa ge dksbZ ubZ Linked List
Create djus ds fy, bl Algorithm dks fuEukuqlkj Function ds :i esa Implement dj ldrs gSa&
Function
//========================================================================
START = NULL;
//This Declaration is Declared in Main Function
CREATE(struct LIST **NEWNODE, ITEM)
{
struct LIST *temp, *NEWNODE;

if(*PTR == NULL)
//[IF START = NULL ] then Create new NODE
{
temp = (struct LIST *)malloc(sizeof(struct LIST));
temp->INFO = ITEM;
temp->LINK = NULL;
*PTR = temp;
}
}
//========================================================================
bl Function esa Argument Variable NEWNODE ds vkxs nks * fpUg yxs gq, gSaA bldk eryc ;s gS fd
bl Variable esa fdlh vU; Pointer Variable dk Address Store gksxkA
INSERTING New NODE at the End of the LIST

tc fdlh Linked List dh kq:vkr gks pqdh gks ;kuh START = NULL uk gks rc Linked List ds var esa
u;k node Add djus ds fy, gesa fuEu dke djus gksrs gSSa&
1 ,d Structure izdkj dk u;k Pointer Variable ysdj Loop dks rc rd pykrs gSa] tc rd fd
Linked List dk var ugha vk tkrk gSA
2 tc Linked List ds var esa igqap tkrs gSa] rc u;s node dk Address Linked list ds vafre node ds
LINK Part dks NULL ds LFkku ij ns nsrs gSaA
3 u, node ds next dk eku
NULL
dj nsrs gSaA
pwfa d Linked List dh kq:vkr igys gh gks pqdh gS ;kuh START dk eku NULL ugha gS] blfy, lcls
igys rks gesa Linked List ds vUr ij igqapuk gksxkA fdlh Linked List dk vUr ogka gksrk gS tgka
LIST[LINK] = NULL gksrk gSA blds fy, gesa Linked List dh Traversing djuh gksxhA fdlh Linked
List ds lHkh Data Items dks Process djus dh izf;k dks TRAVERSING dgrs gSaA Traversing ds
fy, ge fuEUk Algorithm dk iz;ksx dj ldrs gSa] tgka LIST ,d Linked List gSA START Linked List
dh kq:vkr crkrk gSA INFO Data Element dk Information Part gS vkSj LINK vxys NODE dk
Pointer gSA PTR ,d Pointer gS tks fd Currently Process gks jgs Data Item dks Point djrk gSA
TRAVERSING A One Way Linked List Algorithm
//========================================================================
1 SET PTR = START
[ Initialize Pointer PTR with the Address of START ]
2 REPEAT Step 3 and 4 WHILE PTR <> NULL
3
SET PTR = PTR[LINK]
[ PTR now Points to Next NODE ]
4
PROCESS PTR[INFO]
[ Process the Data of the Node ]
[ End of Step 2 Loop ]
5 EXIT
//========================================================================
pwfa d Linked List dh kq:vkr igys gh gks pqdh gS vkSj gj Linked List dh kq:vkr dk Address
START esa gksrk gS] blfy, gesa ,d Variable PTR esa START ds Address dks ysuk gksxk rkfd ge
START ds eku dks Change fd, fcuk Linked List dh fofHkUu Nodes dks PTR }kjk izkIr dj ldsAa
;fn ge START Pointer }kjk gh Linked List dh Traversing djrs gSa rks gekjh Linked List dh
kq:vkr dks Point djus okyk Variable START dk Address Damage gks tk,xk vkSj fQj ;fn ge
okil ls Linked List dh Traversing djuk pkgsa] rks ge ,lk ugha dj ldsaxsA D;ksafd gekjh Linked List
dh kq:vkr dk Pointer gh Damage gks pqdk gksxk vkSj START gekjh Linked List ds vfUre Node dks
Point dj jgk gksxkA ;kuh ;fn ge START Pointer dk iz;ksx Traversing ds fy, djrs gSa rks ge ,d gh
Traversing esa vius lkjs Nodes dks Damage dj nsaxsA ,lk blfy, gksrk gS D;ksfd gekjs bl
Traversing Algorithm esa START ,d Actual Argument ds :i esa vkrk gSA blfy, ;fn START dk
eku Change fd;k tk, rks okLrfod START dk eku Hkh Change gks tk,xk tks fd ugha gksuk pkfg,A
blhfy, geus PTR esa START dk Address fy;k gS vkSj PTR }kjk Linked List dh Traversing dh gSA
D;ksfa d PTR mlh Node dks Point dj jgk gS ftls START Point dj jgk gSA ge tkurs gSa fd fdlh Hkh
Linked List dk vUr gesa kk LINK = NULL gksus ij gksrk gS] blfy, ,d Loop }kjk Loop ds gj
Iteration ij PTR esa gj vxys Node dk Address Store fd;k x;k gS tc rd fd PTR dk eku
NULL ugha gks tkrkA bl Algorithm dk iz;ksx djds ge fuEukuqlkj ,d Function fy[k ldrs gSa tks
fdlh Linked List ds vUr ij igqaprk gSA
Function
//========================================================================
void GoToEnd(struct LIST **PTR)
{
while(PTR != NULL)
PTR = PTR->LINK;
}
//========================================================================
pwfa d ge fdlh igys ls Created Linked List ds vUr esa ,d u;k NODE Add djuk pkgrs gSa] blfy,
Linked List ds vUr ij igqapus ds ckn gesa ,d u;k Node Create djuk gksrk gS vkSj ml Node dk
Address igys ls cuh gqbZ Linked List ds vfUre Node ds LINK Part esa ftlesa NULL Stored gS] nsuk
gksrk gSA ,lk djus ij Created u;k Node fiNys Node ls Link gks tkrk gSA vUr esa gesa Create gksus
okys u, Node ds Link Part ds LINK dks NULL djuk iMrk gS] ftldk eryc gksrk gS fd bl Node ds
ckn dksbZ Node Linked List ls Linked ugha gSA bl iwjh izf;k dks /;ku ls le>us ij ge ns[k ldrs gSa
fd fdlh igys ls Started Linked List ds vUr esa u;k Node INSERT djus ds fy, gesa nks dke djus
iMrs gSa% igyk ;s fd ge Linked List ds vUr ij igqapsa vkSj nwljk ;s fd ge u, Node dks fiNys Node ls
Link djsAa bu nksuksa dkeksa ds fy, ge fuEukuqlkj ,d gh Algorithm fy[k ldrs gSa&
Algorithm
//========================================================================
1 SET PTR = START
[ Initialize Pointer PTR with the Address of START ]
2 REPEAT Step 3 WHILE PTR <> NULL
3
SET PTR = PTR[LINK]
[ PTR now Points to Next NODE ]
4 CREATE NEWNODE
[ Create new Node from AVAILABLESPACE Linked List ]
5 NEWNODE[INFO] = ITEM
6 NEWNODE[LINK] = NULL
7 PTR[LINK] = NEWNODE
8 EXIT
//========================================================================
bl Algorithm dk iz;ksx djds ge fuEukuqlkj ,d Function cuk ldrs gSa tks fdlh Linked List ds vUr
esa u;k Node INSERT djrk gS&
Function
//========================================================================
INSERT_END(struct LIST **PTR, ITEM)

{
struct LIST *NEWNODE, *temp;
//Go to End of the Linked List
while(temp->LINK != NULL)
temp = temp->LINK;
//Create New Node
NEWNODE = (struct LIST *)malloc(sizeof(struct LIST));
NEWNODE->INFO = ITEM;
NEWNODE->LINK = NULL;
temp->LINK = NEWNODE;
}
//========================================================================
tc ge igyh ckj dksbZ Linked List Create djrs gSa rc okLro esa ge START esa ,d u, Node dk
Address ns jgs gksrs gSa ;kuh ;fn ;s ekuk tk, fd START fdlh igys ls cuh gqbZ Linked List dks Point
dj jgk gS rks Create gksus okyk u;k Node bl Start ds vUr esa tqMrk gSA bl fLFkfr esa ge CREATE()
o INSERT_AT_END() nksuksa Functions dks fuEukuqlkj ,d gh Function ds :i esa fy[k ldrs gSa&
//========================================================================
void INSERT_AT_END(struct LIST **PTR, int ITEM)
{
if(*PTR == NULL)
{
temp->INFO = ITEM;
temp->LINK = NULL;
*PTR = temp;
}
else
{
struct LIST *temp = *PTR;
temp = temp->LINK;
//Create New Node
}
}
//========================================================================
bl Function dk iz;ksx djrs gq, ge fuEukuqlkj ,d Program cuk ldrs gSa&

//========================================================================
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
Structure
//========================================================================
struct LIST
{
//Information Part
int INFO;
//Link Part
struct LIST *LINK;
};
struct LIST *START = NULL;
//========================================================================
Function
//========================================================================
{
if(*PTR == NULL)
{
temp->INFO = ITEM;
temp->LINK = NULL;
*PTR = temp;
}
else
{
temp = temp->LINK;
//Create New Node
}
}
//========================================================================
main() Function
//========================================================================
main()
{
struct LIST *ptr;
char choice= 'y';
int ITEM;
clrscr();
while(choice=='y' || choice=='Y')
{
printf("\n Enter a NUMBER in Information Part : " );

scanf("%d", &ITEM)
INSERT_AT_END(&START, ITEM);
printf("\n Do You wish to Continuous ? Y/N
fflush(stdin);
choice = (char)getchar();
");
}
ptr = START;
while(ptr)
{
printf("\n Inserted Number \t %d", ptr->INFO);
ptr = ptr->LINK;
}
free(ptr);
free(START);
getch();
}
//========================================================================
Output
//=====================================================================
Enter a NUMBER in Information Part : 123123
Do You wish to Continuous ? Y/N
y
y
y
n
Inserted Number
123123
Inserted Number
787878
Inserted Number
989898
Inserted Number
784112
//========================================================================
blh Concept ij ,d vkSj Program fuEukuqlkj gS] ftlesa fo/kkFkhZ;ksa ds Records dks Linked List o
Dynamic Memory Allocation ds ek/;e ls Input fd;k x;k gS] Memory esa Store fd;k x;k gS vkSj
vUr esa lHkh Input fd, x, Data Items dks Display fd;k x;k gS&
Program
//========================================================================
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
struct stud
{
int roll_no;
long int pin_code;
struct stud *next_rec;

};
struct stud *start = NULL;
main()
{
struct stud *newnode,*ptr;
char choice= 'y';
clrscr();
while(choice=='y' || choice=='Y')
{
newnode=(struct stud *)malloc(sizeof(struct stud));
newnode->next_rec=NULL;
printf("\n Enter Roll Number : " );
scanf("%d", &newnode->roll_no);
printf("\n Enter Pincode: ");
scanf("%ld", &newnode->pin_code);
if ( start == NULL)
start = newnode;
else
{
newnode->next_rec = start;
start = newnode;
}
printf("\n Do You wish to Continuous ? Y/N
fflush(stdin);
");
choice = getchar();
}
ptr = start;
while(ptr)
{
printf("\n Roll Number \t %d", ptr->roll_no);
printf("\n Pin Code \t %ld", ptr->pin_code);
ptr = ptr->next_rec;
}
free(ptr);
free(start);
free(newnode);
getch();
}
//========================================================================
Output
//=======================================================================
Enter Roll Number : 1
Enter Pincode: 111111
y
Do You wish to Continuous

? Y/N
? Y/N
? Y/N
? Y/N
Roll Number
5
Pin Code
555555
Roll Number
4
Pin Code
444444
Roll Number
3
Pin Code
333333
Roll Number
2
Pin Code
222222
Roll Number
1
Pin Code
111111
//========================================================================
bl izkx
s zke esa Structure cukus ds ckn Structure esa dksbZ Link List ugha gSA blfy;s Linked List dh
kq:vkr ds start Pointer dks NULL fd;k x;k gSA vko;drkuqlkj dbZ node cukus o mUgsa Linked List
esa tksMus ds fy;s geus while loop dk iz;ksx fd;k gSA bl Loop esa lcls igys ,d Memory Block
cuk;k x;k gS vkSj ml Memory Block dk Address newnode uke ds var dks fn;k x;k gSA fQj
newnode->next_rec=NULL; statement }kjk bl cukbZ xbZ node dks Linked List dk vafre node
cuk;k x;k gSA fQj bl node esa Pointer new }kjk eku Input fd;k x;k gSA if (start = = NULL)
statement }kjk ;s check fd;k tkrk gS fd D;k start dk eku NULL gS ;k ughaA ;s blfy;s check fd;k
tkrk gS D;ksafd ;fn Linked List esa add fd;k tkus okyk node Linked List dk izFke node gS] rks start
dk eku NULL gksrk gSA ;gka Linked List esa Add gksus okyk newnode igyk node gSA blfy;s start dk
eku NULL gh gksxk vkSj if condition lR; gksxhA ;fn if Condition lR; gksrh gS] rks bl node dks Liked
list dk igyk node cukus ds fy;s bl node dk Address start = newnode; statement }kjk start dks
fn;k x;k gSA bl izdkj ls Linked List kq: gks tkrh gSA vc while loop gels iwaNrk gS fd D;k ge vkSj
Records Input djuk pkgrs gSaA ;fn ge ;gka Y Press djrs gSa rks okil ,d Memory Block cukrk gS
vkSj okil ml Memory Block dk Address newnode dks izkIr gksrk gSA bl ubZ node ds Member
nexr_rec dks okil NULL dj fn;k tkrk gSA okil if condition check gksrh gSA pwafd Linked List kq:
gks pqdh gS blfy;s if condition vlR; gks tkrh gS vkSj else ds statements dk Execution gksrk gSA ;gka
newnode->next_rec = start; statement }kjk bl ubZ node ds next_rec esa Stored NULL dks gVk dj
NULL ds LFkku ij start esa fLFkr Address dks Mky fn;k tkrk gS vkSj start = newnode; statement }kjk
start esa u, node dk Address Mky fn;k tkrk gSA bl izdkj ftruh ckj Loop pyrk gS] mruh gh ckj
start esa ml u, node dk Address vk tkrk gS vkSj bl u, node esa next_rec esa ml node dk
Address Mky fn;k tkrk gS] tks fd while loop ds fiNys Iteration esa cuk FkkA Dynamic Memory
Allocation es lkjk dke Allocated Memory ds Address dks store djus okys Pointer }kjk fd;k tkrk
gSA blfy;s Address rc rd c<rk jgrk gS] tc rd fd User eku Input djrk gSA blfy;s okil bu
ekuksa dks read djus ds fy;s ,d Pointer ptr dks Linked List dk igyk Address ;kuh start dk
Address fn;k x;k gS vkSj okil ,d while loop dks rc rd pyk;k x;k gS tc rd fd ptr esa dksbZ eku
gksrk gSA bl izdkj ls start es]a tksMs x, vafre node dk Address gksrk gS] blfy;s printf("\n Roll
Number \t %d", ptr->roll_no); o printf("\n Pin Code \t %ld", ptr->pin_code); statements }kjk izFke
node ds ekuksa dks Print djok;k tkrk gSA fQj ptr = ptr->next_rec statement }kjk ptr vxys node dk
Address store djok;k tkrk gSA loop dh Condition lR; gksrh gS vkSj nwljs node ds eku Screen ij
print gks tkrs gSaA ptr = ptr->next_rec statement vc rhljs node ds ekuksa dks print djrk gSA ;gh e
rc rd pyrk jgrk gS] tc rd fd while loop Terminate uk gks tk, vkSj loop rc Terminate gksrk
gS] tc ptr vafre node ds ekuksa dks print djrk gSA ml le; vafre node ds next_rec dk eku NULL
gksrk gS ;kuh while dk eku while(0) gks tkrk gSA ;gka vkius ns[kk fd tks eku lcls var esa Input fd;k Fkk
og eku lcls igys izkIr gksrk gS vkSj tks eku lcls igys Input fd;k Fkk og eku lcls ckn esa IkzkIr gksrk
gSA bl izf;k dks LIFO (Last In First Out) dgrs gSaA
INSERTING New NODE at the BEGINNING of the LIST

tc dksbZ Linked List igys ls gh Created gks vkSj mldh kq:vkr esa gesa u;k Node Add djuk gks] ;kuh
START esa u, Create fd, x, Node dk Address nsuk gks] rc lcls igys gesa ,d Node Create
djuk gksrk gSA fQj START esa ftl Node dk Address gksrk gS og Address Newly Created Node ds
LINK esa nsuk gksrk gS vkSj START esa Newly Created Node dk Address nsuk gksrk gSA ;s dke djus ds
fy, ge fuEUk Algorithm dk iz;ksx dj ldrs gSa&
Algorithm
//========================================================================
Procedure: ADD_AT_BEGNNING(LIST, ITEM)
SET PTR = START
CREATE NEWNODE
NEWNODE[INFO] = ITEM
NEWNODE[LINK] = PTR
SET START = NEWNODE
EXIT
//========================================================================
bl Algorithm es LIST ,d Linked List gS ftlesa igys ls ,d ;k ,d ls vf/kd Data Items Inserted
gSaA NEWNODE Create gksus okyk u;k Node gSA START esa igys ls cuh gqbZ Linked List dk
Address gSA bl Algorithm dk iz;ksx djds ge fuEukuqlkj ,d Function Create dj ldrs gSa&
//========================================================================
void INSERT_AT_BEGNNING(struct LIST **PTR, int ITEM)
{
struct LIST *NEWNODE;
NEWNODE->LINK = *PTR;
*PTR = NEWNODE;
}
//========================================================================
bl Algorithm dk iz;ksx ge fuEukuqlkj main() Function esa dj ldrs gSa&

Program
//========================================================================
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <stdlib.h>
static int total=0;

//Structure
//========================================================================
struct LIST
{
//Information Part
int INFO;
//Link Part
struct LIST *LINK;
};
//========================================================================
//Function
//========================================================================
{
*PTR = NEWNODE;
total++;
}
//========================================================================
//Function
//========================================================================
{
if(*PTR == NULL)
{
temp->INFO = ITEM;
temp->LINK = NULL;
*PTR = temp;
}
else
{
temp = temp->LINK;
//Create New Node
}
total++;
}
//========================================================================
//Function
//========================================================================
void DISPLAY(struct LIST **PTR)
{
struct LIST *temp;
temp = *PTR;
while(temp != NULL)
{
printf("\n Inserted Number \t %d", temp->INFO);
temp = temp->LINK;
}
}
//========================================================================
//main() Function
//========================================================================
main()
{
char choice;
int ITEM;
clrscr();
while(1)
{
printf("\n1.
Enter Number at the BEGNNING of the LIST");
printf("\n2.
Enter Number at the END of the LIST");
printf("\n3.
Display Data Items");
printf("\n4.
Total Data Items");
printf("\n5.
EXIT");
switch(choice)
{
case 1:
printf("\n Enter a NUMBER at the BEGINNIN of the LIST : " );
scanf("%d", &ITEM);
INSERT_AT_BEGNNING(&START, ITEM);
break;
case 2:
printf("\n Enter a NUMBER at the END of the LIST : " );
scanf("%d", &ITEM);
break;
case 3:
DISPLAY(&START);
break;
case 4:
printf("\nTotal Number of Data Items are %d ", total);
break;
case 5:
exit(1);
}
}
}
//========================================================================
INSERTING New NODE at any MIDDLE Position of the LIST

tc gesa fdlh Linked List ds e/; esa u;k node tksMuk gks] rc gesa fuEu e esa dke djus gksrs gSa&
1 lcls igys gesa ml node rd igqapuk gksrk gS] ftl node ds ckn u;k node Add djuk gSA
2 fQj ubZ node esa mlls vxyh node dk Address store djrs gSaA
3 fiNyh node esa ubZ node dk Address store djrs gSaA
bls izf;k dks fuEu fp=kuqlkj le> ldrs gSa&
Structure1
Item1
Structure2
Item2
Structure3
Item3
Next
NULL
newnode
bl dke ds fy, ge fuEu Algorithm fy[k ldrs gSa&

//========================================================================
INSERT_AT_MIDDLE(INFO, LINK, LOCATION, ITEM)
1 CREATE NEWNODE
2 NEWNODE[INFO] = ITEM
3 IF LOCATION = NULL then
SET NEWNODE[LINK] = START
SET START = NEWNODE
ELSE
SET NEWNODE[LINK] = LOCATION[LINK]
SET LOCATION[LINK] = NEWNODE
4 EXIT
//========================================================================
bl Algorithm dk iz;ksx djds ge fuEukuqlkj Function fy[k ldrs gSa&

Function
//========================================================================
void INSERT_AT_MIDDLE(struct LIST **PTR, int ITEM, int LOCATION)
{
int i;
temp = *PTR;
for(i=0; i<LOCATION; i++)

{
temp = temp->LINK;
if(temp == NULL)
{
printf("\nData Items are Less then LOCATION\n");
return;
}
}
NEWNODE->LINK = temp->LINK;
total = COUNT(&START);
}
//========================================================================
bu lHkh Algorithms dk iz;ksx djds Functions Create djus ds ckn mls Main() Function esa ge
fuEukuqlkj Use dj ldrs gSa&
Program
//========================================================================
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <stdlib.h>
static int total=0;
//Structure
//========================================================================
struct LIST
{
//Information Part
int INFO;
//Link Part
struct LIST *LINK;
};
//========================================================================
//Function
//========================================================================
int COUNT(struct LIST **PTR)
{
int i = 1;
struct LIST *temp;
temp = *PTR;
{
temp = temp->LINK;
i++;
}
return i;
}
//========================================================================
//Function
//========================================================================
{
*PTR = NEWNODE;
}
//========================================================================
//Function
//========================================================================
void INSERT_AT_MIDDLE(struct LIST **PTR, int ITEM, int LOCATION)
{
int i;
temp = *PTR;
for(i=0; i<LOCATION; i++)
{
temp = temp->LINK;
if(temp == NULL)
{
printf("\nData Items are Less then LOCATION\n");
return;
}
}
NEWNODE->LINK = temp->LINK;
}
//========================================================================
//Function
//========================================================================
{
if(*PTR == NULL)
{
temp->INFO = ITEM;
temp->LINK = NULL;
*PTR = temp;
}
else
{
temp = temp->LINK;
//Create New Node
}
}
//========================================================================
//Function
//========================================================================
void DISPLAY(struct LIST **PTR)
{
struct LIST *temp;
temp = *PTR;
while(temp != NULL)
{
printf("\n Inserted Number \t %d", temp->INFO);
temp = temp->LINK;
}
}
//========================================================================
//main() Function
//========================================================================
main()
{
char choice;
int ITEM, LOCATION;
clrscr();
while(1)
{
printf("\n1.
printf("\n2.
printf("\n3.
printf("\n4.
printf("\n5.
printf("\n6.
Enter Number at the BEGINNING of the LIST");

Enter Number after the Specified LOCATION of the LIST");
Enter Number at the END of the LIST");
Display Data Items");
Total Data Items");
EXIT");
printf("\n\nEnter Your CHOICE");

switch(choice)
{
case 1:
printf("\n Enter a NUMBER at the BEGINNING of the LIST : " );
scanf("%d", &ITEM);
INSERT_AT_BEGNNING(&START, ITEM);
break;
case 2:
printf("\n Enter a NUMBER at the MIDDLE of the LIST : " );
scanf("%d", &ITEM);
printf("\nEnter LOCATION Number : ");
scanf("%d", &LOCATION);
INSERT_AT_MIDDLE(&START, ITEM, LOCATION);
break;
case 3:
printf("\n Enter a NUMBER at the END of the LIST : " );
scanf("%d", &ITEM);
break;
case 4:
DISPLAY(&START);
break;
case 5:
printf("\nTotal Number of Data Items are %d ", total);
break;
case 6:
exit(1);
}
}
}
//========================================================================
Searching in a Linked List

ftl rjg ls fdlh Array esa ls ;fn fdlh Data Item dks Search djus ds nks rjhds gSa mlh rjg ls fdlh
Linked List esa ls Hkh fdlh Data Item dks Search djus ds nks rjhds gksrs gSaA ekuyks fd LIST ,d
Linked List gS vkSj ITEM og Item gS ftls Search djuk gS vkSj LOCATION og Memory Location
gS tgka ij Search fd;k tkus okyk ITEM igyh ckj izkIr gksrk gSA ,d Linked List esa ,d gh izdkj ds
eku dbZ ckj dbZ LOCATIONS ij gks ldrs gSaA ;gka igys Algorithm esa ;s ekuk x;k gS fd ftl LIST
esa ls ITEM dh LOCATION dks Search fd;k tk jgk gS og LIST Sorted ugha gSA nwljs Algorithm esa
;s ekuk tk jgk gS fd LIST SORTED gS ftlesa ls Data Items dh LOCATION dks Search djuk gSA
ge ;s Hkh eku dj py jgs gSa fd tks Data Item Search fd;k tk jgk gS og LIST esa dsoy ,d gh ckj
Store gks ldrk gS ;kuh Stored Data Item Unique gSA
LIST is Unsorted
ekuyks fd ge ftl LIST esa Data ITEM dks Search dj jgs gSa og LIST Sorted ugha gSA bl fLFkfr esa
gesa LIST ds gj Data Item PTR[INFO] dks ,d PTR Pointer ls Traversing }kjk Search fd, tk jgs
ITEM ls Check djuk gksxkA ;kuh
IF PTR[INFO] == ITEM then
SET LOCATION = PTR
ELSE
PTR = PTR[LINK]
bl Algorithm esa gesa nks Test djus gksaxs ftlesa igyk Test ;s r; djsxk fd Loop dc rd pysxkA ;kuh
Loop rc rd pyuk pkfg, tc rd fd PTR esa NULL uk vk tk, vkSj nwljk Test ;s Check djsxk fd
tks ITEM Search fd;k tk jgk gS og LIST esa miyC/k gS ;k ughaA ;fn ITEM LIST esa miyC/k gks rks
ITEM dh LOCATION Return gksuh pkfg, vU;Fkk ,d Message Display gksuk pkfg, tks crk, fd
Search fd;k tkus okyk ITEM LIST esa miyC/k ugha gSA blh iwjh izf;k dk Algorithm ge fuEukuqlkj
fy[k ldrs gSa&
UNSORTED SEARCHING Algorithm
//========================================================================
UNSORTED_SEARCHING(LIST, LINK, INFO, ITEM, LOC, PTR)
1
2
3
SET PTR = START

REPEAT Step 3 and 4 WHILE PTR <> NULL
IF PTR[INFO] == ITEM then
SET LOC = PTR and EXIT
ELSE
PTR = PTR[LINK]
[ Now PTR Points next NODE ]
[ End of IF Structure ]
[ End of Loop Step 2 ]
4 SET LOC = NULL
[ If Search is Unsuccessful ]
5 EXIT
//========================================================================
bl Algorithm ds vk/kkj ij ge fuEukuqlkj ,d Function cuk ldrs gSa tks fdlh Linked List esa ls fdlh
ITEM dks Search djrk gS vkSj ;fn ITEM izkIr gks tkrk gS rks mldh LOCATION Return djrk gSA
;fn ITEM izkIr ugha gksrk gS rks LOCATION esa NULL Store gks tkrk gS] ftldk eryc gksrk gS fd List
esa Find fd;k tkus okyk ITEM miyC/k ugha gSA
UNSORTED SEARCH Function
//========================================================================
void SEARCH(struct LIST **PTR, int ITEM)
{
struct LIST *temp;
int LOCATION=0 ;
temp = *PTR;
clrscr();
while(temp != NULL)
{
LOCATION++;
if(temp->INFO == ITEM)
{
printf("\nSearched Data Element Found at the %d LOCATION \n", LOCATION);
return ;
}
else
temp = temp->LINK;
}
printf("\nData Item Not Found In The LIST \n");
}
//========================================================================
LIST is Sorted
ftl LIST esa ls Data Item dh Location dks Search fd;k tk jgk gS og LIST ;fn SORTED gks rks
ge fuEu Algorithm dk iz;ksx djds Find dh tkus okyh ITEM dh LOCATION dk irk yxk ldrs gSaA
bl Algorithm esa Hkh gesa LIST ds gj Node dks ITEM ls Test djuk iMrk gSA ;kuh bl Algorithm dh
Complexity o fiNys Algorithm dh Complexity leku gksrh gSA ;kuh ;fn ge fdlh Linked List ij
Binary Search Algorithm dk iz;ksx djds fdlh Data dh LOCATION izkIr djuk pkgsa rks ge ,lk
ugha dj ldrs gSaA ,d Linked List dh Binary Searching ugha dh tk ldrh gSA
SORTED SEARCH Algorithm
//=========================================================================
SORTED_SEARCH(LIST, LINK, INFO, ITEM, LOC)
SET PTR = START
REPEAT Step 3 WHILE PTR <> NULL
IF ITEM < PTR[INFO] then
SET PTR = PTR[LINK]
[ Now PTR points to next NODE ]
ELSEIF ITEM = PTR[INFO] then
SET LOCATION = PTR and EXIT
[ Search is Successful ]
ELSE
SET LOCATION = NULL and EXIT [ ITEM not Exists in LIST ]
EXIT
//=========================================================================
bl Algorithm dk iz;ksx djds ge fuEukuqlkj ,d Function Create dj ldrs gS&

sa
SORTED SEARCH Function
//========================================================================
void SEARCH2(struct LIST **PTR, int ITEM)
{
struct LIST *temp;
int LOCATION=0 ;
temp = *PTR;
clrscr();
while(temp != NULL)
{
LOCATION++;
if(ITEM < temp->INFO)
temp = temp->LINK;
else if(temp->INFO == ITEM)
{
printf("\nSearched Data Element Found at the %d LOCATION \n", LOCATION);
getch();
clrscr();
return ;
}
else
{
printf("\nData Item Not Found In The LIST \n");
getch();
clrscr();
return ;
}
}
getch();
clrscr();
}
//========================================================================
Sorting
ftl rjg ls ge ,d Array Data Structure dh Sorting dj ldrs gSa mlh rjg ls ge fdlh Linked List
ds fofHkUu Data Items dh Hkh Sorting dj ldrs gSaA fdlh Linked List dh Sorting djus ds fy, ge
fdlh Hkh Standard Algorithm dk iz;ksx dj ldrs gSaA ge tkurs gSa fd tc fdlh Data Structure dh
Sorting dh tkrh gS rc ,lh fLFkfr vkrh gS fd gesa nks Data Elements dks vkil esa Exchange djuk
iMrk gSA fdlh Linked List dh Sorting ds fy, tc gesa Data Elements dks Exchange djuk gksrk gS
rc gekjs ikl gesakk nks rjhds gksrs gSa% fdlh Linked List dh Sorting ds fy, ;fn ge pkgsa rks fofHkUu
Nodes ds Data Elements dks Exchange dj ysa vkSj ;fn pkgsa rks Nodes ds LINK dks vkil esa
Change dj ysaA nksuksa gh rjhdksa esa Linked List dh Sorting gks tkrh gSA bl izf;k dks le>us ds fy,
fuEu fp= nsf[k, ftlesa nksuksa rjhdksa dks vyx&vyx nkkZ;k x;k gS&
ekuyks fd bl Linked List esa Element 10 o 4 dks Exchange djuk gSA ;gka ij dsoy eku 4 ds LFkku
ij 10 o 10 ds LFkku ij eku 4 dh Swapping gks tk,xh ysfdu first o second }kjk Pointed
Address esa fdlh rjg dk dksbZ ifjorZu ugha gksxkA bl izf;k dks ge fp= esa Hkh ns[k ldrs gSa fd INFO
Part esa ekuksa dk ifjorZu gqvk gS ysfdu LINK Part ds Addresses dk ifjorZu ugha gqvk gSA
nwljs rjhds esa Data ds eku esa dksbZ ifjorZu ugha gqvk gSA cfYd LINK Part ds Addresses esa ifjorZu gqvk
gSA bls fuEUk fp= esa ns[k ldrs gSaA
bu nksuksa gh rjhdksa esa igyk rjhdk mi;ksx esa ysuk ljy gS tcfd nwljk rjhdk igys dh rqyuk esa vf/kd
Efficient gSA ,lk blfy, gS D;ksfa d ;fn INFO Part esa dksbZ Record gks ftlesa dkQh vf/kd Fields gksa rks
Sorting ds le; iwjs Record dks Exchange djuk gksxk tks fd vf/kd Time o Space Occupy djsxk]
tcfd nwljs rjhds esa dsoy LINK Part dks gh Exchange djuk gksxkA fdlh Linked List ds fy,
Bubble Sort dk Algorithm fuEukuqlkj gksxk&
Bubble Sort Algorithm DATA PART
//========================================================================
1 SET K = N
2 REPEAT FOR I = 0 TO N-1 STEP I = I + 1
3
P = START
4
Q = P[LINK]
5
REPEAT FOR J = 1 TO K-1 STEP J = J + 1
6
IF P[INFO] > Q[INFO]
7
TEMP = P[INFO]
8
P[INFO] = Q[INFO]
9
Q[INFO] = TEMP
10
P = P[LINK]
11
Q = Q[LINK]
12 EXIT
//========================================================================
bl Algorithm esa N Data Elements ;k NODES dh dqy la[;k gSA I o J Loop pykus okys Variables
gSaA TEMP ,d Variable gS tks Data Exchanging ds le; mi;ksx esa vkrk gSA P o Q nks Linked
Lists gSa vkSj K ,d Variable gS ftldk eku N dh la[;k ij fuHkZj gSA bl Algorithm ds vk/kkj ij ge
fuEukuqlkj Bubble Sort dk Function Create dj ldrs gSa tks fdlh Linked List ds Data Elements
dh Sorting djrk gS&
Bubble Sort Function DATA PART
//========================================================================
void LLBubbleSortDP(int N)
{
int I, J, K, TEMP;
struct LIST *P, *Q;
K = N;
for(I=0; I<N-1; I++)
{
P = START;
Q = START->LINK;
for(J=1; J<K; J++)
{
if(P->INFO > Q->INFO)
{
TEMP = P->INFO;
P->INFO = Q->INFO;
Q->INFO = TEMP;
}
P = P->LINK;
Q = Q->LINK;
}
}
//========================================================================
bl Function esa START Linked List ds Start dks Indicate djrk gS tks fd ,d Global Variable gSA
fdlh Linked List dh Sorting ds fy, ge Selection Sort Method dk Hkh iz;ksx dj ldrs gSaA
Selection Sort dk Algorithm fuEukuqlkj fy[kk tk ldrk gS&
Selection Sort Algorithm DATA PART
//========================================================================
1 P = START
2 REPEAT FOR I = 0 TO N-1 STEP I = I + 1
3
Q = P[LINK]
4
REPEAT FOR J = I + 1 TO J < N STEP J = J + 1
5
6
TEMP = P[INFO]
7
P[INFO] = Q[INFO]
8
Q[INFO] = TEMP
9
Q = Q[LINK]
10
P = P[INFO]
11 EXIT
//========================================================================
bl Algorithm dk mi;ksx djds ge fuEukuqlkj Selection Sort dk Function fy[k ldrs gSa&
Selection Sort Function DATA PART
//========================================================================
void LLSelectionSortDP(int N)
{
int I, J, K, TEMP;
struct LIST *P, *Q;
P = START;
for(I=0; I<N-1; I++)
{
Q = START->LINK;
for(J=I+1; J<N; J++)
{
{
TEMP = P->INFO;
P->INFO = Q->INFO;
Q->INFO = TEMP;
}
Q = Q->LINK;
}
P = P->LINK;
}
//========================================================================
ge ns[k ldrs gSa Array Data Structure o Linked List Data Structure nksuksa esa gh Sorting ds
Algorithm leku gh gSaA dsoy fy[ks tkus okys Syntax esa gh vUrj gksrk gSA ;s nksuksa Functions NODES
ds INFO Part dh Exchanging ij vk/kkfjr gSaA ;kuh bl Sorting esa gesa Node ds INFO Part dh
Exchanging djuh iMrh gSA pwfa d Linked List Data Structure ds INFO Part esa ,d ls vf/kd Fields
gks ldrs gSaA ,ls esa ;fn ge bl rjhds dks Use djrs gSa rks gesa INFO Fields ds lHkh Data Elements dks
Exchange djuk iMrk gSA tSls ekuyks fd fuEukuqlkj ,d Structure gS ftlds INFO Part esa fdlh
Book dh fofHkUu Information gSaA
Structure
//========================================================================
struct Book
{
char name[20];
int price;
int pages;
int isbn_no;
};
//========================================================================
;fn bl Structure ds fofHkUu Nodes dh Sorting djuh gks rks gesa fuEukuqlkj Exchanges djus gksaxs&
Outlines:
//========================================================================
//Exchanging of Data Part
strcpy(TEMP.name, P->name);
strcpy(P->name, Q->name);
strcpy(Q->name, TEMP.name);
TEMP.price = P->price;
P->price = Q->price;
Q->price = TEMP.price;
TEMP.pages = P->pages;
P->pages = Q->pages;
Q->pages = TEMP.pages;
TEMP.isbn_no = P->isbn_no;
P->isbn_no = Q->isbn_no;
Q->isbn_no = TEMP.isbn_no;
//========================================================================
ge le> ldrs gSa fd INFO Part esa ftrus vf/kd Data Items gksx
a s] gesa mrus gh T;knk Exchanges
djus iMsaxsA ysfdu bl leL;k ls cpus dk ,d rjhdk gS vkSj og ;s gS fd ge INFO Part ds Data Items
dks Exchange djus ds ctk; muds LINK Part ds LINK dks Exchange dj nsaA LINKS dks Exchange
djds Sorting djus ds fy, ge fuEu Algorithm dk iz;ksx dj ldrs gSa&
Bubble Sort Algorithm LINK PART
//========================================================================
Here LIST is a Linked List Data Type and P, Q, R, S and TEMP are Linked
Lists. START is a LIST Type Global Linked List Variable.
SET S = NULL
REPEAT Step 3 to 5 WHILE S <> START[LINK]
SET R = P = START
SET Q = P[LINK]
REPEAT Step 6 and 7 WHILE P <> S
IF P = START
TEMP = Q[LINK]
Q[LINK] = P
P[LINK] = TEMP
SET START = Q
SET R = Q
ELSE
TEMP = Q[LINK]
Q[LINK] = P
P[LINK] = TEMP
R[LINK] = Q
R = Q
[ End of Inner IF Structure ]
ELSE
SET R = P
SET P = P[LINK]
[End of Outer IF Structure ]
SET Q = P[LINK]
8
9
IF Q = S
SET S = P
[ End of Inner WHILE Loop ]
[ End of Outer WHILE Loop ]
10 EXIT
//========================================================================
bl Algorithm ds vk/kkj ij ge fuEukuqlkj ,d Function Create dj ldrs gSa tks fd fdlh Linked List
dh Sorting ds fy, Use fd;k tk ldrk gS&
Bubble Sort Function LINK PART
//========================================================================
void LLBubbleSortLP()
{
struct LIST *P, *Q, *R, *S, *TEMP ;
S = NULL;
while(S != START->LINK)
{
R = P = START;
Q = P->LINK;
while(P != S)
{
if( P->INFO > Q->INFO )
{
if( P == START )
{
TEMP = Q->LINK;
Q->LINK = P;
P->LINK = TEMP;
START = Q;
R = Q;
}
else
{
TEMP = Q->LINK;
Q->LINK = P;
P->LINK = TEMP;
R->LINK = Q;
R = Q;
}
}
else
{
R = P;
P = P->LINK;
}
Q = P->LINK;
If( Q == S )
S = P;
}
}
}
//========================================================================
blh rjg ls ge Selection Sort dk Algorithm fy[k dj ml Algorithm ds vk/kkj ij ,d Function

Create dj ldrs gSaA Algorithm o Function fuEukuqlkj gSa&
Selection Sort Algorithm LINK PART
//========================================================================
Here LIST is a Linked List Data Type and P, Q, R, S and TEMP are Linked
Lists. START is a LIST Type Global Linked List Variable.
1
2
3
SET P = R = START
REPEAT Step 3 and 4 WHILE P[LINK] <> NULL
S = Q = P[LINK]
4
5
REPEAT Step 5 to 7 WHILE Q <> NULL

IF P[INFO] = Q[INFO]
IF P[LINK] = Q
IF P = START
P[LINK] = Q[LINK]
Q[LINK] = P
TEMP = P
P = Q
Q = TEMP
START = P
R = P
S = Q
Q = Q[LINK]
ELSE
P[LINK] = Q[LINK]
Q[LINK] = P
R[LINK] = Q
TEMP = P
P = Q
Q = TEMP
S = Q
Q = Q[LINK]
ELSE
IF P = START
TEMP = Q[LINK]
Q[LINK] = P[LINK]
P[LINK] = TEMP
S[LINK] = P
TEMP = P
P = Q
Q = TEMP
S = Q
Q = Q[LINK]
START = P
ELSE
TEMP = Q[LINK]
Q[LINK] = P[LINK]
P[LINK] = TEMP
R[LINK] = Q
S[LINK] = P
TEMP = P
P = Q
Q = TEMP
S = Q
Q = Q[LINK]
ELSE
S = Q
Q = Q[LINK]
6 R = P
7 P = P[LINK]
8 EXIT
//========================================================================
Selection Sort Function LINK PART

//========================================================================
void LLSelectionSortLP()
{
struct LIST *P, *Q, *S, *R, TEMP;
P = R = START;
while(P->LINK != NULL)
{
S = Q = P->LINK;
while(Q!=NULL)
{
{
if(P->LINK == Q)
{
if(P==START)
{
P->LINK = Q->LINK;
Q->LINK = P;
TEMP = P;
P = Q;
Q = TEMP;
START = P;
R = P;
S = Q;
Q = Q->LINK;
}
else
{
P->LINK = Q->LINK;
Q->LINK = P;
R->LINK = Q;
TEMP = P;
P = Q;
Q = TEMP;
S = Q
Q = Q->LINK;
}
}
else
{
if(P==START)
{
TEMP = Q->LINK;
Q->LINK = P->LINK;
P->LINK = TEMP;
S->LINK = P;
TEMP = P;
P = Q;
Q = TEMP;
S = Q;
Q = Q->LINK;
START = P;
}
else
{
TEMP = Q->LINK;
Q->LINK = P->LINK;
P->LINK = TEMP;
R->LINK = Q;
S->LINK = P;
TEMP = P;
P = Q;
Q = TEMP;
S = Q;
Q = Q->LINK;
}
}
}
else
{
S = Q;
Q = Q->LINK;
}
}
R = P;
P = P->LINK;
}
}
//========================================================================
Inserting into a Sorted Linked List

ekuyks fd ITEM dks fdlh Sorted Linked List esa Insert djuk gSA bl fLFkfr esa ITEM dks nks Nodes A
o B ds chp Insert djuk gksxkA ;kuh
A[INFO] < ITEM
AND
B[INFO] >= ITEM
bl Operation ds fy, gesa lcls igys ml LOCATION ij igqapuk gksrk gS tgka ds ITEM dk eku
A[INFO[] ds eku ls rks vf/kd gS ysfdu B[INFO] ds eku ls de ;k cjkcj gSA ;s dke djus ds fy, gesa
,d Pointer Variable PTR ysuk gksrk gS vkSj ITEM ds eku dks PTR[INFO] }kjk LIST ds gj Node ds
INFO ls Compare djuk gksrk gSA Linked List dh Traversing ds le; Hkh dqy fdrus Nodes Travers
gks pqds gSa bldh tkudkjh Hkh j[kuh gksrh gSA ;s tkudkjh ge ,d Pointer Variable SAVE }kjk j[krs gSa
fd fdrus Data Elements ;k NODES Travers fd, tk pqds gSaA SAVE p PTR dks Loop ds gj
Iteration esa Assignment }kjk Update fd;k tkrk gSA ;kuh
SAVE = PTR
PTR = PTR[LINK]
SAVE
PTR
;s Traversing rc rd pyrh gS tc rd PTR[INFO] > ITEM gksrk gSA tSls gh ITEM <= PTR[INFO]
gks tkrk gS] Traversing :d tkrh gSA Traversing :dus ds ckn PTR Node B dks Point djrk gS vkSj
Node A esa LOCATION Number gksrk gSA ;fn LIST Empty gksrk gS ;k ITEM < START[INFO] gksrk
gS rc LOCATION = NULL gksrk gSA bldk Algorithm ge fuEukuqlkj fy[k ldrs gSa&
Algorithm
//========================================================================
FINDA(INFO, LINK, START, ITEM, LOCATION)

This Procedure finds the location LOCATION of the last node in a sorted LIST
such that LOCATION[INFO] < ITEM or Sets LOCATION = NULL
1
2
3
4
5
6
7

[ LIST is Empty ]
SET LOCATION = NULL and RETURN
IF ITEM < START[INFO] then
SET LOCATION = NULL and RETURN
SET SAVE = START and PTR = START[LINK]
[ Initialize Pointers ]
IF ITEM < PTR[INFO] then
SET LOCATION = SAVE and RETURN
8 SET SAVE = PTR and PTR = PTR[LINK]
[ Update Pointers ]
9 SET LOCATION = SAVE
10 EXIT
//========================================================================
Deleting from a Linked List

fdlh Linked List esa fdlh Node ds Deletion Steps dks Perform djus ls igys gesa dqN ckrksa dks /;ku
esa j[kuk gksrk gSA
;fn Linked List Empty gks rks fdlh Node dk Deletion lEHko ugha gksrk gSA bl fLFkfr esa Output
esa Underflow Message Print gksuk pkfg,A
ftl Recoded ds Node dks Delete djuk gksrk gS] igys ml Node rd igqapus ds fy, Traversing
djuh iMrh gSA blfy, fdlh Linked List esa rc rd ml Record dks Find djuk gksrk gS tc
rc fd Delete gksus okyk Record izkIr uk gks tk,A bl dke ds fy, gesa gj fiNys Node ds
Address dks Preserve djds j[kuk gksrk gSA
;fn Traversing ds nkSjku ge Linked List ds vUr rd igqap tk,a vkSj tks Record Delete djuk gS]
og izkIr uk gks] rks Item not found dk Message Output esa Display gksuk pkfg,A
Item ds List esa izkIr gks tkus ds ckn mls Delete djuk gksrk gS vkSj Delete gksus okys Item ds
Space dks Free djuk gksrk gS rkfd og Space AVAILABLESPACE Linked List esa Add gks
ldsA ;fn ge Space dks Free ugha djrs gSa] rks gekjh Linked List }kjk yh tkus okyh Space
AVAILABLESPACE Linked List esa miyC/k ugha gksrh gSA ;kuh gekjh Node }kjk tks Space
Reserve fd;k x;k Fkk oks Space rc Hkh Reserve jgrk gS tcfd ml Space dks Reserve
djus okys Node dks Delete fd;k tk pqdk gksrk gSA
ftl rjg ls ge fdlh Linked List esa rhu rjhds ls Data Elements ds Nodes dks Insert dj ldrs gSa]
mlh rjg ls ge fdlh Linked List ls fdlh Node dks rhu rjg ls Delete Hkh dj ldrs gSaA
Deletion of First Node
ekuyks fd gekjs ikl fuEukuqlkj dksbZ Linked List LIST gS ftlesa ikap Nodes Node1, Node2, Node3,
Node4 o Node5 gSa vkSj gesa bl Linked List ds igys Node Node1 dks Delete djuk gSA
ge tkurs gSa fd fdlh Hkh Linked List esa START Pointer gesakk Linked List dh kq:vkr ds igys Node
dks Point djrk gSA ;kuh START esa Linked List ds igys Node dk Address gksrk gSA ;fn ge bl
Linked List esa ls izFke Node dks Delete djuk pkgrs gSa rks gesa dsoy bruk djuk gS fd ge START esa
nwljs Node dk Address Insert dj nsaA ;kuh ;fn START Pointer esa Node1 ds Address ds LFkku ij
Node2 dk Address Store gks tk,] rks izFke Node bl Linked List LIST ls Free gks tk,xkA vc bl
Free Node Node1 }kjk Reserved Memory dks AVAILABLESPACE Linked List esa Add djuk
gksxkA ;s dke gekjk Operating System dj ysrk gSA
START Pointer esa Node2 dk Address nsus ds ckn START Pointer Node2 ds Address 200 dks
Point djsxkA ;kuh vc Node1 Free gks pqdk gSA blfy, blds Space dks vc Free fd;k tk ldrk gSA
Node1 Delete djus ds ckn vc gekjh LIST fuEukuqlkj gksrh gS&
vc ,d vkSj fLFkfr gekjs lkeus vkrh gS fd ;fn Linked List esa ,d Hkh Node uk gks rks D;k gksxkA ;fn
LIST esa ,d Hkh Node uk gks rks ge dg ldrs gSa fd LIST Empty gSA bl fLFkfr esa gesa Output esa ,d
Underflow Message nsuk gksxkA bl iwjs Discussion ds vk/kku ij fdlh Linked List LIST ds izFke
Node dks Delete djus ds fy, ge fuEukuqlkj Algorithm Create dj ldrs gSa&
First Node Deletion Algorithm
//========================================================================
DELETE_FIRST_NODE(LIST, INFO, LINK, START, AVAILABLESPACE)

1
2
3

PRINT Underflow, LIST is Empty and EXIT
PTR = START
AVAILABLESPACE = START [Give First Node to AVAILABLESPACE Linked List]
4 START = PTR[LINK]
[Give Address of Second Node of the LIST to START]
5 EXIT
//========================================================================
bl Algorithm ds vk/kkj ij ge fuEukuqlkj ,d Function Create djds fdlh Linked List ds izFke
Node dks Delete dj ldrs gSa&
First node Deletion Function
//========================================================================
void DeleteFirstNode(struct LIST **START)
{
struct LIST *PTR;
if(*START == NULL)
{
printf("\nUnderflow, LIST is Empty");
return ;
}
PTR = *START;
*START = PTR->LINK;
free(PTR);
}
//========================================================================
Deletion of Last Node

tc gesa fdlh Linked List ds vfUre Node dks Delete djuk gksrk gS rc lcls igys gesa Traversing
djds Linked List ds dqy Nodes dh la[;k n Kkr djuh iMrh gS rkfd gesa irk py lds ds Linked List
esa dqy Nodes dh la[;k fdruh gSA tc gesa Traversing djds dqy Nodes dh la[;k n irk py tkrh gS
mlds ckn gesa okil ls ,d Loop dks n-1 ckj pykuk gksrk gS rkfd ge vfUre Node ls fiNyh okyh
Node rd igqap ldsaA fQj gesa bl Node ds LINK Part esa NULL Assign djuk gksrk gSA tSls gh ge
Second Last Node ds LINK Part esa NULL Assign djrs gSa] Linked List dk vfUre Node Free gks
tkrk gSA vc bl Free Node ds Space dks AVAILABLESPACE Linked List dks iznku djuk gksrk gSA
bl iwjh izf;k dk Algorithm ge fuEukuqlkj fy[k ldrs gSa&
Last Node Deletion Algorithm
//========================================================================
DELETE_LAST_NODE(LIST, INFO, LINK, START, AVAILABLESPACE, COUNTNODE)
SET PREPTR = START

[ Initialize Address of START to PREPTR ]
SET PTR = START[LINK]
SET COUNTNODE = 0
[ Set Counter to 0 ]
IF PREPTR = NULL then
PRINT Underflow, LIST is Empty and RETURN
REPEAT WHILE PREPTR <> NULL
[Traverse LIST until PREPTR <> NULL]
PTR = PTR[LINK]
PREPTR = PREPTR[LINK]
COUNTNODE = COUNTNODE + 1
SET PREPTR = START
[ Initialize Address of START to PTR Again ]
SET PTR = START[LINK]
REPEAT FOR I = COUNTNODE To 1 STEP SIZE I = I - 1
PREPTR = PREPTR[LINK]
PTR = PTR[LINK]
IF COUNTNODE = 1
PREPTR[LINK] = PTR[LINK]
AVAILABLESPACE[LINK] = PTR[LINK]
EXIT
//========================================================================
bl Algorithm ds vk/kkj ij ge fuEukuqlkj ,d Function Create djds fdlh Linked List ds vfUre
Node dks Delete dj ldrs gSaA
Last Node Deletion Function
//========================================================================
void DeleteLastNode(struct LIST **START)
{
int COUNTNODE = 0;
struct LIST *PTR, *PREPTR;
PREPTR = *START;
PTR = PREPTR->LINK;
if(PREPTR==NULL)
{
printf("\nUnderflow, LIST is Empty");
return;
}
while(PTR)
{
PTR = PTR->LINK;
PREPTR = PREPTR->LINK;
COUNTNODE = COUNTNODE + 1;
printf("\nTotal Nodes are %d ", COUNTNODE);

PREPTR = *START;
PTR = PREPTR->LINK;
while(COUNTNODE != 1)
{
PTR = PTR->LINK;
PREPTR = PREPTR->LINK;
COUNTNODE = COUNTNODE - 1 ;
}
if(COUNTNODE == 1)
{
PREPTR->LINK = PTR->LINK;
free(PTR);
}
PREPTR = *START;
PTR = PREPTR->LINK;
printf("\nAfter Deleting Node, LIST is as Follows \n");
while(PTR)
{
printf("\n0x%x", PTR);
printf("%d", PTR->INFO);
PTR = PTR->LINK;
}
}
//========================================================================
Deletion Any NODE from a Linked List

vHkh rd geus nks rjhdksa ls fdlh Linked List ds izFke o vfUre Node dks Delete djus ds rjhds dks
le>k o mudks Use djus ds fy, muds Algorithm ds vk/kkj ij Function Develop fd,A vc ge
rhljk rjhdk le>sx
a s ftlesa fdlh Linked List ds fdlh e/; ds Node dks Delete djuk gksrk gSA okLro
esa ge dHkh Hkh ;s ugha tku ldrs fd ge ftl Data Element ds Node dks Delete djuk pkgrs gSa og
Linked List ds izFke Node ij gh gS ;k vfUre Node ijA ;kuh vHkh rd geus tks Hkh dqN fdlh Node
ds Deletion ds ckjs esa lh[kk] og dsoy Deleting izf;k dks le>us ds fy, FkkA tc okLro esa gesa fdlh
Application Software esa ls fdlh Data Element ds Node dks Delete djuk gksrk gS] rc ge nks rjhdksa
ls fdlh Node dks Search djds Delete djrs gSaA igys rjhds esa ge ,d Key dk iz;ksx djds ml
Record dks Search djrs gSa ftls ge Delete djuk pkgrs gSa vkSj nwljs rjhds esa ge ,d Node Number
Key ds :i esa Use djrs gSa vkSj ml Number okys Node dks Delete dj nsrs gSaA ;kuh ;fn gesa fdlh
LIST ds pkSFks Node dks Delete djuk gS] rks ge 4 Input djrs gSaA fdlh Hkh Linked List ls fdlh Node
dks Delete djus dk ;gh rjhdk izk;ksfxr rkSj ij viuk;k tkrk gSA
vHkh rd geus ftu nks rjhdksa ls
gS] mu nksuksa rjhdksa dk iz;ksx vc
esa ls tks Hkh Node Delete gksuk
bl izf;k dks le>us dh dksfkk
fdlh Linked List ds fdlh Node dks Delete djus dk rjhdk viuk;k
bl rjg ls fd;k tk,xk fd fdlh Linked List ds izFke] e/; ;k vfUre
pkfg, og Requirement ds vuqlkj Node Delete gks tkrk gSA pfy,]
djrs gSaA
ekuyks fd LIST ,d Linked List gS] ftlesa nks Nodes A o B ds chp ,d Node N gS vkSj bl Node N
dks Linked List esa ls Delete djuk gSA bl Node N dks Delete djus ds fy, ge fuEu fp= esa fn[kk,
x, Process dks Use dj ldrs gSa&
tSls gh ge fdlh Node dks Linked List esa ls Delete djrs gSa] ;s t:jh gksrk gS fd og Space fdlh
vU; Program ds fy, Usable gks tk, ;kuh og Space Free gks tk, vkSj AVAILABLESPACE
Linked List esa tqM tk,A ,lk djus ds fy, gesa Programming Language C esa free() Function dk
iz;ksx djuk iMrk gSA
fdlh Node ds Deletion ds le; Hkh nks fLFkfr;ka gksrh gSaA igyh ;s fd tc fdlh Linked List esa Delete
fd;k tkus okyk Node N gh ml Linked List dk START Node gks vkSj nwljh fLFkfr ;s fd Delete
fd;k tkus okyk Node N fdlh Linked List dk vfUre Node gks ftlesa NULL gksA
ekuyks fd LIST ,d Linked List gS vkSj gesa fdlh Node N
Location ds Node dks LIST ls Delete djuk gSA ;fn ge ;s ekus
gS ml Node N ls igys ds Node dh Location LOCP gS ;k ;fn
LOCP = NULL gksrk gSA bl fLFkfr esa fdlh Node N dks Delete
iz;ksx djuk gksxk&
dh Location LOC nh xbZ gSA bl

fd gesa ftl Node dks Delete djuk
N fdlh LIST dk igyk Node gS rks
djus ds fy, gesa fuEu Algorithm dk
Algorithm
//========================================================================
DELETE(INFO, LINK, START, AVAILABLESPACE, LOC, LOCP)
This Algorithm deletes a NODE N with location LOC. LOCP is the location of
the node which precedes N or, when N is the first node, LOCP = NULL.
1
2
3
SET LOCP = START

SET LOC = LOCP[LINK]
IF LOCP = NULL then
SET START = START[LINK]
ELSE
SET LOCP[LINK] = LOC[LINK]
4
[ Delete First Node ]

[ Delete Node N ]
SET LOC[LINK] = AVAILABLESPACE

[ Return deleted node to the AVAILABLE SPACE Linked List ]
5 AVAILABLESPACE = LOC
6 EXIT
//========================================================================
Deleting the Node with a Given ITEM of Information

ekuyks fd LIST ,d Linked List gS vkSj gesa ITEM fn;k x;k gSA gesa ml Node N dks Delete djuk gS
ftlesa ITEM gSA ;fn ITEM dksbZ Primary Key gS rks ,d LIST esa dsoy ,d gh ,lk ITEM gks ldrk gS
ftls Delete djuk gSA blls igys fd ge Information ITEM okys Node N dks Delete djs]a gesa Node
N ls fiNys ITEM dh LOCATION dk irk yxkuk gksxkA blds fy, gesa ,d Procedure Use djuk
gksxk tks fd Node N dh LOCATION LOC dk irk yxk,xk vkSj LOC ls igys okys Node LOCP dk
irk yxk,xkA ;fn N fdlh Linked List dk igyk ITEM gks rks gesa LOCP = NULL djuk gksrk gS vkSj
;fn LIST esa ITEM uk feys rks gesa LOC = NULL djuk gksrk gSA
,d Pointer PTR dk iz;ksx djrs gq, ITEM dks PTR[INFO] ls Compare djrs gq, Linked List dks
Traverse djrs gSaA tc Traversing dh tk jgh gks rc Compare gksus okys Node ds igys ds Node dk
SAVE uke ds ,d Variable esa Track j[kk tkuk pkfg,A SAVE o PTR dks fuEu Assignment }kjk
Update djuk pkfg,&
SAVE = PTR
PTR = PTR[LINK]
Traversing rc rd pyuh pkfg, tc rd fd PTR[INFO] <> ITEM uk gks tk,A nwljs kCnksa esa dgsa rks
Traversing rc :duh pkfg, tc ITEM = PTR[INFO] gks tk,A bl fLFkfr esa PTR esa Node dh
Location LOC gksrk gS vkSj SAVE esa Node N ds igys ds Node dk Location LOCP gksrk gSA tc
Linked List esa dsoy ,d gh Node gksrk gS ;k tc N igyk Node gksrk gS rc SAVE Variable dh
t:jr ugha gksrh gSA bl Algorithm dks ge fuEukuqlkj ns[k ldrs gSa&
Algorithm
//========================================================================
FINDB(INFO, LINK, START, ITEM, LOC, LOCP)
This procedure finds the location LOC of the Node N which contains ITEM and
the location LOCP of the node preceding N. If ITEM does not appear in the
list, then the procedure sets LOC = NULL; and if ITEM appears in the first
node, then it sets LOCP = NULL.
1
2
3

SET LOC = NULL and LOCP = NULL and RETURN
IF START[INFO] = ITEM then
SET LOC = START and LOCP = NULL and RETURN
SET SAVE = START and PTR = START[LINK]
[
[
[
[
[
If LIST is Empty ]
End of IF Structure ]
ITEM is in first node ]
End of IF Structure ]
Initialize Pointers ]
4
5

IF PTR[INFO] = ITEM then
SET LOC = PTR and LOCP = SAVE and RETURN [ End of IF Structure ]
6 SET SAVE = PTR and PTR = PTR[LINK]
[ Update Pointers ]
7 SET LOC = NULL
[ Search Unsuccessful ]
8 EXIT
//========================================================================
mijksDr Algorithm ml Node dks Find djrk gS ftlesa ITEM miyC/k gSA bl Algorithm dk iz;ksx
djds ge fuEukuqlkj ,d Algorithm fy[k ldrs gSa] ftlls fdlh LIST ds ml Node N dks Delete fd;k
tk ldrk gS ftlesa Search fd;k tkus okyk ITEM gS&
//========================================================================
DELETE(INFO, LINK, START, AVAILABLESPACE, ITEM)
This Algorithm deletes from a Linked List the node N which contains the given
ITEM of information.
1
[Use Previous Procedure to find the location of N and its preceding

node]
CALL FINDB(INFO, LINK, START, ITEM, LOC, LOCP)
2 IF LOC = NULL then
PRINT ITEM is not in the LIST
EXIT
3 IF LOCP = NULL then
SET START = START[LINK]
[ Delete First Node ]
ELSE
SET LOCP[LINK] = LOC[LINK]
4 SET LOC[LINK] = AVAILABLESPACE
AVAILABLESPACE = LOC
[ Free DELETED Nodes Space ]
5 EXIT
//========================================================================
bl Algorithm ds vk/kkj ij ge fuEukuqlkj ,d Program Create dj ldrs gSa tks fdlh Linked List ds
ml Node dks Delete fd;k x;k gS ftlesa ITEM izkIr gksrk gSA
Program of Deletion of a Given Node
//========================================================================
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
void main(void)
{
int i, ITEM;
struct LIST
{
int INFO;
struct LIST *LINK;
}START, *NODE, *LOC, *LOCP;
START.LINK = NULL;
NODE = &START;
// Empty List
// Points to the Start of Linked List
for(i=1; i<10; i++)
// Linked List Creation
{
NODE->LINK = (struct LIST *)malloc(sizeof(struct LIST));
NODE->INFO = i;
NODE=NODE->LINK;
NODE->LINK = NULL;
}
//Remove the Number
fflush(stdin);
printf("\nEnter Number You want to Delete [ 1 to 9 ] ");
scanf("%d", &ITEM);
printf("\n\nLIST Before Deletion of VALUE = %d \n\n", ITEM);
NODE = &START;
// Points to the Start of Linked List
while(NODE != NULL)
{
printf("%d\t", NODE->INFO);
NODE = NODE->LINK;
}
LOC = START.LINK;
LOCP = &START;
while(LOC)
{
if(LOC->INFO == ITEM)
{
LOCP->LINK = LOC->LINK;
free(LOC);
break;
}
else
{
LOC = LOC->LINK;
LOCP = LOCP->LINK;
}
}
//Display the LIST
LOC = &START;
printf("\n\nLIST After Deletion VALUE = %d \n\n", ITEM);
while(LOC != NULL)
{
printf("%d\t", LOC->INFO);
LOC = LOC->LINK;
}
getch();
}
//========================================================================
Output
//========================================================================
Enter Number You want to Delete [ 1 to 9 ] 5
LIST Before Deletion of VALUE = 5

1
4253080
LIST After Deletion VALUE = 5

1 2 3 4 6 7 8 9 4253080
//========================================================================
Header Linked List

Header Linked List esa ,d Special Node gksrk gS] tks fd fdlh Linked List dh kq:vkr dk igyk
Node gksrk gSA bl Node dks gesakk START Point djrk gSA fdlh Header Linked List esa Linked List
ds bl izFke Node dks Header Node dgrs gSaA bl izdkj dh Linked List rc cgqr mi;ksxh gksrh gS tc
fdlh Information dks izkIr djus ds fy, iwjh Linked List dks Traverse djuk iMrk gSA tSls ;fn gesa
fdlh Linked List ds dqy Nodes dh la[;k Kkr djuh gks] rks gesa gj ckj iwjh Linked List dh
Traversing djds dqy Nodes dh la[;k Kkr djuh iMrh gSA ysfdu ;fn fdlh Linked List dh Current
Nodes dh dqy la[;k dks fdlh Additional Header Node }kjk Maintain fd;k tk,] rks ge bl
Header Node dk iz;ksx djds fdlh Hkh le; fdlh Linked List ds dqy Nodes dh la[;k Kkr dj
ldrs gSa vkSj blds fy, gesa iwjh Linked List dh Traversing djus dh Hkh t:jr ugha gksrh gSA bl fLFkfr
esa ge Header Linked List dk iz;ksx dj ldrs gSaA bl Header Linked List ds nks :i gksrs gSa ftudk
lcls vf/kd iz;ksx gksrk gS&
What is Error! Bookmark not defined.

vkidks bl iqLrd ds Index of Contents dh List esa Error! Bookmark not defined. Message
fn[kkbZ ns jgk gksxkA ;s os Contents gSa] tks vkidks rc fn[kkbZ nsaxs] tc vki bl iqLrd dks PDF Format
EBook ds :i esa Purchase djsaxsA
Did you liked this EBook?

D;k vkidks ;s Sample Chapters ilUn vk,\ ;fn vkidks yxrk gS fd ;s iqLrd vkids fy, mi;ksxh gS]
rks vki bl iqLrd dks PDF Format EBook ds :i esa [kjhn ldrs gSaA iqLrd [kjhnus ls lacaf/kr
Detailed tkudkjh vki http://www.bccfalna.com/how-to-pay/ Page ls izkIr dj ldrs gSaA
bl iqLrd dh dher dkQh de gS vkSj ;fn vki nks ls T;knk iqLrdsa [kjhnrs gSa] rks vkidks Extra Discount
izkIr gksrk gSA Discount dh tkudkjh Hkh vki http://www.bccfalna.com/how-to-pay/ Page ij izkIr
dj ldrs gSaA
;fn vki bl iqLrd dks PDF Format EBook ds :i esa [kjhnrs gSa] rks bl iqLrd dk gj Updated
Version vkidks Lifetime Free feyrk gSA ;kuh iqLrd ds vxys Version ds fy, vkidks fdlh izdkj dk
dksbZ Payment ugha djuk iMrkA
pwfa d ;s iqLrd fofHkUu Universities ds Syllabus dks /;ku esa j[krs gq, fy[kh xbZ gS] blfy, ;s iqLrd
vkids fy, ml fLFkfr esa Hkh dkQh mi;ksxh lkfcr gksrh gS] tcfd vki dksbZ Degree Level Course tSls
fd BCA, PGDCA, MCA vkfn dj jgs gksrs gSaA
bl iqLrd ds Pages dks vki viuh bPNkuqlkj Print djds vius Syllabus ds vuqlkj Lo;a ds Notes
cuk ldrs gSa] tks fd vkids Exam esa bl Subject ds Marks Increase djus esa vkidh enn djrs gSaA
pwfa d ;s iqLrd ,d PDF EBook gS] blfy, vki fdlh Hkh PDF Reader Supported Mobile, Tablet,
Palmtop, Laptop ;k Computer ij bl iqLrd dks i< ldrs gSa vkSj bl iqLrd esa fn, x, fofHkUu
Example Programs dks fcuk Type fd, gq, Copy-Paste djds vius Computer ij Compile o Run
djds gj Program dk Output ns[k ldrs gSa] ftlls vkids Programming lh[kus dh Speed dkQh rst
gks tkrh gS] D;ksafd vkidks gj Program dks Manually Type djus dh t:jr ugha iMrhA
tc vki ;s iqLrd [kjhnrs gSa] rks vki bl iqLrd ds lHkh Contents dks fcuk fdlh ijskkuh ds i< ldrs
gSaA bl iqLrd ds lHkh Contents dk Index fuEukuqlkj gS%
Contents .................................................................................................................................... 4
Data Structure Fundamentals and Arrays .................................................................................. 8
Introduction of Data - Field, Record and File........................................................................... 8
Data Structures .................................................................................................................... 10
Linear Data Structure ........................................................................................................ 10
Non-Linear Data Structure ................................................................................................ 10
Algorithm : Time Space Tradeoff and Complexity .............................................................. 11
Algorithms ............................................................................................................................ 13
Analysis of Algorithm ........................................................................................................ 14
Rate of Growth .................................................................................................................. 14
Time Analysis ................................................................................................................... 16
Complexity ( Big O Notation ) ............................................................................................ 16

Properties of O Notation ................................................................................................. 17
CPU Time...................................................................................................................... 18
Input / Output ................................................................................................................ 19
Analyzing Algorithms ............................................................................................................ 21
Inserting and Deleting........................................................................................................... 26
Algorithm of Inserting ........................................................................................................ 27
Sorting .................................................................................................................................. 29
Bubble Sort ....................................................................................................................... 29
Selection Sort ................................................................................................................... 30
Insertion Sort .................................................................................................................... 31
Searching ............................................................................................................................. 34
Internal Search ................................................................................................................. 34
External Search ................................................................................................................ 34
Linear Searching ............................................................................................................... 34
Binary Searching............................................................................................................... 37
String Operations and Data Structure ................................................................................... 41
Pattern Matching Algorithms ................................................................................................. 44
Algebra of Matrix .................................................................................................................. 46
Addition of Matrixes .......................................................................................................... 46
Subtraction of Matrixes ..................................................................................................... 47
Multiplication of Matrix....................................................................................................... 48
Transpose of Matrix .......................................................................................................... 50
Orthogonal Matrix ............................................................................................................. 50
Symmetric Matrix .............................................................................................................. 51
Sparse Matrix .................................................................................................................... 51
Linked Lists .............................................................................................................................. 52
Linked List ............................................................................................................................ 54
Creating Linked List .............................................................................................................. 60
Memory Allocation ................................................................................................................ 61
Garbage Collection ............................................................................................................... 63
Overflow and Underflow ....................................................................................................... 63
INSERTING New NODE at the End of the LIST ................................................................... 64
INSERTING New NODE at the BEGINNING of the LIST ...................................................... 71
INSERTING New NODE at any MIDDLE Position of the LIST .............................................. 74
Searching in a Linked List..................................................................................................... 78
LIST is Unsorted ............................................................................................................... 78
LIST is Sorted ................................................................................................................... 80
Sorting .................................................................................................................................. 81
Inserting into a Sorted Linked List......................................................................................... 89
Deleting from a Linked List ................................................................................................... 90
Deletion of First Node ....................................................................................................... 91
Deletion of Last Node ....................................................................................................... 92
Deletion Any NODE from a Linked List ............................................................................. 94
Deleting the Node with a Given ITEM of Information ......................................................... 96
Header Linked List................................................................................................................ 99
Grounded Header .................................................................... Error! Bookmark not defined.
Circular Header ....................................................................... Error! Bookmark not defined.
Creating a Circular Linked List ............................................. Error! Bookmark not defined.
Traversing a Circular Linked List .......................................... Error! Bookmark not defined.
Two Way Lists OR Doubly Linked List .................................. Error! Bookmark not defined.
CREATION of Doubly Linked List ........................................ Error! Bookmark not defined.

INSERTING NODE After Specific Node Number ................. Error! Bookmark not defined.
DELETION In Doubly Linked List ......................................... Error! Bookmark not defined.
DELETION of Specified NODE of the Doubly Linked List ..... Error! Bookmark not defined.
Circular Doubly Linked List ...................................................... Error! Bookmark not defined.
Stacks and Queues ..................................................................... Error! Bookmark not defined.
STACK .................................................................................... Error! Bookmark not defined.
PUSH................................................................................... Error! Bookmark not defined.
POP ..................................................................................... Error! Bookmark not defined.
Postponed Decisions ........................................................... Error! Bookmark not defined.
ARRAY Representation of Stack .......................................... Error! Bookmark not defined.
PUSH Algorithm For Array Stack ......................................... Error! Bookmark not defined.
POP Algorithm For Array Stack ............................................ Error! Bookmark not defined.
Linked List Representation of STACK .................................. Error! Bookmark not defined.
Arithmetic Expressions and POLISH Notations ....................... Error! Bookmark not defined.
Evaluation of a Postfix Expression ....................................... Error! Bookmark not defined.
Transforming Infix Expression into Postfix Expression ......... Error! Bookmark not defined.
Quick Sort ............................................................................... Error! Bookmark not defined.
Complexity fo the Quick Sort Algorithm ................................ Error! Bookmark not defined.
Queues.................................................................................... Error! Bookmark not defined.
Representation of Queues ................................................... Error! Bookmark not defined.
PUSH Algorithm For Array Queue ....................................... Error! Bookmark not defined.
POP Algorithm For Array Queue .......................................... Error! Bookmark not defined.
Linked Representation of Queues ........................................ Error! Bookmark not defined.
Circular QUEUE ...................................................................... Error! Bookmark not defined.
DEQUE ................................................................................... Error! Bookmark not defined.
Priority Queue ......................................................................... Error! Bookmark not defined.
Trees .......................................................................................... Error! Bookmark not defined.
Binary Tree .............................................................................. Error! Bookmark not defined.
Terminology............................................................................. Error! Bookmark not defined.
A Complete Binary Tree .......................................................... Error! Bookmark not defined.
Extended Binary Tree or 2 Tree............................................ Error! Bookmark not defined.
Representation of Binary Tree ................................................. Error! Bookmark not defined.
Sequential Representation ................................................... Error! Bookmark not defined.
Linked List Representation ................................................... Error! Bookmark not defined.
Traversing Binary Tree ............................................................ Error! Bookmark not defined.
Preorder Traversing ............................................................. Error! Bookmark not defined.
Inorder Traversing................................................................ Error! Bookmark not defined.
Postorder Traversing ........................................................... Error! Bookmark not defined.
CREATING Binary Tree .......................................................... Error! Bookmark not defined.
INSERTING in a Binary Tree ................................................... Error! Bookmark not defined.
Creating Binary Tree Array Representation ............................. Error! Bookmark not defined.
Binary Search Tree (BST) ....................................................... Error! Bookmark not defined.
SEARCHING and INSERTING in Binary Search Tree ......... Error! Bookmark not defined.
Complexity of the Searching Algorithm ................................ Error! Bookmark not defined.
DELETING from Binary Search Tree ................................... Error! Bookmark not defined.
Complexity of Binary Search Tree ........................................ Error! Bookmark not defined.
Balanced Binary Tree .............................................................. Error! Bookmark not defined.
AVL Tree ( Height Balanced Tree ) ...................................... Error! Bookmark not defined.
Tree Rotation ....................................................................... Error! Bookmark not defined.
Insertion a Node in AVL Tree ............................................... Error! Bookmark not defined.
Deletion From an AVL Tree ................................................. Error! Bookmark not defined.

M Way Search Tree.............................................................. Error! Bookmark not defined.
Searching in M Way Tree .................................................. Error! Bookmark not defined.
Insertion in M Way Tree .................................................... Error! Bookmark not defined.
Deletion from M Way Tree ................................................ Error! Bookmark not defined.
B Tree .................................................................................. Error! Bookmark not defined.
Graph.......................................................................................... Error! Bookmark not defined.
Basic Concepts and Definitions ............................................... Error! Bookmark not defined.
Path ......................................................................................... Error! Bookmark not defined.
Sequential Representation ...................................................... Error! Bookmark not defined.
Adjacency Matrix ..................................................................... Error! Bookmark not defined.
Path Matrix .............................................................................. Error! Bookmark not defined.
Shortest Path Algorithm ........................................................... Error! Bookmark not defined.
Warshall Algorithm .................................................................. Error! Bookmark not defined.
Warshalls Modified Algorithm ................................................. Error! Bookmark not defined.
Dijkstras Algorithm .................................................................. Error! Bookmark not defined.
Floyds Technique ................................................................... Error! Bookmark not defined.
Linked List Representation of Graph (Adjacency List) ............. Error! Bookmark not defined.
Operations on GRAPHS .......................................................... Error! Bookmark not defined.
Inserting in a GRAPH ........................................................... Error! Bookmark not defined.
Deleting From a GRAPH ...................................................... Error! Bookmark not defined.
Traversing A GRAPH ........................................................... Error! Bookmark not defined.
Breadth First Search................................................................ Error! Bookmark not defined.
Depth First Search................................................................... Error! Bookmark not defined.
Partially Ordered Set (POSETS).............................................. Error! Bookmark not defined.
Topological Sorting .................................................................. Error! Bookmark not defined.
Minimum Spanning Tree (MST) ............................................... Error! Bookmark not defined.
Kruskals Algorithm .................................................................. Error! Bookmark not defined.
Searching and Sorting................................................................. Error! Bookmark not defined.
Searching ................................................................................ Error! Bookmark not defined.
Data Modification ..................................................................... Error! Bookmark not defined.
Sorted Array......................................................................... Error! Bookmark not defined.
Linked List............................................................................ Error! Bookmark not defined.
Binary Search Tree .............................................................. Error! Bookmark not defined.
Linear and Binary Searching ................................................... Error! Bookmark not defined.
Hash Table .............................................................................. Error! Bookmark not defined.
Hashing ............................................................................... Error! Bookmark not defined.
Hash Function ...................................................................... Error! Bookmark not defined.
Collision Resolution ................................................................. Error! Bookmark not defined.
Open Addressing : Linear Probing(Key Comparisons) and Modifications ..... Error! Bookmark
not defined.
Clustering............................................................................. Error! Bookmark not defined.
Quadratic Probing ................................................................ Error! Bookmark not defined.
Double Hashing ................................................................... Error! Bookmark not defined.
Deletion ............................................................................... Error! Bookmark not defined.
Rehashing............................................................................ Error! Bookmark not defined.
Bucket And Chaining ........................................................... Error! Bookmark not defined.
Selecting Good Hash Function............................................. Error! Bookmark not defined.
File Structure .............................................................................. Error! Bookmark not defined.
File System ............................................................................. Error! Bookmark not defined.
Basic Concepts of File and File System................................... Error! Bookmark not defined.
File Data Storage and Retrieval ........................................... Error! Bookmark not defined.
File Naming and File Attribute Maintenance ......................... Error! Bookmark not defined.
File System Application Program Interface (API).................. Error! Bookmark not defined.
Disk Space Allocation .............................................................. Error! Bookmark not defined.
FAT File System (MS-DOS) .................................................... Error! Bookmark not defined.
Directory System ..................................................................... Error! Bookmark not defined.
UNIX File System .................................................................... Error! Bookmark not defined.
i-node File System (Flat File System) ................................... Error! Bookmark not defined.
Directory File System ........................................................... Error! Bookmark not defined.
Primary Key ......................................................................... Error! Bookmark not defined.
System Architecture ............................................................. Error! Bookmark not defined.
Primary and Secondary Structure ............................................ Error! Bookmark not defined.
Secondary Storage Devices .................................................... Error! Bookmark not defined.
Hard Disk Drives .................................................................. Error! Bookmark not defined.
Disk Capacity ....................................................................... Error! Bookmark not defined.
Disk Access ......................................................................... Error! Bookmark not defined.
Last Thing by Author ................................................................... Error! Bookmark not defined.

DSN Ain Hindi

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

DSN Ain Hindi

Transféré par

Droits d'auteur :

Formats disponibles

Data Structure and Algorithms with C in Hindi

Betalab Computer Center

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Postorder Traversing ........................................................... Error! Bookmark not defined.

Data Structure and Algorithms with C in Hindi

Collision Resolution ................................................................. Error! Bookmark not defined.

Data Structure and Algorithms with C in Hindi

Data Structure Fundamentals and Arrays

Data Structure and Algorithms with C in Hindi

Structure dh Logical ;k Mathematical Description

Data Structure and Algorithms with C in Hindi

djsa ;s ckr nks rF;ksa ij fuHkZj djrh gS%

Linear Data Structure

ubZ bdkbZ tksMukA

Data Structure and Algorithms with C in Hindi

Algorithm : Time Space Tradeoff and Complexity

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Complexity ( Big O Notation )

Data Structure and Algorithms with C in Hindi

| f(n) | <= | g(n) | tcfd lHkh n > n0

dk O Notation O(n5) gksxkA

dk O Notation O(n3) gksxkA

Data Structure and Algorithms with C in Hindi

an3 + bn4 + cn2 + dn1

mnkgj.k ds fy, log2 n is O(n0.5)

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

bl Algorithm dh Length Quadratic ls de ysfdu Linear ls vf/kd gksrh gSA

Data Structure and Algorithms with C in Hindi

A1 - Efficiency(n) = 29 [ Constant Time ]

dj jgs gksrs gSaA

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

( Number of Loops Repetitions ) * ( Complexity of each Iteration )

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

bldh Efficiency ge fuEukuqlkj Kkr dj ldrs gSa&

SUM( i, 1, n ) of ( Efficiency of Ith Iteration )

Inserting and Deleting

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

fdlh Linear Array ls Deletion dk Algorithm fuEukuqlkj gks ldrk gS&

bu nksuksa Algorithms dk ge fuEukuqlkj iz;ksx djds Program cuk ldrs gSa&

//Deletion Operation on the Array

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

lkjkak esa dgsa rks

Data Structure and Algorithms with C in Hindi

Data Structure and Algorithms with C in Hindi

Insertion Algorithm dk iz;ksx rc fd;k tk ldrk gS tc Data Items n dh la[;k de gksA bl

Data Structure and Algorithms with C in Hindi

i = 1 To n SIGMA( i-1 )/2

struct LIST temp, NEWNODE;