प्रौद्योगिकी साझेदारी

दत्तांशसंरचना (भाग 2)--रेखीय सारणी

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

सामग्रीसूची

1. मूलभूतसंकल्पना

2. रेखीयसारणीनां मूलभूतक्रियाः

3. अनुक्रमसारणी

(1).स्थिर आवंटन

(2).गतिशील आवंटन

(3) अनुक्रमसारणीनां सम्मिलनं विलोपनं च (स्थिरविनियोगं उदाहरणरूपेण गृहीत्वा) (नमूनासङ्केते आवश्यकानि मूलभूतकार्यं भवति) ।

(4) बिट् क्रमेण अन्वेषणं कुर्वन्तु, मूल्येन अन्वेषणं कुर्वन्तु

4. लिङ्क् कृतसूची

(1).एकललिङ्कितसूची

i. एकललिङ्कितसूचिकायाः ​​परिभाषा (लीड नोड्) ।

1. मूलभूतसंकल्पना

रेखीय सारणी : १.

(1).तस्मिन् प्रत्येकं तत्त्वं, .समानः दत्तांशप्रकारः。

(२).तत्त्वानां मध्ये, २.क्रमेण。

(३)शीर्षकतत्त्वम्तथापुच्छतत्त्वम्。

(4).शीर्षकं पादलेखं च विहाय प्रत्येकस्य तत्त्वस्य कृते एकं द्रष्टुं शक्यतेप्रत्यक्षपूर्ववर्तीतथाप्रत्यक्ष उत्तराधिकारी。

2. रेखीयसारणीनां मूलभूतक्रियाः

पीठिकाआद्यतः एव

InitList (एण्ड एल) .आरम्भीकरणम्रेखीयसारणी

DestroyList(&L): 1.1.विनश्

。

ListInsert (& एल, मैं, ई):युज्, सारणी L मध्ये i-तमे तत्त्वं e सम्मिलितं कुर्वन्तु

ListDelete(&L, i, &e):लुप्, table L इत्यस्य i-th element इत्येतत् विलोपयन्तु, तथा च deleted element इत्यस्य प्रत्यागमनार्थं e इत्यस्य उपयोगं कुर्वन्तु

。

LocateElem (L, e): प्रेसमूल्यम्‌अन्वेषणं कुर्वन्तु, सारणीयां विशिष्टस्य कीवर्डस्य e इत्यस्य तत्त्वं अन्वेष्टुम्, e इत्यस्य क्रमं प्रत्यागच्छन्तु, न तु उपलिपिम्

GetElem (L, i): दबाएँकिञ्चित्सारणीयां i-th element इत्यस्य मूल्यं प्राप्तुं अन्वेषणं कुर्वन्तु

。

अन्ये सामान्यक्रियाः : १.

लम्बाई(L): ज्ञात कीजिएमेजस्य नेताव्ययीकरोतु

मुद्रणसूची(L): .उत्पादनम्पीठिकासर्वेतत्व

रिक्त(L): न्यायसारणीशून्यं किम्, सत्यं वा असत्यं वा प्रत्यागच्छति

अत्यन्तं सारांशतः अर्थात् विक्रयस्य निर्माणं तथा च योजनं, विलोपनं, परिवर्तनं, परीक्षणं च

3. अनुक्रमसारणी

इत्यनेनक्रमिक भण्डारणदत्तांशस्य रेखीयसारणी

(1).स्थिर आवंटन

  1. #define MAX 10
  2. //顺序表（静态分配）
  3. class SqList
  4. {
  5. public:
  6.     int data[MAX];
  7.     int length;
  8. };
  9. //初始化
  10. void InitList(SqList &l)
  11. {
  12.     for(int i = 0 ;i < 10 ;i++)
  13.     {
  14.         l.data[i] = 0;
  15.     }
  16.     l.length = 0;
  17. }
  18. //打印所有元素
  19. void PrintList(SqList &l)
  20. {
  21.     for (int i = 0; i < 10; i++)
  22.         cout << "第" << i << "个数：" << l.data[i] << endl;
  23. }
  24.  
  25. //测验
  26. void test01()
  27. {
  28.     SqList l;
  29.     InitList(l);
  30.     PrintList(l);
  31. }

(2).गतिशील आवंटन

  1. #define InitSize 10
  2. //顺序表（动态分配）
  3. class SqList
  4. {
  5. public:
  6. 	int* data;		//指示动态分配数组的指针
  7. 	int MaxSize;	//指示最大容量
  8. 	int length;		//指示当前长度
  9. };
  10. //初始化顺序表
  11. void InitList(SqList& l)
  12. {
  13. 	l.data = new int[InitSize];
  14. 	l.MaxSize = InitSize;
  15. 	l.length = 0;
  16. 	for (int i = 0; i < l.MaxSize; i++)
  17. 	{
  18. 		l.data[i] = 0;
  19. 	}
  20. }
  21. //增长数组空间
  22. void IncreaseSize(SqList& l, int len)
  23. {
  24. 	int* p = l.data;					//暂存原数组中的数据
  25. 	l.data = new int[10 + len];			//扩展新的数组
  26. 	for (int i = 0; i < l.length; i++)	//将原数据拷贝进新数组中
  27. 	{
  28. 		l.data[i] = p[i];
  29. 	}
  30. 	l.MaxSize = InitSize + len;			//修改数组的状态数据
  31. 	delete p;							//将p释放
  32. }
  33. //打印所有元素
  34. void PrintList(SqList& l)
  35. {
  36. 	for (int i = 0; i < 10; i++)
  37. 		cout << "第" << i << "个数：" << l.data[i] << endl;
  38. }
  39.  
  40. void test01()
  41. {
  42. 	SqList l;
  43. 	InitList(l);
  44. 	PrintList(l);
  45. }

(3) अनुक्रमसारणीनां सम्मिलनं विलोपनं च (स्थिरविनियोगं उदाहरणरूपेण गृहीत्वा) (नमूनासङ्केते आवश्यकानि मूलभूतकार्यं भवति) ।

//युज्

bool ListInsert (SqList& एल, int d, int ई)
{
if (l.length &gt;= MAX) //प्रथमं निर्धारयन्तु यत् सारणी पूर्णा अस्ति वा, सम्मिलनं कानूनी अस्ति वा इति।
    {
cout &lt;&lt; "प्रवेशः विफलः, ऊर्ध्वसीमा प्राप्ता" &lt;&lt; endl;
false प्रत्यागच्छतु;
    }
        
यदि (d &lt; 1 || d &gt; ल.दीर्घता + 1) .
    {
cout &lt;&lt; "प्रवेशः विफलः, प्रत्यक्षः पूर्ववर्ती नास्ति" &lt;&lt; endl;
false प्रत्यागच्छतु;
    }
for (int j = l.length; j &gt;= d; j--) //प्रवेशबिन्दुस्य अनन्तरं तत्त्वं पृष्ठतः चालयन्तु
l.data [j] = l.data [ज - 1];
l.data[d - 1] = e; //Insertion, यतः d संख्यां निर्दिशति, सरणीरूपान्तरणे एकं घटितव्यम्
ल.दीर्घता++;
return true;
}

//लुप्
bool ListDelete (SqList& l, int d, int & ई)
{
if (d &lt; 1 || d &gt;l.length) //विलोपिता स्थितिः कानूनी अस्ति वा इति निर्धारयतु
false प्रत्यागच्छतु;
e = l.data[d - 1] //अस्थायीरूपेण विलोपिततत्त्वान् संग्रहयन्तु
for (int j = d; j &lt; l.length; j++) //विलोपिततत्त्वस्य अनन्तरं तत्त्वं अग्रे चालयन्तु
l.data[j - 1] = l.data[j]; j+1 आच्छादयति, j+1 च अन्ते सरणीयाः अधिकतमक्षमताम् अतिक्रमितुं शक्नोति
ल.दीर्घता--;
return true;
}

नमूना कोड

  1. #define MAX 10
  2. //顺序表（静态分配）
  3. class SqList
  4. {
  5. public:
  6.     int data[MAX];
  7.     int length;
  8. };
  9. //初始化
  10. void InitList(SqList& l)
  11. {
  12.     for (int i = 0; i < 10; i++)
  13.     {
  14.         l.data[i] = 0;
  15.     }
  16.     l.length = 0;
  17. }
  18. //打印所有元素
  19. void PrintList(SqList& l)
  20. {
  21.     for (int i = 0; i < 10; i++)
  22.         cout << "第" << i << "个数：" << l.data[i] << endl;
  23. }
  24. //存入数据
  25. void InputElem(SqList& l, int e)
  26. {
  27.     int i = 0;
  28.     while (i < MAX)
  29.     {
  30.         if (l.data[i] == 0)
  31.         {
  32.             l.data[i] = e;
  33.             l.length++;
  34.             break;
  35.         }
  36.         i++;
  37.     }
  38. }
  39. //获取顺序表长度
  40. int GetLength(SqList l)
  41. {
  42.     //cout << l.length << endl;
  43.     return l.length;
  44. }
  45. //插入
  46. bool ListInsert(SqList& l, int d, int e)
  47. {
  48.     if (l.length >= MAX)                        //首先要判断表是否已满、插入是否合法
  49.     {
  50.         cout << "插入失败，已达上限" << endl;
  51.         return false;
  52.     }
  53.         
  54.     if (d < 1 || d > l.length + 1)
  55.     {
  56.         cout << "插入失败,无直接前驱" << endl;
  57.         return false;
  58.     }
  59.     for (int j = l.length; j >= d; j--)         //将插入点之后的元素后移
  60.         l.data[j] = l.data[j - 1];
  61.     l.data[d - 1] = e;                          //插入，因为d指的是第几个数，在数组的换算中要减一
  62.     l.length++;
  63.     return true;
  64. }
  65. //删除
  66. bool ListDelete(SqList& l, int d, int &e)
  67. {
  68.     if (d < 1 || d >l.length)                   //判断删除的位置是否合法
  69.         return false;
  70.     e = l.data[d - 1];                          //暂存删除掉的元素
  71.     for (int j = d; j < l.length; j++)          //将被删除元素之后的元素前移
  72.         l.data[j - 1] = l.data[j];              //此处，必须是j = d，j-1被j覆盖，若j = d-1，则下文的覆盖会变为j 被j+1 覆盖，而j+1在最后有可能会超过数组的最大容量
  73.     l.length--;
  74.     return true;
  75. }
  76.  
  77. //查看情况
  78. void CheckList(SqList& l)
  79. {
  80.     PrintList(l);
  81.     cout << "当前长度为" << GetLength(l) << endl;
  82. }
  83.  
  84. //测验
  85. void test01()
  86. {
  87. 	SqList l;
  88. 	InitList(l);
  89.     
  90.     //输入部分数据
  91.     InputElem(l, 1);
  92.     InputElem(l, 2);
  93.     InputElem(l, 3);
  94.     InputElem(l, 4);
  95.     CheckList(l);
  96.  
  97.     //开始插入
  98.     if(ListInsert(l, 3, 6))
  99.         CheckList(l);
  100.  
  101.     //开始删除
  102.     int a = -1;
  103.     if (ListDelete(l, 2, a))
  104.         CheckList(l);
  105. }

(4) बिट् क्रमेण अन्वेषणं कुर्वन्तु, मूल्येन अन्वेषणं कुर्वन्तु

अतीव सरलम्, विस्तरेण गन्तुं आवश्यकता नास्ति

  1. //判断d的合法性
  2. bool JugdeD(SqList l, int d)
  3. {
  4.     if (d < 1 || d > l.length)
  5.         return false;
  6.     return true;
  7. }
  8.  
  9. //按位序查找
  10. int GetElem(SqList l, int d)
  11. {
  12.     if (JugdeD(l, d))
  13.         return l.data[d - 1];
  14.     return 0;
  15. }
  16.  
  17. //按值查找
  18. int LocateElem(SqList l, int e)
  19. {
  20.     for (int i = 0; i < l.length; i++)
  21.     {
  22.         if (l.data[i] == e)       //数组储存的数据，若是类等复杂的数据类型，则需要对等号进行重载
  23.             return i + 1;
  24.     }
  25.     return 0;
  26. }
  27. //其余代码与上文相同
  28. //其中，JugdeD函数可以替换上文插入与删除中对位序合法性的判别————封装

4. लिङ्क् कृतसूची

इत्यनेनश्रृङ्खला भण्डारणम्दत्तांशस्य रेखीयसारणी

(1).एकललिङ्कितसूची

i. एकललिङ्कितसूचिकायाः ​​परिभाषा (लीड नोड्) ।

  1. //单链表
  2. class LNode
  3. {
  4. public:
  5.     int data;           //数据域，存放数据
  6.     LNode* next;        //指针域，指向下一个节点
  7. };
  8. //用using关键字给类起别名，用LinkList指代的是头结点，代表的是整个链表
  9. using LinkList = LNode*;
  10.  
  11. //初始化
  12. bool InitList(LinkList& L)
  13. {
  14.     L = new LNode();
  15.     if (L == nullptr)   //如果成立，则说明内存不足，分配失败
  16.         return false;
  17.     L->next = nullptr;
  18.     return true;
  19. }

ii.प्रवेशः विलोपनं च (अग्रणी नोडः) ।

यदि हेड नोड् नास्ति तर्हि हेड सूचकस्य परिवर्तनं प्रति ध्यानं ददातु अन्यत् सर्वं समानम् अस्ति ।

सम्मिलितं (नियमितसंस्करणम्) २.

  1. //插入
  2. bool ListInsert(LinkList& L, int i, int e)
  3. {
  4.     if (i < 1)                          //判断插入位点是否合法[1]——i值的合法性
  5.     {
  6.         cout << "i为负数" << endl;
  7.         return false;
  8.     }    
  9.     LNode* p = L;                       //让p与L指向相同的位点，L是指示头指针的，所以L是不能改变的
  10.     LNode* s = new LNode();             //新的数据储存
  11.     s->data = e;
  12.     while (p != nullptr && i != 1)      //由头结点起始，开始遍历寻找对应位点
  13.     {
  14.         p = p->next;
  15.         i--;
  16.     }
  17.     if (p == nullptr)                   //判断插入的位点是否合法[2]——i值对应的节点的合法性
  18.     {
  19.         cout << "插入位点超出实际长度" << endl;
  20.         return false;
  21.     }                     
  22.     s->next = p->next;                  //开始接轨，顺序不能乱
  23.     p->next = s;
  24.     return true;
  25. }

सम्मिलितं (सङ्कुलितसंस्करणम्) २.

  1. //特定节点的后插操作
  2. bool InsertNextNode(LNode* p, int e)
  3. {
  4.     if (p == nullptr)                   
  5.     {
  6.         cout << "插入位点超出实际长度" << endl;
  7.         return false;
  8.     }
  9.     LNode* s = new LNode();
  10.     s->data = e;
  11.     s->next = p->next;
  12.     p->next = s;
  13.     return true;
  14. }
  15. //插入
  16. bool ListInsert(LinkList& L, int i, int e)
  17. {
  18.     if (i < 1)                          //判断插入位点是否合法[1]——i值的合法性
  19.     {
  20.         cout << "i为负数" << endl;
  21.         return false;
  22.     }    
  23.     LNode* p = L;                       //让p与L指向相同的位点，L是指示头指针的，所以L是不能改变的
  24.     while (p != nullptr && i != 1)      //由头结点起始，开始遍历寻找对应位点
  25.     {
  26.         p = p->next;
  27.         i--;
  28.     }
  29.     return InsertNextNode(p, e);        //被封装了的部分
  30. }

 

व्यक्तिगत प्रोफाइल

सः ३० वर्षाणाम् अधिकं कालात् प्रौद्योगिक्याः शोधकार्यं कर्तुं समर्पितः अस्ति, तथा च जावा, लिनक्स, जावास्क्रिप्ट्, php, css इत्यादिषु विविधभाषासु प्रवीणः अस्ति, मुक्तस्रोतक्षेत्रे सः बहु योगदानं कृतवान् अस्ति विकासक दस्तावेजीकरणस्थानकं भविष्ये सन्दर्भार्थं प्रौद्योगिकीविकासे केचन विषयाः साझां कर्तुं सर्वे तत् पश्यन्तु

मम सम्पर्कसूचना

मेल