Tabla de contenido
Implementación de la función de interfaz
Inicialización de la tabla de secuencia.
Insertar al final de la tabla de secuencia
Eliminar del final de la tabla de secuencia.
Inserción de encabezado de secuencia
Eliminar encabezado de secuencia
Búsqueda de tabla de secuencia
Insertar en la posición especificada en la tabla de secuencia
Eliminar la posición especificada en la tabla de secuencia
Tabla de secuencia de destrucción
Código completo de la tabla de secuencia.
concepto y estructura
La tabla de secuencia es un tipo de tabla lineal. Es una estructura lineal que utiliza una unidad de almacenamiento con dirección física continua para almacenar elementos de datos en secuencia. Generalmente se utiliza almacenamiento en matriz . Complete la adición, eliminación, verificación y modificación de datos en la matriz.
La tabla de secuencia generalmente se divide en:
1. Tabla de secuencia estática: utilice una matriz de longitud fija para almacenar elementos.
#define N 100
//顺序表的静态存储
typedef int SLDatatype;
typedef struct SeqList
{
SLDataType Data[N]; //定长数组
int size; //有效数据个数
}SeqList;Este método de almacenamiento tiene limitaciones al almacenar datos. Cuando la cantidad de datos almacenados es muy pequeña, la longitud de la matriz es demasiado larga, lo que provocará una pérdida de espacio. Cuando la cantidad de datos almacenados es muy grande, es posible que el espacio de la matriz no sea Es suficiente, pero este método de almacenamiento no se puede ampliar. Por lo tanto, al implementar una tabla de secuencia, generalmente usamos una tabla de secuencia dinámica. Esto puede mejorar nuestra utilización del espacio.
2. Tabla de secuencia dinámica: utilice matrices abiertas dinámicamente para almacenar elementos.
//顺序表的动态存储
typedef int SLDatatype;
typedef struct SeqList
{
SLDataType* Data; //定长数组
int size; //有效数据个数
int capacity; //空间容量的大小
}SeqList;Implementación de la función de interfaz
Inicialización de la tabla de secuencia.
//初始化链表
void SLInit(SeqList* ps)
{
assert(ps); //判空，如果传入的空指针，后面对它进行解引用就会报错
ps->data = NULL; //将data初始化为空指针
ps->capacity = ps->size = 0;
}Ahora que se completa la inicialización de la tabla de secuencia, el siguiente paso es agregar, eliminar, verificar y modificar la tabla de secuencia.
Antes de implementar la función de agregar elementos a la lista de secuencia, primero implementamos una verificación para ver si la lista de secuencia está llena. Si está lleno, entonces tendremos que ampliarlo.
Juicio de capacidad
//容量判断
void Check_Capacity(SeqList* ps)
{
assert(ps);
if (ps->capacity == ps->size) //判断顺序表中有效数据个数是否已经达到容量大小
{
int new_capacity = ps->capacity == 0 ? 4 : (ps->capacity) * 2;
//如果容量为0的话，此时就是第一次向顺序表中添加元素，capacity就设为4
//如果容量不为0，此时就是有效数据个数达到容量，就进行扩容，新容量设置为原容量的2倍
SLDataType* tmp = (SLDataType*)realloc(ps->data, new_capacity * sizeof(SLDataType));
if (tmp == NULL) //如果扩容失败，就终止程序。
{
perror("ralloc fail");
exit(-1);
}
ps->data = tmp;
ps->capacity = new_capacity;
}
}La función realloc se usa para la expansión aquí. Cuando insertamos por primera vez, el puntero ps->data sigue siendo un puntero nulo. En este momento, también podemos usar realloc. Cuando se usa la función realloc, si el puntero entrante Es un puntero nulo, su función es la misma que malloc.
Insertar al final de la tabla de secuencia
//顺序表尾插
void SL_PushBack(SL* ps, SLDataType x)
{
assert(ps);
Check_Capacity(ps);
ps->data[ps->size] = x;
ps->size++;
}Eliminar del final de la tabla de secuencia.
//顺序表尾删
void SL_PopBack(SL* ps)
{
assert(ps);
assert(ps->size > 0); //如果顺序表中已经没有元素，那么就不用进行删除，所以
//这里需要检查顺序表中是否还有元素。
ps->size--;
}Ya sea que se trate de una eliminación de la cola o de la cabeza, se debe verificar la tabla de secuencia para ver si hay algún elemento en la tabla.
Inserción de encabezado de secuencia
//顺序表头插
void SL_PushFront(SL* ps, SLDataType x)
{
assert(ps);
Check_Capacity(ps); //检查容量
//将所有数据向后移动一位
for (int i = ps->size - 1; i >= 0; i--)
{
ps->data[i + 1] = ps->data[i];
}
ps->data[0] = x;
ps->size++;
}Al insertar el cabezal, no solo debemos verificar la capacidad, sino también mover los datos hacia atrás un bit antes de insertarlos; de lo contrario, se perderán los datos.
Eliminar encabezado de secuencia
//顺序表头删
void SL_PopFront(SL* ps)
{
assert(ps);
//如果顺序表中只有一个数据，那么直接将数据个数-1
//如果对数据进行挪动，会造成越界
if (ps->size == 1)
{
ps->size--;
return;
}
如果数据个数不为1，就将数据中第2个到最后一个都往前移动一位
for (int i = 1; i < ps->size; i++)
{
ps->data[i - 1] = ps->data[i];
}
ps->size--;
}Búsqueda de tabla de secuencia
//顺序表查找
int SL_Find(SeqList* ps, SLDataType x)
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
if (ps->data[i] == x)
{
//找到就返回下标
return i;
}
}
//找不到就返回-1
return -1;
}Insertar en la posición especificada en la tabla de secuencia
//顺序表指定位置插入
void SL_Insert(SeqList* ps, int pos, SLDataType x)
{
assert(ps);
//判定pos是否合法
assert(pos <= ps->size);
assert(pos >= 0);
Check_Capacity(ps); //检查容量是否够用
//将pos位置后的元素全部都向后移动一位
for (int i = ps->size-1; i >= pos; i--)
{
ps->data[i + 1] = ps->data[i];
}
ps->data[pos] = x;
ps->size++;
}Eliminar la posición especificada en la tabla de secuencia
//顺序表指定位置删除
void SL_Erase(SeqList* ps, int pos)
{
assert(ps);
//检查pos位置是否合法
assert(pos >= 0);
assert(pos < ps->size);
//将pos位置后面的元素全都向前移动一位
for (int i = pos; i < ps->size; i++)
{
ps->data[i] = ps->data[i + 1];
}
ps->size--;
}Con la inserción y eliminación en la posición especificada en la tabla de secuencia, podemos reescribir la inserción y eliminación de cola y la eliminación del tapón de cabeza :
//尾插
void SL_PushBack(SeqList* ps, SLDataType x)
{
SL_Insert(ps, ps->size, x);
}
//尾删
void SL_PopBack(SeqList* ps)
{
SL_Erase(ps, ps->size - 1);
}
//头插
void SL_PushFront(SeqList* ps, SLDataType x)
{
SL_Insert(ps, 0, x);
}
//头删
void SL_PopFront(SeqList* ps)
{
SL_Erase(ps,0);
}Imprimir tabla de secuencia
//打印顺序表
void SLPrint(SeqList* ps)
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
printf("%d ", ps->data[i]);
}
printf("\n");
}Tabla de secuencia de destrucción
//销毁顺序表
void SL_Destroy(SeqList* ps)
{
assert(ps);
free(ps->data);
ps->data = NULL;
ps->capacity = ps->size = 0;
}Código completo de la tabla de secuencia.
ListaSeq.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;
typedef struct SeqList
{
SLDataType* data;
int size;
int capacity;
}SeqList;
//初始化顺序表
void SLInit(SeqList* ps);
//删除顺序表
void SL_Destroy(SeqList* ps);
//打印顺序表
void SLPrint(SeqList* ps);
//检查容量
void Check_Capacity(SeqList* ps);
//尾插尾删
void SL_PushBack(SeqList* ps,SLDataType x);
void SL_PopBack(SeqList* ps);
//头插头删
void SL_PushFront(SeqList* ps, SLDataType x);
void SL_PopFront(SeqList* ps);
//顺序表查找
int SL_Find(SeqList* ps, SLDataType x);
//顺序表指定位置插入
void SL_Insert(SeqList* ps, int pos, SLDataType x);
//顺序表指定位置删除
void SL_Erase(SeqList* ps, int pos);ListaSeq.c
#include "SeqList.h"
void SLInit(SeqList* ps)
{
assert(ps);
ps->data = NULL;
ps->capacity = ps->size = 0;
}
void SL_Destroy(SeqList* ps)
{
assert(ps);
free(ps->data);
ps->data = NULL;
ps->capacity = ps->size = 0;
}
void SLPrint(SeqList* ps)
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
printf("%d ", ps->data[i]);
}
printf("\n");
}
void Check_Capacity(SeqList* ps)
{
assert(ps);
if (ps->capacity == ps->size)
{
int new_capacity = ps->capacity == 0 ? 4 : (ps->capacity) * 2;
SLDataType* tmp = (SLDataType*)realloc(ps->data, new_capacity * sizeof(SLDataType));
if (tmp == NULL)
{
perror("ralloc fail");
exit(-1);
}
ps->data = tmp;
ps->capacity = new_capacity;
}
}
void SL_PushBack(SeqList* ps, SLDataType x)
{
//assert(ps);
//Check_Capacity(ps);
//ps->a[ps->size] = x;
//ps->size++;
SL_Insert(ps, ps->size, x);
}
void SL_PopBack(SeqList* ps)
{
//assert(ps);
//assert(ps->size > 0);
//ps->size--;
SL_Erase(ps, ps->size - 1);
}
void SL_PushFront(SeqList* ps, SLDataType x)
{
//assert(ps);
//Check_Capacity(ps);
//for (int i = ps->size - 1; i >= 0; i--)
//{
// ps->a[i + 1] = ps->a[i];
//}
//ps->a[0] = x;
//ps->size++;
SL_Insert(ps, 0, x);
}
void SL_PopFront(SeqList* ps)
{
//assert(ps);
//if (ps->size == 1)
//{
// ps->size--;
// return;
//}
//for (int i = 1; i < ps->size; i++)
//{
// ps->data[i - 1] = ps->data[i];
//}
//ps->size--;
SL_Erase(ps,0);
}
int SL_Find(SeqList* ps, SLDataType x)
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
if (ps->data[i] == x)
{
return i;
}
}
return -1;
}
void SL_Insert(SeqList* ps, int pos, SLDataType x)
{
assert(ps);
assert(pos <= ps->size);
assert(pos >= 0);
Check_Capacity(ps);
for (int i = ps->size-1; i >= pos; i--)
{
ps->data[i + 1] = ps->data[i];
}
ps->data[pos] = x;
ps->size++;
}
void SL_Erase(SeqList* ps, int pos)
{
assert(ps);
assert(pos >= 0);
assert(pos < ps->size);
for (int i = pos; i < ps->size; i++)
{
ps->data[i] = ps->data[i + 1];
}
ps->size--;
}Lo anterior es todo el contenido relacionado con la tabla de secuencia, espero que pueda ayudar a todos.