<Estructura de datos> Tabla de secuencias

contenido

1. Introducción a la tabla de secuencia

2. Preparativos

       1. Crea una tabla de secuencia

       2. Tabla de secuencia de inicialización

       3. Compruebe si se requiere expansión

       4. Tabla de secuencia de destrucción

       5. Tabla de órdenes de impresión

Tres, cuatro funciones

       1. Agregar datos

                    enchufe de cabeza

                    tapón de cola

                    Especificar inserción de subíndice

       2. Eliminar datos

                    eliminación de encabezado

                    eliminación de la cola

                    Especificar eliminación de subíndice

       3. Encuentra datos

       4. Modificar datos

Cuarto, el código total

       1 、 SeqList.h

       2 、 SeqList.c

       3, Prueba.c

---

1. Introducción a la tabla de secuencia

• concepto y estructura

La tabla de secuencia es una estructura lineal en la que los elementos de datos se almacenan secuencialmente en un segmento de unidades de almacenamiento con direcciones físicas consecutivas, generalmente utilizando almacenamiento en matriz. Complete la adición, eliminación, búsqueda y modificación de datos en la matriz.

La tabla de secuencia generalmente se puede dividir en:

1. Tabla de orden estática: use una matriz de longitud fija para almacenar elementos.

2. Tabla de secuencia dinámica: use almacenamiento de matriz desarrollado dinámicamente.

• Exigir:

La tabla de secuencia requiere que los datos que se almacenarán comiencen desde 0 y se almacenen continuamente en secuencia, y no puede haber espacio en el medio.

• implementación de la interfaz

Una tabla de secuencia estática solo es útil si sabe cuántos datos necesita almacenar. La matriz de longitud fija de la tabla de secuencia estática hace que N sea grande, y el espacio es demasiado derrochador, y menos no es suficiente . Por lo tanto, en realidad, la tabla de secuencia dinámica se usa básicamente y el tamaño del espacio se asigna dinámicamente de acuerdo con las necesidades, por lo que implementaremos la tabla de secuencia dinámica a continuación.

• Nota:

Este artículo creará tres carpetas, SeqList.h, SeqList.c y Test.c, que se utilizan para declarar, definir e implementar respectivamente.

El texto comienza:

2. Preparativos

1. Crea una tabla de secuencia

• Archivo SeqList.h:

//创建顺序表
typedef int SLDataType; //确保以后想存其它类型的时候方便改动，本文以存放整型数据为例
typedef struct SeqList
{
	SLDataType* a; //动态开辟数组
	int size;    //存储顺序表中有效数据个数
	int capacity;//存储空间个数-->记录最大容量 
}SeqList; 

2. Tabla de secuencia de inicialización

• Archivo SeqList.h:

//初始化顺序表
void SeqListInit(SeqList* psl);

• Archivo SeqList.c:

//初始化通讯录
void SeqListInit(SeqList* psl)
{
	assert(psl);
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

3. Compruebe si se requiere expansión

• Archivo SeqList.h:

//检测是否需要扩容
void SeqListCheckCapacity(SeqList* psl);

• Archivo SeqList.c:

//检测是否需要扩容
void SeqListCheckCapacity(SeqList* psl)
{
	assert(psl);
	//如果满了，就要扩容
	if (psl->size == psl->capacity)
	{
		size_t newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2; //防止原始capacity的容量本身为0，导致后续扩容仍为0
		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			psl->a = tmp;
			psl->capacity = (int)newCapacity;
		}
	}
}

• Aviso:

Cuando el puntero de realloc está vacío, realloc es equivalente a malloc

4. Tabla de secuencia de destrucción

• Archivo SeqList.h:

//销毁顺序表
void SeqListDestroy(SeqList* psl);

• Archivo SeqList.c:

//销毁顺序表
void SeqListDestroy(SeqList* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = psl->size = 0;
}

5. Tabla de órdenes de impresión

• Pensamiento:

Simplemente imprima el bucle for secuencialmente

• Archivo SeqList.h:

//打印顺序表
void SeqListPrint(SeqList* psl);

• Archivo SeqList.c:

//打印顺序表
void SeqListPrint(SeqList* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ",psl->a[i]);
	}
	printf("\n");
}

Tres, cuatro funciones

1. Agregar datos

enchufe de cabeza

• Pensamiento:

Es un poco más complicado que el tapón de cola. El tapón de cabeza es mover el último número hacia atrás, y luego mover hacia atrás el número anterior, y así sucesivamente, hasta que la primera posición quede vacante, pero la premisa es asegurarse de que haya suficiente espacio No lo suficiente para expandir

• Archivo SeqList.h:

//头插
void SeqListPushFront(SeqList* psl, SLDataType x);

• Archivo SeqList.c:

//头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
	SeqListCheckCapacity(psl); //检测容量
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[0] = x;
	psl->size++;
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s); //一定要加上&，因为形参的改变不会影响实参，要传地址
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	//头插2个数字
	SeqListPushFront(&s, 0);
	SeqListPushFront(&s, -1);
	SeqListPrint(&s); //头插2次后打印
	return 0;
}

• El efecto es el siguiente:

tapón de cola

• Pensamiento:

De hecho, el tamaño del subíndice de la matriz a es la siguiente posición de los últimos datos. La inserción de la cola solo necesita insertar un dato en ps->size, pero la premisa es verificar si la capacidad está llena primero.

• Archivo SeqList.h:

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x);

• Archivo SeqList.c:

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);
	SeqListCheckCapacity(psl); //检测容量
	psl->a[psl->size] = x;
	psl->size++;
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s); //一定要加上&，因为形参的改变不会影响实参，要传地址
	//尾插5个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPrint(&s); //打印
	return 0;
}

• El efecto es el siguiente:

Especificar inserción de subíndice

• Pensamiento:

De hecho, la idea de insertar en una posición específica es muy similar a la inserción de cola anterior, pero es necesario asegurarse de que la posición de inserción especificada esté dentro del rango de tamaño de datos válido, de lo contrario cruzará el límite y no será una tabla de secuencia.

• Archivo SeqList.h:

//在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);

• Archivo SeqList.c:

//在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	//暴力检查
	/*assert(pos <= psl->size && psl);*/
	//温和检查
	if (pos > psl->size)
	{
		printf("pos 越界：%d\n", (int)pos);
		return;
	}
	SeqListCheckCapacity(psl); //检测容量
	int end = psl->size - 1;
	while (end >= (int)pos)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[pos] = x;
	psl->size++;
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s);
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	//指定下标插入2个数字
	SeqListInsert(&s, 10, 100);
	SeqListInsert(&s, 1, 20);
	SeqListPrint(&s); //插入成功后打印
	SeqListDestroy(&s);
	return 0;
}

• El efecto es el siguiente:

• Aviso:

Cuando implementamos la inserción de subíndice especificada, encontramos que cuando pos = tamaño, la implementación es inserción de cola

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);
//法一：
	/*SeqListCheckCapacity(psl); //检测容量
	psl->a[psl->size] = x;
	psl->size++;*/
//法二：
	SeqListInsert(psl, psl->size, x);
}

De manera similar, cuando pos=0, el encabezado se implementa de la siguiente manera:

//头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
//法一：
	/*SeqListCheckCapacity(psl); //检测容量
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[0] = x;
	psl->size++;*/
//法二：
	SeqListInsert(psl, 0, x);
}

2. Eliminar datos

eliminación de encabezado

• Pensamiento:

La eliminación principal no necesita considerar la expansión. La eliminación principal debe mover el segundo número hacia adelante y luego mover el siguiente número hacia adelante, y así sucesivamente. Tenga en cuenta que al eliminar datos, asegúrese de que el tamaño de datos válido sea constante> = 0 para garantizar que los datos posteriores se pueden agregar normalmente.

• Archivo SeqList.h:

//头删
void SeqListPopFront(SeqList* psl);

• Archivo SeqList.c:

//头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
	if (psl->size > 0)
	{
		int begin = 1;
		while (begin < psl->size)
		{
			psl->a[begin - 1] = psl->a[begin];
			begin++;
		}
		psl->size--;
	}
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s);
	//尾插10个数字
	for (int i = 1; i <= 10; i++)
	{
		SeqListPushBack(&s, i);
	}
	SeqListPrint(&s); //尾插10个数字后打印
	//头删12次数据
	for (int i = 1; i <= 12; i++)
	{
		SeqListPopFront(&s);
	}
	SeqListPrint(&s); //头删12次后打印
	//头插5个数字
	for (int i = -5; i <= -1; i++)
	{
		SeqListPushFront(&s, i);
	}
	SeqListPrint(&s); //头插5次后打印
	return 0;
}

• El efecto es el siguiente:

eliminación de la cola

• Pensamiento:

Aquí, el tamaño es la cantidad de datos válidos en la matriz creada. Solo necesita establecer la cantidad de datos válidos en -1. Al imprimir, los últimos datos originales se eliminarán naturalmente, pero debe tenerse en cuenta que si la cantidad de eliminaciones es demasiado, será efectivo. El tamaño de los datos puede volverse negativo. Para evitar este fenómeno, solo es necesario asegurarse de que se disminuya cuando el tamaño> 0. De manera similar, para evitar el puntero nulo entrante, solo la aserción es necesaria.

• Archivo SeqList.h:

//尾删
void SeqListPopBack(SeqList* psl);

• Archivo SeqList.c:

//尾删
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	if (psl->size > 0)
	{
		psl->size--;
	}
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s); //一定要加上&，因为形参的改变不会影响实参，要传地址
	//尾插5个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPrint(&s); //尾插5次后打印

	//尾删6个数字
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s); //尾删6次后打印

	//再尾插2个数字
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPrint(&s); //再尾插2次打印
	return 0;
}

• El efecto es el siguiente:

Especificar eliminación de subíndice

• Pensamiento:

De hecho, la idea no es complicada, en primer lugar, es necesario afirmar que no es un puntero nulo, y en segundo lugar, asegurarse de que el subíndice pos<tamaño, no puede ser =tamaño, porque el valor del subíndice tamaño está vacío, datos no válidos, si = tamaño, elimine un número sin sentido, el siguiente paso es similar a la eliminación del encabezado, mueva la última posición de pos a la anterior y luego reemplácela con la siguiente, y así sucesivamente.

• Archivo SeqList.h:

//删除pos位置的数据
void SeqListErase(SeqList* psl, size_t pos);

• Archivo SeqList.c:

//删除pos位置的数据
void SeqListErase(SeqList* psl, size_t pos)
{
	assert(psl);
	assert(pos < psl->size);
	size_t begin = pos + 1;
	while (begin < psl->size)
	{
		psl->a[begin - 1] = psl->a[begin];
		++begin;
	}
	psl->size--;
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s);
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	//删除2个指定下标的数字
	SeqListErase(&s, 3);//下标3
	SeqListErase(&s, 1);//下标1
	SeqListPrint(&s); //删除后打印
	return 0;
}

• El efecto es el siguiente:

•  Aviso:

Cuando pos=size-1, se elimina el último número y se implementa la eliminación de la cola, por lo que la eliminación de la cola se puede escribir de la siguiente manera:

//尾删
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	/*if (psl->size > 0)
	{
		psl->size--;
	}*/
	SeqListErase(psl, psl->size - 1);
}

Cuando pos=0, se elimina el primer número y se elimina el encabezado, por lo que la eliminación del encabezado también se puede resolver de esta manera.

//头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
//法一：
	/*if (psl->size > 0)
	{
		int begin = 1;
		while (begin < psl->size)
		{
			psl->a[begin - 1] = psl->a[begin];
			begin++;
		}
		psl->size--;
	}*/
//法二：指定下标删除法
	SeqListErase(psl, 0);
}

3. Encuentra datos

• Pensamiento:

Iterar sobre la matriz.

• Archivo SeqList.h:

//查找指定数字
int SeqListFind(SeqList* psl, SLDataType x);

• Archivo SeqList.c:

//查找指定数字
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s);
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	int pos = SeqListFind(&s, 3);
	if (pos != -1)
		printf("找到了，下标是：%d", pos);
	else
		printf("找不到\n");
	return 0;
}

• El efecto es el siguiente:

4. Modificar datos

• Pensamiento:

Solo necesita modificar el número del subíndice especificado, siempre que el número modificado sea un dato válido

• Archivo SeqList.h:

//修改指定下标数字
void SeqListModify(SeqList* psl, size_t pos, SLDataType x);

• Archivo SeqList.c:

//修改指定下标数字
void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos < psl->size);
	psl->a[pos] = x;
}

• Archivo de prueba.c:

int main()
{
	SeqList s;
	SeqListInit(&s);
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	SeqListModify(&s, 1, 5);
	SeqListPrint(&s); //修改后打印
	int pos = SeqListFind(&s, 3);
	if (pos != -1)
	{
		SeqListModify(&s, pos, 5000);
		SeqListPrint(&s); //查找再修改后打印
	}
	return 0;
}

• El efecto es el siguiente:

Cuarto, el código total

1 、 SeqList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//创建顺序表
typedef int SLDataType; //确保以后想存其它类型的时候方便改动，本文以存放整型数据为例
typedef struct SeqList
{
	SLDataType* a; //动态开辟数组
	int size;    //存储顺序表中有效数据个数
	int capacity;//存储空间个数-->记录最大容量 
}SeqList;

//初始化顺序表
void SeqListInit(SeqList* psl);
//检测是否需要扩容
void SeqListCheckCapacity(SeqList* psl);
//打印顺序表
void SeqListPrint(SeqList* psl);
//销毁顺序表
void SeqListDestroy(SeqList* psl);

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x);
//尾删
void SeqListPopBack(SeqList* psl);
//头插
void SeqListPushFront(SeqList* psl, SLDataType x);
//头删
void SeqListPopFront(SeqList* psl);
//在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
//删除pos位置的数据
void SeqListErase(SeqList* psl, size_t pos);

//查找指定数字
int SeqListFind(SeqList* psl, SLDataType x);
//修改指定下标数字
void SeqListModify(SeqList* psl, size_t pos, SLDataType x);

2 、 SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
//初始化通讯录
void SeqListInit(SeqList* psl)
{
	assert(psl);
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

//检测是否需要扩容
void SeqListCheckCapacity(SeqList* psl)
{
	assert(psl);
	//如果满了，就要扩容
	if (psl->size == psl->capacity)
	{
		size_t newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2; //防止原始capacity的容量本身为0，导致后续扩容仍为0
		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			psl->a = tmp;
			psl->capacity = (int)newCapacity;
		}
	}
}

//打印顺序表
void SeqListPrint(SeqList* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}
//销毁顺序表
void SeqListDestroy(SeqList* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = psl->size = 0;
}

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);
	//法一：
		/*SeqListCheckCapacity(psl); //检测容量
		psl->a[psl->size] = x;
		psl->size++;*/
	//法二：指定下标插入
	SeqListInsert(psl, psl->size, x);
}
//尾删
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	/*if (psl->size > 0)
	{
		psl->size--;
	}*/
	SeqListErase(psl, psl->size - 1);
}

//头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
//法一：
	/*SeqListCheckCapacity(psl); //检测容量
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[0] = x;
	psl->size++;*/
//法二：指定下标插入法
	SeqListInsert(psl, 0, x);
}
//头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
//法一：
	/*if (psl->size > 0)
	{
		int begin = 1;
		while (begin < psl->size)
		{
			psl->a[begin - 1] = psl->a[begin];
			begin++;
		}
		psl->size--;
	}*/
//法二：指定下标删除法
	SeqListErase(psl, 0);
}

//在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	//暴力检查
	/*assert(pos <= psl->size && psl);*/
	//温和检查
	if (pos > psl->size)
	{
		printf("pos 越界：%d\n", (int)pos);
		return;
	}
	SeqListCheckCapacity(psl); //检测容量
	int end = psl->size - 1;
	while (end >= (int)pos)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[pos] = x;
	psl->size++;
}
//删除pos位置的数据
void SeqListErase(SeqList* psl, size_t pos)
{
	assert(psl);
	assert(pos < psl->size);
	size_t begin = pos + 1;
	while (begin < psl->size)
	{
		psl->a[begin - 1] = psl->a[begin];
		++begin;
	}
	psl->size--;
}

//查找指定数字
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//修改指定下标数字
void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos < psl->size);
	psl->a[pos] = x;
}

3, Prueba.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void test1()
{
	SeqList s;
	SeqListInit(&s); //一定要加上&，因为形参的改变不会影响实参，要传地址
	//尾插5个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPrint(&s); //尾插5次后打印

	//尾删6个数字
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s); //尾删6次后打印

	//再尾插2个数字
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPrint(&s); //再尾插2次打印
}
void TestSeqList2()
{
	SeqList s;
	SeqListInit(&s); //一定要加上&，因为形参的改变不会影响实参，要传地址
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	//头插2个数字
	SeqListPushFront(&s, 0);
	SeqListPushFront(&s, -1);
	SeqListPrint(&s); //头插2次后打印
}
void TestSeqList3()
{
	SeqList s;
	SeqListInit(&s);
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	//头删
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s); //头删6次后打印
	//头插2个数字
	SeqListPushFront(&s, 0);
	SeqListPushFront(&s, -1);
	SeqListPrint(&s); //头插2次后打印
}
void TestSeqList4()
{
	SeqList s;
	SeqListInit(&s);
	//尾插10个数字
	for (int i = 1; i <= 10; i++)
	{
		SeqListPushBack(&s, i);
	}
	SeqListPrint(&s); //尾插10个数字后打印
	//头删12次数据
	for (int i = 1; i <= 12; i++)
	{
		SeqListPopFront(&s);
	}
	SeqListPrint(&s); //头删12次后打印
	//头插5个数字
	for (int i = -5; i <= -1; i++)
	{
		SeqListPushFront(&s, i);
	}
	SeqListPrint(&s); //头插5次后打印
}
void TestSeqList5()
{
	SeqList s;
	SeqListInit(&s);
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	//指定下标插入2个数字
	SeqListInsert(&s, 10, 100);
	SeqListInsert(&s, 1, 20);
	SeqListInsert(&s, 5, 50);
	SeqListPrint(&s); //指定插入2次后打印
	SeqListDestroy(&s);
}
int main()
{
	SeqList s;
	SeqListInit(&s);
	//先尾插4个数字
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s); //尾插4次后打印
	SeqListModify(&s, 1, 5);
	SeqListPrint(&s); //修改后打印
	int pos = SeqListFind(&s, 3);
	if (pos != -1)
	{
		SeqListModify(&s, pos, 5000);
		SeqListPrint(&s); //查找再修改后打印
	}
	return 0;
}