లో DFS , అన్వేషించబడుతున్న నోడ్‌లు స్టాక్ డేటా నిర్మాణంలో నిల్వ చేయబడతాయి. అన్వేషించని నోడ్‌లకు మమ్మల్ని నడిపించే అంచులను ' ఆవిష్కరణ అంచులు 'ఇప్పటికే సందర్శించిన నోడ్‌లకు దారితీసే అంచులను అంటారు' బ్లాక్ అంచులు '. DFS ప్రోగ్రామర్ కనెక్ట్ చేయబడిన భాగాలు లేదా చక్రాలను గ్రాఫ్‌లో కనుగొనాలనుకున్నప్పుడు దృశ్యాలలో ఉపయోగకరంగా ఉంటుంది.
అమలు చేయడానికి ఈ కథనం యొక్క మార్గదర్శకాలను అనుసరించండి DFS C++లో.
C++లో DFS అమలు
కింది విభాగంలో, మేము ఎలా చేయాలో చూద్దాం DFS C++లో అమలు చేయబడుతుంది. అమలు చేయడానికి ఇచ్చిన దశలను అనుసరించవచ్చు DFS .
- చెట్టు లేదా గ్రాఫ్ యొక్క రూట్ నోడ్‌ను స్టాక్‌లోకి చొప్పించండి.
- మీరు సందర్శించిన జాబితాకు స్టాక్ యొక్క అగ్ర అంశాన్ని జోడించండి.
- సందర్శించిన నోడ్‌కు ప్రక్కనే ఉన్న అన్ని నోడ్‌లను కనుగొనండి మరియు స్టాక్‌ను ఇంకా సందర్శించని నోడ్‌లను జోడించండి.
- స్టాక్ ఖాళీ అయ్యే వరకు 2 మరియు 3 దశలను పునరావృతం చేయండి.
DFS సూడోకోడ్
ది DFS సూడోకోడ్ క్రింద చూపబడింది. లో వేడి () ఫంక్షన్, మేము మా అమలు DFS ప్రతి నోడ్‌లో ఫంక్షన్. గ్రాఫ్ రెండు డిస్‌కనెక్ట్ చేయబడిన భాగాలను కలిగి ఉండవచ్చు కాబట్టి, మనం దీన్ని అమలు చేయవచ్చు DFS మేము ప్రతి శీర్షాన్ని కవర్ చేసామని నిర్ధారించడానికి ప్రతి నోడ్‌లోని అల్గోరిథం.
DFS ( g a )
a. సందర్శించారు = నిజం
కోసం ప్రతి b ∈ g. Adj [ a ]
ఉంటే బి. సందర్శించారు == తప్పుడు
DFS ( g,b )
వేడి ( )
{
ప్రతి a ∈ g
a. సందర్శించారు = తప్పుడు
ప్రతి a ∈ g
DFS ( g, a )
}
ఇక్కడ g, a మరియు b వరుసగా స్టాక్‌లోని గ్రాఫ్, మొదట సందర్శించిన నోడ్ మరియు నోడ్‌ను సూచిస్తాయి.
C++లో DFSని అమలు చేస్తోంది
కోసం ఒక C++ ప్రోగ్రామ్ DFS అమలు క్రింద ఇవ్వబడింది:
#include
#చేర్చండి<మ్యాప్>
#చేర్చండి<జాబితా>
ఉపయోగించి నేమ్‌స్పేస్ std ;
టెంప్లేట్ < టైప్ పేరు t >
తరగతి డెప్త్ ఫస్ట్ సెర్చ్
{
ప్రైవేట్ :
పటం < t, జాబితా < t > > adjList ;
ప్రజా :
డెప్త్ ఫస్ట్ సెర్చ్ ( ) { }
శూన్యం Add_edge ( t a, t b, బూల్ మీరు = నిజం )
{
adjList [ a ] . వెనుకకు నెట్టడం ( బి ) ;
ఉంటే ( మీరు )
{
adjList [ బి ] . వెనుకకు నెట్టడం ( a ) ;
}
}
శూన్యం ముద్రణ ( )
{
కోసం ( దానంతట అదే i : adjList ) {
కోట్ << i. ప్రధమ << '->' ;
కోసం ( t ప్రవేశం : i. రెండవ ) {
కోట్ << ప్రవేశం << ',' ;
}
కోట్ << endl ;
}
}
శూన్యం dfs_helper ( t నోడ్, మ్యాప్ < t, బూల్ > & సందర్శించారు ) {
సందర్శించారు [ నోడ్ ] = నిజం ;
కోట్ << నోడ్ << '' << endl ;
కోసం ( t పొరుగు : adjList [ నోడ్ ] ) {
ఉంటే ( ! సందర్శించారు [ పొరుగు ] ) {
dfs_helper ( పొరుగు, సందర్శించిన ) ;
}
}
}
శూన్యం DFS ( t src )
{
పటం < t, బూల్ > సందర్శించారు ;
dfs_helper ( src, సందర్శించారు ) ;
}
} ;
int ప్రధాన ( ) {
డెప్త్ ఫస్ట్ సెర్చ్ < int > g ;
g. Add_edge ( 0 , 5 ) ;
g. Add_edge ( 0 , 7 ) ;
g. Add_edge ( 4 , 7 ) ;
g. Add_edge ( 7 , 8 ) ;
g. Add_edge ( 2 , 1 ) ;
g. Add_edge ( 0 , 6 ) ;
g. Add_edge ( 2 , 4 ) ;
g. Add_edge ( 3 , 2 ) ;
g. Add_edge ( 3 , 6 ) ;
g. Add_edge ( 7 , 5 ) ;
g. Add_edge ( 5 , 8 ) ;
g. ముద్రణ ( ) ;
g. DFS ( 6 ) ;
కోట్ << endl ;
}
ఈ కోడ్‌లో, మేము అమలు చేసాము DFS పైన ఇచ్చిన సూడో కోడ్‌ను అనుసరించే అల్గోరిథం. మాకు 12 జతల నోడ్‌లు ఉన్నాయి. మేము ఒక తరగతిని నిర్వచించాము ' జి ” ఇది సందర్శించిన మరియు సందర్శించని నోడ్‌లను సూచించే a మరియు b శీర్షాలను కలిగి ఉన్న గ్రాఫ్‌ను సూచిస్తుంది.
అవుట్‌పుట్
ముగింపు
DFS గ్రాఫ్‌లో చక్రాలను కనుగొనడం మరియు కనెక్ట్ చేయబడిన భాగాలు లేదా గ్రాఫ్‌లోని అన్ని శీర్షాల గురించి సమాచారాన్ని పొందడం వంటి అనేక దృశ్యాలకు ఉపయోగపడే ప్రసిద్ధ శోధన అల్గారిథమ్. మేము పనిని కూడా వివరించాము DFS ఒక ఉదాహరణతో పద్ధతి. DFS సాంకేతికతను అమలు చేయడానికి స్టాక్‌లను ఉపయోగిస్తుంది మరియు చెట్లపై కూడా ఉపయోగించవచ్చు.