Technology sharing

Data structuram acervum

2024-07-12

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

Titulus

Hi!

1. Stack

1.1 Basic notiones ACERVUS

Stack: Peculiaris index linearis qui insertionem ac deletionem modo ad certum finem operationes admittit. Finis qui intrat datae insertionis et deletionis operationes, dicitur acervus cacumen, et alter finis imo acervus vocatur.Data elementa in ACERVUS parereLIFO (In First Out) principium. Possumus fingere eum sicut esus musculi kebabs;Pone illud primumIn frusta vervecinis premunturimo，ultima unumIn frusta vervecina suntSuper tectaof.

Strepto ACERVUS: Insertio operatio ACERVUS dicitur dis/dis/dis.Notitia inserta a summo in BIBLIOTHECA。

Pop: Operatio ACERVUS deletio papaver appellatur.Exitus et notitia super verticem ACERVUS。

1,2 exsequendam ACERVUS

ACERVUS plerumque effici potest utendo ordine ad ACERVUM deducendum vel cum indice coniuncto ad acervum efficiendumordinata structuraACERVUS simplicior et efficacior exsequens.

Quia in exsequenda additione, deletione, modificatione et interrogatione interfacies tabulae praecedentis seriei (notitia structura serie mensam) Commodissimum nobis est uti structuram ordinatae a fine inserere et delere, sic in exsequendo ACERVUS, finem ordinatae definimus ut cacumen ACERVUS et caput ut imum. acervus.

2. Stack interface implementation

ACERVUS, sicut album sequentia, designari potest ut acervus stabilis fixus longitudinis vel acervus dynamice crescens.Quia acervus fixus longitudinis magnas limitationes habet et practicus in usu non est, nos maxime adiumentum efficiuntDynamically crescente BIBLIOTHECA。

Eadem cum praecedenti serie album/connexum album interfaciei exsequendi, primum fasciculum caput "Stack.h" creamus et duo fasciculi fons "Stack.c" et "Test.c".

Stack.hStack definition, file header reference and interface function declaration
Stack.cExsequendam interface munera
Test.cTest quisque munus

Primum codicem integrum "Stack.h" exhibeamus, noli oblivisci "Stack.h" in 2 fontium fasciculis referre.

  1. #pragma once				//防止头文件被二次引用
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<assert.h>
  5.  
  6. typedef int ElemType;		//如果要修改存储的数据类型可直接在此修改
  7. typedef struct Stack {
  8. 	ElemType* arr;			//动态数组
  9. 	int top;				//栈顶
  10. 	int capacity;			//容量
  11. }Stack;
  12.  
  13.  
  14. void StackInit(Stack* ps);//初始化栈
  15.  
  16. void StackPush(Stack* ps, ElemType x);//入栈
  17.  
  18. void StackPop(Stack* ps);//出栈
  19.  
  20. ElemType StackTop(Stack* ps);//获取栈顶元素
  21.  
  22. int StackSize(Stack* ps);//获取栈中有效元素的个数
  23.  
  24. int StackEmpty(Stack* ps);//检测栈是否为空,如果为空返回非零结果,如果不为空返回0
  25.  
  26. void StackDestroy(Stack* ps);//销毁栈

Inter eos, significatio "caput" a valore initiali determinatur, de quo infra singillatim exponetur. Deinceps interfaciendi causa incipitur.

(I) Initialization acervus
  1. //初始化栈
  2. void StackInit(Stack* ps) {
  3. 	assert(ps);		//断言,防止传入空指针
  4. 	ps->arr = NULL; //初始化数组,置空
  5. 	ps->capacity = 0;//top指向栈顶元素的下一个位置
  6. 	ps->top = 0;	 //初始化容量
  7. }

Pro facilitate intellectus, proxime intelligimus supremam structuram, sicut subscriptum ordinatae.Si initialize summo ad 0 cum acervum initializemus, nulla notitia in acervo est, et cacumen puncta ad proximam positionem summae datae in ACERVUS.

Si initialize summo ad -1, culmen ad locum datae in ACERVUS monstrabit. Praestat nobis initialize hanc 0 hic, quia opportunum est elementa addere et elementa delere.

(II) ventilabis in ACERVUS
  1. //入栈
  2. void StackPush(Stack* ps, ElemType x) {
  3. 	//扩容
  4. 	if (ps->capacity == ps->top) //容量已满,需要扩容
  5. 	{
  6. 		//如果容量为0,则扩容到4; 否则扩大2倍
  7. 		int newCapacity = ps->capacity == 0 ? 4 : 2 * (ps->capacity);
  8. 		//创建一个临时指针变量来存储新空间地址,防止开辟失败
  9. 		ElemType* temp = realloc(ps->arr, newCapacity * sizeof(ElemType));
  10. 		if (temp == NULL) //防止开辟失败出现空指针
  11. 		{
  12. 			perror("realloc fail!n");
  13. 			exit(1);
  14. 		}
  15. 		ps->arr = temp;	  //将临时指针变量中存放的新空间地址赋给arr
  16. 		ps->capacity = newCapacity;//空间容量更新
  17. 	}
  18. 	ps->arr[ps->top] = x;//将数据存放进栈顶元素的下一个位置
  19. 	ps->top++;//位置更新
  20. }

Quia differentia est inter acervum et mensam sequentiam, non possumus directe percurrere et imprimere. Si igitur elementa in ACERVA imprimi velimus, opus est uti munere StackEmpty et munere StackPop, de quo postea disputabitur. .

(3) Pop out
  1. //出栈
  2. void StackPop(Stack* ps) {
  3. 	assert(ps);			//断言,防止传入空指针
  4. 	assert(ps->top);	//断言,防止栈中没有元素,却还在执行删除
  5. 	ps->top--;			//top指针往前挪动一位(相当于这个位置被覆盖了)
  6. }
(IV) elementum Get summo in ACERVUS
  1. //获取栈顶元素
  2. ElemType StackTop(Stack* ps) {
  3. 	assert(ps);				//断言,防止传入空指针
  4. 	assert(ps->top);		//断言,防止栈为空
  5. 	return ps->arr[ps->top - 1];//top-1为栈顶元素的位置,返回其值
  6. }
(V) numerus valida elementa in ACERVUS Get
  1. //获取栈中有效元素的个数
  2. int StackSize(Stack* ps) {
  3. 	assert(ps);				//断言,防止传入空指针
  4. 	return ps->top;			//top即为有效元素的个数
  5. }
(VI) Reprehendo an ACERVUS inanis est
  1. //检测栈是否为空,如果为空返回非零结果,如果不为空返回0
  2. int StackEmpty(Stack* ps) {
  3. 	assert(ps);				//断言,防止传入空指针
  4. 	return ps->top == 0;	//如果top==0, 说明栈为空
  5. }

Inde est, quod StackEmpty in praecedenti assertione addi debetlogice negatio operatorRatio est, quia si acervus inanis est, vera StackEmpty redit, et negatio falsa probare potest elementa in acervo esse.

(VII) Solvite acervum
  1. //销毁栈
  2. void StackDestroy(Stack* ps) {
  3. 	assert(ps);				//断言,防止传入空指针
  4. 	if (ps->arr)			//如果动态数组有效
  5. 	{
  6. 		free(ps->arr);		//释放arr
  7. 		ps->arr = NULL;		//将arr置空
  8. 	}
  9. 	ps->capacity = 0;		//数组的容量为0
  10. 	ps->top = 0;			//数组的栈顶top为0
  11.  
  12. }

Postquam omnia interfaces completa sunt, experiamur codicem in Test.c:

Experiamur aliquid amplius:

Nulla quaestio omnino. Gratulationes peractae exsequendae ACERVUS!

  1. #include"Stack.h"
  2.  
  3. //初始化栈
  4. void StackInit(Stack* ps) {
  5. 	assert(ps);		//断言,防止传入空指针
  6. 	ps->arr = NULL; //初始化数组,置空
  7. 	ps->capacity = 0;//top指向栈顶元素的下一个位置
  8. 	ps->top = 0;	 //初始化容量
  9. }
  10.  
  11. //入栈
  12. void StackPush(Stack* ps, ElemType x) {
  13. 	//扩容
  14. 	if (ps->capacity == ps->top) //容量已满,需要扩容
  15. 	{
  16. 		//如果容量为0,则扩容到4; 否则扩大2倍
  17. 		int newCapacity = ps->capacity == 0 ? 4 : 2 * (ps->capacity);
  18. 		//创建一个临时指针变量来存储新空间地址,防止开辟失败
  19. 		ElemType* temp = realloc(ps->arr, newCapacity * sizeof(ElemType));
  20. 		if (temp == NULL) //防止开辟失败出现空指针
  21. 		{
  22. 			perror("realloc fail!n");
  23. 			exit(1);
  24. 		}
  25. 		ps->arr = temp;	  //将临时指针变量中存放的新空间地址赋给arr
  26. 		ps->capacity = newCapacity;//空间容量更新
  27. 	}
  28. 	ps->arr[ps->top] = x;//将数据存放进栈顶元素的下一个位置
  29. 	ps->top++;//位置更新
  30. }
  31.  
  32. //出栈
  33. void StackPop(Stack* ps) {
  34. 	assert(ps);			//断言,防止传入空指针
  35. 	assert(ps->top);	//断言,防止栈中没有元素,却还在执行删除
  36. 	ps->top--;			//top指针往前挪动一位(相当于这个位置被覆盖了)
  37. }
  38.  
  39. //获取栈顶元素
  40. ElemType StackTop(Stack* ps) {
  41. 	assert(ps);				//断言,防止传入空指针
  42. 	assert(ps->top);		//断言,防止栈为空
  43. 	return ps->arr[ps->top - 1];//top-1为栈顶元素的位置,返回其值
  44. }
  45.  
  46. //获取栈中有效元素的个数
  47. int StackSize(Stack* ps) {
  48. 	assert(ps);				//断言,防止传入空指针
  49. 	return ps->top;			//top即为有效元素的个数
  50. }
  51.  
  52. //检测栈是否为空,如果为空返回非零结果,如果不为空返回0
  53. int StackEmpty(Stack* ps) {
  54. 	assert(ps);				//断言,防止传入空指针
  55. 	return ps->top == 0;	//如果top==0, 说明栈为空
  56. }
  57.  
  58. //销毁栈
  59. void StackDestroy(Stack* ps) {
  60. 	assert(ps);				//断言,防止传入空指针
  61. 	if (ps->arr)			//如果动态数组有效
  62. 	{
  63. 		free(ps->arr);		//释放arr
  64. 		ps->arr = NULL;		//将arr置空
  65. 	}
  66. 	ps->capacity = 0;		//数组的容量为0
  67. 	ps->top = 0;			//数组的栈顶top为0
  68.  
  69. }

Exercitium sectionis

1. Quod de his dictis circa acervos est verum ()

A. ACERVUS est "primus in primo e" notitia compages

B. Stack impleri potest utens coniunctum album vel seriem album

C. ACERVUS non solum inserere notitia in fundo ACERVUS

D. BIBLIOTHECA potest delere notitia

rectam responsum: B

Error A: BIBLIOTHECA ultima est in-primo-e data structura, queue est primo-in, primo-e.

B verum est: Utraeque tabulae series et index conexi ad acervos deducendi adhiberi possunt, sed series indices generaliter adhibentur quia ACERVUS castratus reputatur versio seriei indicem usus est, et cauda insertio tabulae sequentiae adhibetur.

C error: BIBLIOTHECA input insertio et deletio operationum in summo ACERVUS non potest praestare

D error: ACERVUS impulsus et pop operationes habet.

2. Ordo acervus dis est ABCDE , et impossibilis pop series est ( )

A.ABCDE

B.EDCBA

C.DCEBA

D.ECDBA

rectam responsum: D

Si E primo exeat, significat ABCDE totum in acervum eiectum. .

Ergo eligendus est D

3. Cum sequentiae acervus comparatus, manifestae commoda catenae acervus sunt ( )

A. operatio commodius insertio

B. Deletio operatio commodius est

C. dilatatio non requiritur cum propellentibus in ACERVUS

rectam responsum: C

Error A. Si ACERVUS coniunctus est, plerumque capitis insertionem vel capitis deletionem requirit, dum ACERVUS sequentialis plerumque caudam insertionem et operationes deletionis caudae praestat simplicius utatur sequentiae structurae ad efficiendum acervum.

B perperam, quaeso refer ad A pro ratione.

C recte.

4. Quod ex his quae de utens acervos ad effectum deducendi queues falsa est ()

A. Acervus simulationis usus ad efficiendum queue duobus acervis uti potest, unus acervus queue intrantem simulat, et unus acervus queue relinquens simulat.

B. Quotienscumque dequeue, omnia elementa in unum acervum in alium acervum importare debes et ex eo pop.

C. Cum intrantes queue, mox elementa directe in acervum reponunt queue simulat ingrediens.

D. Tempus complexionis queue operationis est O (1).

rectam responsum: B

In optione B, unus acervus simulat ingrediens queue, et unus acervus simulat dequeuing . Elementa omni tempore importari debent, error est

In optione A, characteres acervos et queues oppositi sunt.

In optione C, unus acervus simulat ingrediens queue, et unus acervus simulat queue relinquens.

In optio D, queueing significat elementa in acervo ponere, ergo tempus complexionis est O (1).

Ending

Hodie de notitia acervi structuram didicimus. Estne multo simplicius quam indicem coniunctum?

oroSimilis, ventus et sequere!!!

gratias omnibus do! ! !

Personal profile

technologiae technologiae plus quam 30 annos operam dedit et in variis linguis proficit ut java, linux, javascript, php, css, etc. Multas contributiones in aperto fonte campo fecit elit documentorum statione ad communicandas quaestiones in technologia progressus ad futuram referentiam

mihi contactus notitia

Mail