2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
यथा एकललिङ्क् कृतसूचीनां कृते केचन कार्यात्मकाः अन्तरफलकाः लिखामः, तथैव प्रथमं द्विगुणलिङ्कितसूचीनां कृते केचन अन्तरफलकाः लिखामः यत् तस्य मुख्यरूपरेखायाः परिचयः भवति:
#निहितः<stdio.h>
#निहितः<stdlib.h>
typedef int LDataप्रकार;
//द्विपक्षीयशीर्षकवृत्तीयलिङ्कितसूचिकायाः नोड्
typedef struct सूचीनोड{ 1.1.
LDataType _दत्तांश;
//अग्रे नोडस्य आरम्भस्थानं सूचयन्तु
struct ListNode * _अगला;
//पूर्वस्य नोड् इत्यस्य आरम्भस्थानं सूचयन्तु
struct LIst * _पूर्व;
}सूची नोड;
//द्विपक्षीयशीर्षकं परिपत्रलिङ्कितसूची
typedef struct सूची{ 1.1.
struct ListNode * _शिरः;
}सूची;
struct सूचीनोड * createListNode (LDataType val) {
struct ListNode * नोड = (struct ListNode *) malloc (sizeof (स्ट्रक्चर ListNode));
नोड->_दत्तांश = val;
नोड->_अगला = NULL;
नोड->_पूर्व = NULL;
}
void ListInit (सूची * lst){
//रिक्त लिङ्क् कृता सूची
lst->_head = createListNode (0);
lst->_शीर्षक->_अगला = lst->_शीर्षक->_पूर्व = lst->_शीर्षक;
}
//पुच्छ सम्मिलन O (1) //शिरस्य सम्मुखं एकं डेटा सम्मिलितं कुर्वन्तु ListInsert (lst, lst->_head, val);
void ListpushBack (सूची * lst, LDataType val) {
यदि (lst == NULL){
निर्वतनम्;
struct ListNode * अन्तिम = lst->_शिरः->_पूर्व;
struct ListNode * newNode = सूचीनोड बनाओ (val);
//_head ... अन्तिमः newNode
अन्तिम->_अगला = newNode;
newNode->_पूर्व = अन्तिम;
newNode->_next = lst->_शिरः;
lst->_सिर->_पूर्व = newNode;
}
}
//Tail delete://शिरस्य पूर्ववर्ती नोडं मेटयन्तु ListErase(lst, lst->_head->_prev);
void सूचीपॉपबैक (सूची * lst){
यदि (lst == NULL)
निर्वतनम्;
//लिङ्क् कृतसूची रिक्तं वा इति निर्धारयन्तु
यदि (lst->_head->_next == lst->_head)
निर्वतनम्;
struct ListNode * अन्तिम = lst->_शिरः->_पूर्व;
struct ListNode * पूर्व = अंतिम-> _पूर्व;
मुक्त(अन्तिम);
lst->_शिरः->_पूर्व = पूर्व;
पूर्व->_अगला = lst->_शिरः;
}
void printList (सूची * lst){
struct ListNode * cur = lst->_सिर->_अगला;
while (cur != lst->_शिरः){
printf ("% d", cur->_डेटा);
cur = cur->_अगला;
}
printf ("n");
}
//शीर्ष सम्मिलित //ListInsert (lst, lst-> _सिर-> _अगला, val);
void सूचीपुशफ्रंट (सूची * lst, LDataType val) {
यदि (lst == NULL)
निर्वतनम्;
struct ListNode * next = lst->_शिरः->_अगला;
struct ListNode * newNode = सूचीनोड बनाओ (val);
//_head, newNode, अग्रिमम्
lst->_सिर->_अगला = newNode;
newNode->_prev = lst->_शिरः;
newNode->_next = अग्रिम;
next->_prev = newNode;
}
//शीर्षक हटाओ //ListErase (lst, lst-> _सिर->_अगला);
void ListPopFront (सूची * lst){
यदि (lst == NULL || lst->_head == lst->_head)
निर्वतनम्;
struct ListNode * next = lst->_शिरः->_अगला;
struct ListNode * nextnext = अगला->_अगला;
nextnext->_prev = अगला->_अगला;
lst->_head->_next = अगला अगला;
मुक्त(अगला);
}
void ListErase (सूची * lst, struct ListNode * नोड) {
//शिरः नोड् विलोपयितुं न शक्नोति
यदि (lst == NULL || lst->_head == नोड)
निर्वतनम्;
//पूर्व, नोड, अग्रिम
struct ListNode * पूर्व = नोड-> _पूर्व;
struct ListNode * अगला = नोड->_अगला;
पूर्व->_अगला = अग्रिम;
next->_prev = पूर्व;
मुक्त (नोड);
}
void ListInsert (सूची * lst, struct ListNode * नोड, LDataType val) {
यदि (lst == NULL)
निर्वतनम्;
struct ListNode * पूर्व = नोड-> _पूर्व;
struct ListNode * newNode = सूचीनोड बनाओ (val);
//पूर्व newNode नोड
पूर्व->_अगला = newNode;
newNode->_पूर्व = पूर्व;
newNode->_next = नोड;
नोड->_पूर्व = newNode;
}
//विनश्
ListDestoty (सूची * lst){ 1.1.
यदि (lst){ .
यदि (lst->_head){
struct ListNode * cur = lst->_सिर->_अगला;
while (cur != lst->_शिरः){
struct ListNode * अगला = कट->_अगला;
मुक्त (cur);
cur = अग्रिमः;
}
मुक्त (lst->_शिरः);
}
}
}
शून्य परीक्षण(){ .
सूची lst;
ListInit (& lst);
सूचीपुशफ्रंट (& lst, 5);
printList (& lst);
सूचीपुशफ्रंट (& lst, 1);
printList (& lst);
सूचीपुशफ्रंट (& lst, 2);
printList (& lst);
सूचीपुशफ्रंट (& lst, 3);
printList (& lst);
सूचीपुशफ्रंट (& lst, 4);
printList (& lst);
ListPopFront (& lst);
printList (& lst);
ListPopFront (& lst);
printList (& lst);
ListPopFront (& lst);
printList (& lst);
/ * सूचीपॉपबैक (& lst);
printList (& lst);
ListPopBack (& lst);
printList (& lst);
ListPopBack (& lst);
printList (& lst);
ListPopBack (& lst);
मुद्रणसूची (& lst);*/
}
int मुख्य(){
परीक्षा();
प्रणाली ("विराम");
return 0;
}
अनुक्रमसूचिकायाः लिङ्क् कृतसूचिकायाः च मध्ये अन्तरं सम्बन्धः च : १.
अनुक्रमसारणीयाः लाभाः हानिः च : उत्तमम् : अन्तरिक्षं निरन्तरं भवति, यादृच्छिकप्रवेशस्य समर्थनं करोति, उच्चस्थानस्य उपयोगः भवति तथा च स्मृतिविखण्डनस्य कारणं न भवति, तथा च उच्चपुच्छप्रवेशः, पुच्छविलोपनदक्षता च भवति
हानिः : 1. मध्यभागस्य अथवा अग्रभागस्य सम्मिलितस्य विलोपनस्य च समयजटिलता O(N) भवति 2. क्षमताविस्तारस्य व्ययः तुल्यकालिकरूपेण अधिकः भवति: प्रतिलिपिविमोचनार्थं आवेदनं कुर्वन्तु
लिङ्क्ड् सूचीनां (नेतृत्वेन द्विपक्षीय यादृच्छिकलिङ्क्ड् सूचीः) लाभाः हानिश्च
लाभाः : 1. कस्मिन् अपि स्थाने सम्मिलितस्य विलोपनस्य च समयजटिलता O(1) भवति 2. क्षमताविस्तारस्य समस्या नास्ति, एकं सम्मिलितं कृत्वा एकं स्थानं उद्घाट्यते, तथा च कस्मिन् अपि स्थाने निवेशनस्य विलोपनस्य च कार्यक्षमता अधिका भवति
दोषाः : एतत् नोड्-एककेषु संगृहीतं भवति, यादृच्छिक-प्रवेशस्य समर्थनं न करोति, न्यून-स्थानस्य उपयोगेन च स्मृति-विखण्डनं सहजतया भवितुम् अर्हति ।
स्तम्भाः पङ्क्तयः च
Stack: एकः विशेषः रेखीयसूची या केवलं एकस्मिन् अन्ते तत्त्वानां सम्मिलनं विलोपनं च अनुमन्यते यत्र दत्तांशप्रवेशः विलोपनं च क्रियाः क्रियन्ते सः अन्तः स्तम्भस्य उपरिभागः इति कथ्यते स्तम्भे LIFO (last in first out) सिद्धान्तस्य अनुसरणं करोति
स्तम्भस्य धक्कानम् : स्तम्भस्य निवेशनक्रिया push/push/push इति उच्यते, निवेशितः दत्तांशः च स्तम्भस्य उपरि भवति
Pop: stack इत्यस्य deletion operation popping इति उच्यते, तथा च popping data अपि stack इत्यस्य उपरि भवति ।
push operation push--->स्टैकस्य उपरितः तत्त्वानि संग्रहयन्तु इति कार्यान्वयनम्
अनुक्रमसारणी : इदं पुच्छनिवेशनक्रियारूपेण गणयितुं शक्यते
लिङ्क्ड् सूची: (द्विपक्षीयशीर्षकं वृत्ताकारलिङ्क्ड् सूची) सूचीयाः शिरः स्तम्भस्य उपरिभागः इति गण्यते, यत् शिरःप्रवेशः भवति, सूचीयाः पुच्छं च स्तम्भस्य उपरिभागः इति गण्यते, यत् पुच्छप्रवेशः
Pop operation pop--->ढेरस्य उपरितः तत्त्वानि निष्कासयन्तु
अनुक्रमसारणी : सारणीयाः अन्तः स्तम्भस्य उपरिभागः इति गण्यते, तथा च सः पुच्छविलोपनक्रिया इति गण्यते ।
लिङ्क्ड् सूची: (द्विपक्षीयशिरः वृत्ताकारलिङ्क्ड् सूची) सूचीयाः शिरः स्तम्भस्य उपरिभागः इति गण्यते, यत् शिरः लोपः भवति, सूचीयाः पुच्छं च स्तम्भस्य उपरिभागः इति गण्यते, यत् पुच्छ लोपः ।
#निहितः<stdio.h>
#निहितः<stdlib.h>
typedef int STDataप्रकार;
//अनुक्रमसारणी एकं ढेरं कार्यान्वितं करोति
typedef स्ट्रक्चर स्टैक{
STDataType * _डेटा;
int _आकारः;
int _क्षमता;
}स्त्राव;
void stackInit (ढेर * st){ 1।
यदि (st == NULL)
निर्वतनम्;
st->_डेटा = NULL;
st->_size = st->_क्षमता = 0;
}
void checkCapcacity (ढेर * st){
if (st->_size == st->_क्षमता){
int newCapcacity = st->_क्षमता == 0 ? 1 : 2 * st->_क्षमता;
st->_डेटा = (STDataType *) realloc (st-> _डेटा, sizeof (STDataType) * newCapcacity);
st->_capacity = नई क्षमता;
}
}
//ढेरं कृत्वा स्तम्भं कुर्वन्तु
void stackPush (ढेर * st, STDataType val) {
यदि (st == NULL)
निर्वतनम्;
चेकक्षमता (st);
//पुच्छ सम्मिलन
st->_डेटा [st->_आकार ++] = val;
}
//लोक
void stackPop (ढेर * st){ 1।
यदि (st == NULL)
निर्वतनम्;
यदि (st->_size > 0) .
st->_आकार--;
}
STDataType stackTop (ढेर * st) {
return st->_data [st->_आकार - 1];
}
int stackSize (ढेर * st){
यदि (st == NULL)
return 0;
return st->_size;
}
शून्य परीक्षण(){ .
ढेर st;
stackInit (& st);
stackPush (& st, 1);
stackPush (& st, 2);
stackPush (& st, 3);
stackPush (& st, 4);
for (int इ = ०; इ < ४; ++इ){
printg ("% d", stackTop (& st));
stackPop (& st);
}
printf ("n");
}
int मुख्य(){
परीक्षा();
प्रणाली ("विराम");
return 0;
}
सः ३० वर्षाणाम् अधिकं कालात् प्रौद्योगिक्याः शोधकार्यं कर्तुं समर्पितः अस्ति, तथा च जावा, लिनक्स, जावास्क्रिप्ट्, php, css इत्यादिषु विविधभाषासु प्रवीणः अस्ति, मुक्तस्रोतक्षेत्रे सः बहु योगदानं कृतवान् अस्ति विकासक दस्तावेजीकरणस्थानकं भविष्ये सन्दर्भार्थं प्रौद्योगिकीविकासे केचन विषयाः साझां कर्तुं सर्वे तत् पश्यन्तु
