La tabla lineal (linear_list) es la estructura de datos más común y simple. En resumen, una tabla lineal es una secuencia finita de n elementos de datos. En cuanto al significado específico de cada elemento de datos, es diferente en diferentes situaciones: puede ser una cantidad de símbolos, una página o incluso otra información más compleja. Por ejemplo, los 26 alfabetos ingleses son una tabla lineal, y los elementos de datos en la tabla son caracteres alfabéticos individuales.
(A,B,C,...,Z)
Como otro ejemplo, el cambio de la cantidad de computadoras propiedad de una escuela primaria de 2000 a 2020 se puede dar en forma de una tabla lineal, y los elementos de datos en la tabla son enteros
(6,12,23,34,45,...,99)
En una tabla lineal un poco más complicada, un elemento de datos puede estar compuesto de varios elementos de datos . En este caso, el elemento de datos a menudo se denomina registro , y una tabla lineal con una gran cantidad de registros también se denomina archivo.
Por ejemplo, la tabla de clasificación del estado de salud del estudiante de una escuela. La condición de cada estudiante en la tabla es un registro. Los seis elementos de datos son número de estudiante, sexo, edad, clase y estado de salud.
En resumen, los elementos de datos en la tabla lineal pueden ser varios, pero los elementos en la misma tabla lineal deben tener las mismas características, es decir, pertenecer al mismo objeto de datos, y existe una relación de orden uniforme entre los elementos de datos adyacentes. Si la tabla lineal se escribe como,
entonces ai-1 está por delante de ai y ai está por delante de ai + 1. Se dice que ai-1 es el precursor directo de ai, y ai + 1 es el sucesor directo de ai. Cuando i = 1,2, ··, n-1, ai tiene un único sucesor directo, cuando i = 2,3, ··, n, ai tiene un único precursor directo.
注意：除第一个之外，集合中的每个数据元素均只有一个前驱；
除最后一个之外，集合中每个数据元素均只有一个后继；
El número de elementos en la tabla lineal n (n> = 0) se define como la longitud de la tabla lineal. Cuando n = 0, se denomina tabla vacía. Cada elemento en la tabla no vacía tiene una posición definida, como a1 es el primer elemento de datos, an es el último elemento de datos, ai es el i-ésimo elemento de datos e i se llama el elemento de datos ai en la tabla lineal Orden de bits
La tabla lineal es una estructura de datos bastante flexible, y su longitud se puede aumentar o acortar según sea necesario, es decir, no solo se puede acceder a los elementos abstractos de la tabla lineal, sino también insertarlos y eliminarlos.
ADT List {
数据对象：D＝{ | ∈ ElemSet, i=1,2,...,n, n≥0 }
数据关系：R1＝{ <ai-1 ,ai >| ,∈D, i=2,...,n }
基本操作：
{结构初始化}
InitList( &L )
操作结果：构造一个空的线性表 L 。
{销毁结构}
DestroyList( &L )
初始条件：线性表 L 已存在。
操作结果：销毁线性表 L 。
例如，26个小写英文字母是一个线性表
(a,b,…,z)
同一花色的13张扑克牌
(2,3,4,5,6,7,8,9,10,J,Q,K,A)
可以构成一个线性表。
序偶 <,> 表示 是 的直接前驱，反之， 是 的直接后继。
{引用型操作}
ListEmpty( L )
初始条件：线性表L已存在。
操作结果：若 L 为空表，则返回 TRUE，否则返回 FALSE。
ListLength( L )
初始条件：线性表 L 已存在。
操作结果：返回 L 中元素个数。
PriorElem( L, cur_e, &pre_e )
初始条件：线性表 L 已存在。
操作结果：若 cur_e 是 L 中的数据元素，则用 pre_e 返回它的前驱，
否则操作失败，pre_e 无定义。
NextElem( L, cur_e, &next_e )
初始条件：线性表 L 已存在。
操作结果：若 cur_e 是 L 中的数据元素，则用 next_e 返回它的后继，
否则操作失败，next_e 无定义。
GetElem( L, i, &e )
初始条件：线性表 L 已存在，1≤i≤LengthList(L)。
操作结果：用 e 返回 L 中第 i 个元素的值。
LocateElem( L, e, compare( ) )
初始条件：线性表 L 已存在，compare( ) 是元素判定函数。
操作结果：返回 L 中第1个与 e 满足关系 compare( ) 的元素的位序。
若这样的元素不存在，则返回值为0。
ListTraverse(L, visit( ))
初始条件：线性表 L 已存在，visit( ) 为元素的访问函数。
操作结果：依次对 L 的每个元素调用函数 visit( )。
一旦 visit( ) 失败，则操作失败。
{加工型操作}
ClearList( &L )
初始条件：线性表 L 已存在。
操作结果：将 L 重置为空表。
PutElem( &L, i, &e )
初始条件：线性表L已存在，1≤i≤LengthList(L)。
操作结果：L 中第 i 个元素赋值同 e 的值。
ListInsert( &L, i, e )
初始条件：线性表 L 已存在，1≤i≤LengthList(L)+1。
操作结果：在 L 的第 i 个元素之前插入新的元素 e，L 的长度增1。
ListDelete( &L, i, &e )
初始条件：线性表 L 已存在且非空，1≤i≤LengthList(L)。
操作结果：删除 L 的第 i 个元素，并用 e 返回其值，L 的长度减1。
} ADT List
Para más detalles, consulte https://blog.csdn.net/m57091003/article/details/1911982
Para la tabla lineal del tipo de datos abstractos definida anteriormente, también puede realizar algunas operaciones más complejas, por ejemplo, fusionar dos o más tablas lineales en una tabla lineal; dividir una tabla lineal en dos o más Tabla lineal; vuelva a copiar una tabla lineal, etc.
Ejemplo:
假设利用两个线性表LA和LB分别表示两个集合A和B（即线性表中的数据元素即为集合中的成员），
现要求一个新的集合A = A U B。这就要求对线性表做如下操作：
扩大线性表LA,将存在于线性表LB中依次取得每个数据元素，并依次在线性表LA中进行查看，若不存在，则插入。
void union(List &La, List Lb){
//将所有在线性表Lb但不在La中的数据元素插入到La中
La_len = ListLength(La);
Lb_len = ListLength(Lb); //求线性表的长度
for(i=1;i<=Lb_len;i++){
GetElem(Lb,i,e); //求Lb中第i个数据元素赋给e
if(!LocateElem(La,e,equal)
ListInsert(La,++La_len,e);
//La中不存在和e相同数据元素，则插入
}
}//union
Ejemplo:
已知线性表LA和LB中国的数据元素按值递增有序排列，现要求将LA和LB归并为一个新的线性表LC，
且LC中的数据元素仍按值递增排列。
LA = (3,5,8,11)
LB = (2,6,8,9,11,25,20)
则
LC = (2,3,5,6,8,8,9,11,11,15,20)
A partir de los requisitos anteriores, podemos ver que los elementos de datos en el LC o los elementos de datos en el LA o los elementos de datos en el LB, siempre que el LC sea una tabla vacía, y luego los elementos en el LA o LB se inserten en el LC uno por uno. Para organizar los elementos en el LC en orden creciente de valor, se pueden configurar dos punteros i y j para que apunten a ciertos elementos en LA y LB. Si el elemento al que apunta actualmente i es a y el elemento al que apunta actualmente b es b, entonces la corriente El elemento c que debe insertarse en la LC es
void MegeList(List La, List Lb, List &Lc){
//已知线性表La和Lb中的数据元素按值递增排列
//Lc也呈递增排雷
InitList(Lc);
i = j =1;
k = 0;
La_len = ListLength(La);
Lb_len = ListLength(Lb);
while( (i<=La_len) && Lb_len = ListLength(Lb) ){ //La和Lb均非空
GetElem(La, i, ai);
GetElem(Lb, j, bi);
if(ai <= bj){
ListInsert(Lc, ++k, ai);
++i;}
else{
ListInsert(Lc,++k,bj);
++j;}
}
while(i <= La_len){
GetElem(La, i++, ai);
ListInsert(Lc, ++k, ai);
}
while(j <= Lb_len){
GetElem(Lb, j++， bj);
ListInsert(Lc, ++k, bi);
}
}
La complejidad temporal de los dos algoritmos anteriores depende del tiempo de ejecución de las operaciones básicas en la definición de la lista de tipos de datos abstractos. Suponiendo que el tiempo de ejecución de las dos operaciones GetElem y ListInsert no tiene nada que ver con la longitud de la tabla, el tiempo de ejecución de LocateElem es proporcional a la longitud de la tabla, luego la replicación de tiempo del algoritmo anterior es O (ListLength (LA) * ListLength (LB)), el segundo La complejidad temporal de este algoritmo es O (ListLength (LA) + ListLength (LB)). Aunque el último algoritmo tiene tres sentencias while, solo cuando i y j apuntan a los elementos de datos que realmente existen en la tabla, los valores de los elementos de datos se pueden obtener y comparar; y cuando los elementos de datos de una de las tablas lineales se han insertado en el lineal Después de la tabla LC, simplemente inserte los elementos restantes en otra tabla lineal en secuencia. Por lo tanto, para cada conjunto de entradas específicas (LA y LB), las dos últimas sentencias while ejecutan solo un cuerpo de bucle.
