Compartir tecnología

Estructura de datos (Parte 2): tabla lineal

2024-07-12

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

Tabla de contenido

1. Conceptos básicos

2. Operaciones básicas de tablas lineales.

3. Tabla de secuencia

(1).Asignación estática

(2).Asignación dinámica

(3). Inserción y eliminación de tablas de secuencia (tomando la asignación estática como ejemplo) (el código de muestra contiene las funciones básicas necesarias)

(4). Buscar por orden de bits, buscar por valor.

4. Lista enlazada

(1).Lista enlazada individualmente

i. Definición de lista enlazada individualmente (nodo principal)

1. Conceptos básicos

Mesa lineal:

(1). Cada elemento que contiene,Mismo tipo de datos。

(2). Entre elementos,En orden。

(3).elemento de encabezadoyelemento de cola。

(4).Excepto el encabezado y el pie de página, se puede encontrar uno para cada elemento.precursor directoysucesor directo。

2. Operaciones básicas de tablas lineales.

mesaDesde cero

ListaInit(&L):inicializaciónuna mesa lineal

Lista de destrucción (&L):destruir

。

ListaInsertar(&L, i, e):insertar, inserte el elemento e en la i-ésima posición en la tabla L

ListaEliminar(&L, i, &e):borrar, elimine el elemento i-ésimo de la tabla L y use e para devolver el elemento eliminado

。

LocalizarElem(L, e): PresionevalorBusque, encuentre el elemento de la palabra clave específica e en la tabla, devuelva el orden de e, no el subíndice

GetElem(L,i): presionePocoBusque para obtener el valor del i-ésimo elemento de la tabla

。

Otras operaciones generales:

Longitud (L): Buscarlíder de mesaGastar

Lista de impresión (L):producciónmesatodoelemento

Vacío (L): mesa de juicio¿Está vacío?, devuelve verdadero o falso

Altamente resumido, es decir, crear ventas y agregar, eliminar, modificar y verificar

3. Tabla de secuencia

poralmacenamiento secuencialtabla lineal de datos

(1).Asignación estática

  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).Asignación dinámica

  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). Inserción y eliminación de tablas de secuencia (tomando la asignación estática como ejemplo) (el código de muestra contiene las funciones básicas necesarias)

//insertar

bool ListaInsertar(SqList&l, int d, int e)
{
if (l.length &gt;= MAX) // Primero, determine si la tabla está llena y si la inserción es legal.
    {
cout &lt;&lt; "Falló la inserción, se alcanzó el límite superior" &lt;&lt; endl;
falso retorno;
    }
        
si (d &lt; 1 || d &gt; l.longitud + 1)
    {
cout &lt;&lt; "Error de inserción, no hay predecesor directo" &lt;&lt; endl;
falso retorno;
    }
for (int j = l.length; j &gt;= d; j--) //Mover el elemento después del punto de inserción hacia atrás
l.datos[j] = l.datos[j - 1];
l.data[d - 1] = e; //Inserción, debido a que d se refiere al número, se debe restar uno en la conversión de la matriz.
l.longitud++;
devuelve verdadero;
}

//borrar
bool ListDelete(SqList& l, int d, int &e)
{
if (d &lt; 1 || d &gt;l.length) //Determina si la posición eliminada es legal
falso retorno;
e = l.data[d - 1]; //Almacenar temporalmente los elementos eliminados
for (int j = d; j &lt; l.length; j++) //Mover el elemento después del elemento eliminado hacia adelante
l.data[j - 1] = l.data[j]; // Aquí, debe ser j = d, j-1 está cubierto por j, si j = d-1, la siguiente cobertura será j está cubierto j+1 cubre, y j+1 puede exceder la capacidad máxima de la matriz al final
l.longitud--;
devuelve verdadero;
}

Código de muestra

  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). Buscar por orden de bits, buscar por valor.

Muy sencillo, no es necesario entrar en detalles.

  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. Lista enlazada

poralmacenamiento en cadenatabla lineal de datos

(1).Lista enlazada individualmente

i. Definición de lista enlazada individualmente (nodo principal)

  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. Inserción y eliminación (nodo principal)

Si no hay un nodo principal, preste atención al cambio del puntero principal. Todo lo demás es igual.

Insertar (versión normal)

  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. }

Insertar (versión empaquetada)

  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. }

 

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo