DSnAinHindi

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/


Data Structure and Algorithms with “C” in Hindi 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 [email protected], 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. Warshall’s Modified Algorithm ................................................. Error! Bookmark not defined. Dijkstra’s Algorithm .................................................................. Error! Bookmark not defined. Floyd’s 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. Kruskal’s 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 fo”ks’krk,a gksrh gSa] tks mls vU; Object ;k Entity ls vyx cukrh gSA tSls ,d Student dh fofHkUu fo”ks’krk,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 fo”ks’krk,a gks ldrh gSaA fdlh Hkh Entity ;k Object dh fofHkUu fo”ks’krkvksa 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


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 iznf”kZr 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 Non–Linear 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 gesa”kk 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 cus 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 fo”ks’k 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 n”kkZrk 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 n”kkZus 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 fo”ks’k 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 iznf”kZr 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 n”kkZ 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 fo”ks’k Ø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 fuf”pr Øe esa ljy Hkk’kk 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
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 dksf”k”k djuh pkfg, fd fdlh Hkh Algorithm dh Complexity Linear Øe esa c


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 Array’s 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 eqf”dy 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

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 fuf”pr Øe ds vuqlkj Input Data n ds fy, vk;ke iznku djrs gSaA fofHkUu Functions tks vk;ke iznf”kZr djrs gSa mu lHkh vk;ke iznf”kZr 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 ifjHkkf’kr 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(n3) gksxkA dk “O” Notation O(n2) 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 fo”ks’krk,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

dk “O” Notation O(n3) gksxkA

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


an3 + bn4 + cn2 + dn1 Operations gksrs gSa rks bl Algorithm dh Complexity bn4 ds c
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
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 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 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 ges”a 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 ifjHkk’kk 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 fuf”pr vad ds :i esa fdlh Algorithm dh Efficiency dks ifjHkkf’kr ugha dj ldrs gSaA blfy, gesa Algorithm dh Efficiency dks Input Data dh Size n ds Qyu ds :i esa gh ifjHkkf’kr 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 ifjHkkf’kr 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 n”kkZus 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 gesa”kk 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 ges”a 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 ges”a 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 http://www.bccfalna.com/


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 eqf”dy 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 Li’B :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 iznf”kZr 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, ges”a 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
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
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 dksf”k”k 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
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 Loop’s 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 fuf”pr 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 iznf”kZr fd;k tk, rks bl Program dh Efficiency dks ge fuEukuqlkj Big – O Notation ds :i esa iznf”kZr 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 fo”ks’k 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

0



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 #include #include #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
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; iArray[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 )

lkjka”k 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 “ks’k 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 “ks’k 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& //=====================================================================

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 = 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 ] [ End of Inner Loop ] [ End of Outer Loop ] 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(i=0; iArray[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 “ks’k bdkbZ;ksa dks Right Side esa Shift djuk gksrk gSA mlds ckn cuk, x, LFkku esa bdkbZ dks izo”s k djok nsrs gSaA bl Method dk Algorithm fuEukuqlkj gksrk 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 = 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 [ End of Inner Loop ] [ End of Inner Loop ] [ End of Outer Loop ] 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(i=0; iArray[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 n”kkZ;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 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]
,d izkxs zke cukvks tks nl vad Input ys vkSj mls vojksgh dze esa Output esa Print djsAa //================================================================ #include 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

5

30

20

4

9

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 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 dksf”k”k 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

2

3

4

5

6

7

Mid

8

9

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



1

2

Low

3

4

Mid

5

6

7

8

9

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

1

2

Low

3

4

5

6

7

8

9

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 #include 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 -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 Enter The Elements:2 Enter The Elements:3 Enter The Elements:4 Enter The Elements:5 Enter The Elements:6 Enter The Elements:7 Enter The Elements:8 Enter The Elements:9 Enter The Elements:77 The Entered Array is 1 The Entered Array is 2 The Entered Array is 3 The Entered Array is 4 The Entered Array is 5 The Entered Array is 6

<=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 izo”s 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 iznf”kZr 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 #include #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 fo”ks’k 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 #include #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


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
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 #include #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
;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=

A–B

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

B–A

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) 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 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) 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 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 “ks’k 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 fuf”pr 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


gksrs gSaA bl rjg ds Data Structure dks Linked List dgk tkrk gSA bl Data Structure dh viuh dqN fo”ks’krk,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 gesa”kk 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 gesa”kk ,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 ges”a kk ,d Structure gksrk gS] ftldk ,d Member ges”a 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 n”kkZ;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 fo”ks’k Ø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
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 iznf”kZr 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 iznf”kZr 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 //========================================================================



1

IF START = NULL then PTR = AVAILABLESPACE [ Assign that Node to New Linked List which Currently Points AVAILABLESPACE Linked List’s 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 ges”a 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 ] [ End of Step 2 Loop ] 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) { 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; } else { struct LIST *temp = *PTR; //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; } } //========================================================================

bl Function dk iz;ksx djrs gq, ge fuEukuqlkj ,d Program cuk ldrs gSa& //======================================================================== #include #include #include



Structure //======================================================================== struct LIST { //Information Part int INFO; //Link Part struct LIST *LINK; }; struct LIST *START = NULL; //======================================================================== Function //======================================================================== void INSERT_AT_END(struct LIST **PTR, int 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; } else { struct LIST *temp = *PTR; //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; } } //======================================================================== 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 Enter a NUMBER in Information Part : 787878 Do You wish to Continuous ? Y/N y Enter a NUMBER in Information Part : 989898 Do You wish to Continuous ? Y/N y Enter a NUMBER in Information Part : 784112 Do You wish to Continuous ? Y/N 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 #include #include 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 Do You wish to Continuous ? Y/N y Enter Roll Number : 2 Enter Pincode: 222222



Do You wish to Continuous Enter Roll Number : 3 Enter Pincode: 333333 Do You wish to Continuous Enter Roll Number : 4 Enter Pincode: 444444 Do You wish to Continuous Enter Roll Number : 5 Enter Pincode: 555555 Do You wish to Continuous

? Y/N

y

? Y/N

y

? Y/N

y

? Y/N

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 croll_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 = (struct LIST *)malloc(sizeof(struct LIST)); NEWNODE->INFO = ITEM; NEWNODE->LINK = *PTR; *PTR = NEWNODE; } //========================================================================

bl Algorithm dk iz;ksx ge fuEukuqlkj main() Function esa dj ldrs gSa& Program //======================================================================== #include #include #include #include



static int total=0; //Structure //======================================================================== struct LIST { //Information Part int INFO; //Link Part struct LIST *LINK; }; struct LIST *START = NULL; //======================================================================== //Function //======================================================================== void INSERT_AT_BEGNNING(struct LIST **PTR, int ITEM) { struct LIST *NEWNODE; NEWNODE = (struct LIST *)malloc(sizeof(struct LIST)); NEWNODE->INFO = ITEM; NEWNODE->LINK = *PTR; *PTR = NEWNODE; total++; } //======================================================================== //Function //======================================================================== void INSERT_AT_END(struct LIST **PTR, int 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; } else { struct LIST *temp = *PTR; //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;



} 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"); scanf("%d", &choice); 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); INSERT_AT_END(&START, 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) { struct LIST *NEWNODE, *temp; int i; temp = *PTR;



for(i=0; iLINK; if(temp == NULL) { printf("\nData Items are Less then LOCATION\n"); return; } } NEWNODE = (struct LIST *)malloc(sizeof(struct LIST)); NEWNODE->INFO = ITEM; NEWNODE->LINK = temp->LINK; temp->LINK = NEWNODE; 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 #include #include #include static int total=0; //Structure //======================================================================== struct LIST { //Information Part int INFO; //Link Part struct LIST *LINK; }; struct LIST *START = NULL; //======================================================================== //Function //======================================================================== int COUNT(struct LIST **PTR) { int i = 1; struct LIST *temp; temp = *PTR; while(temp->LINK != NULL) { temp = temp->LINK; i++;



} return i; } //======================================================================== //Function //======================================================================== void INSERT_AT_BEGNNING(struct LIST **PTR, int ITEM) { struct LIST *NEWNODE; NEWNODE = (struct LIST *)malloc(sizeof(struct LIST)); NEWNODE->INFO = ITEM; NEWNODE->LINK = *PTR; *PTR = NEWNODE; total = COUNT(&START); } //======================================================================== //Function //======================================================================== void INSERT_AT_MIDDLE(struct LIST **PTR, int ITEM, int LOCATION) { struct LIST *NEWNODE, *temp; int i; temp = *PTR; for(i=0; iLINK; if(temp == NULL) { printf("\nData Items are Less then LOCATION\n"); return; } } NEWNODE = (struct LIST *)malloc(sizeof(struct LIST)); NEWNODE->INFO = ITEM; NEWNODE->LINK = temp->LINK; temp->LINK = NEWNODE; total = COUNT(&START); } //======================================================================== //Function //======================================================================== void INSERT_AT_END(struct LIST **PTR, int 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;



} else { struct LIST *temp = *PTR; //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; } total = COUNT(&START); } //======================================================================== //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"); scanf("%d", &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); INSERT_AT_END(&START, 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 gesa”kk 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 n”kkZ;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 [ End of IF Structure ] 10 P = P[LINK] 11 Q = Q[LINK] [ End of Inner Loop ] [ End of Outer Loop ] 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; ILINK; for(J=1; JINFO > 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 IF P[INFO] > Q[INFO] 6 TEMP = P[INFO] 7 P[INFO] = Q[INFO] 8 Q[INFO] = TEMP [ End of IF Structure ] 9 Q = Q[LINK] [ End of Inner Loop ] 10 P = P[INFO] [ End of Outer Loop ] 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


{ Q = START->LINK; for(J=I+1; JINFO > Q->INFO) { 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.      6

7

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[INFO] > Q[INFO] 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->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; } } 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

IF START = NULL then [ 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 ] REPEAT Step 7 and 8 WHILE PTR <> NULL IF ITEM < PTR[INFO] then SET LOCATION = SAVE and RETURN [ End of IF Structure ] 8 SET SAVE = PTR and PTR = PTR[LINK] [ Update Pointers ] [ End of Step 6 Loop ] 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 gesa”kk 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

IF START = NULL then 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 dksf”k”k

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 ] [ End of IF Structure ]

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

IF START = NULL then 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

REPEAT Step 5 and 6 WHILE PTR <> NULL 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 ] [ End of Step 4 Loop ] 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] [ End of IF Structure ] 4 SET LOC[LINK] = AVAILABLESPACE AVAILABLESPACE = LOC [ Free DELETED Node’s 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 #include #include 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

2

3

4

5

6

7

8

9

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 gesa”kk 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 ijs”kkuh 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. Warshall’s Modified Algorithm ................................................. Error! Bookmark not defined. Dijkstra’s Algorithm .................................................................. Error! Bookmark not defined. Floyd’s 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. Kruskal’s 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.


DSnAinHindi

Recommend Documents