<Estrutura de dados> Tabela de sequência

contente

1. Introdução à tabela de sequências

2. Preparações

       1. Crie uma tabela de sequência

       2. Tabela de sequência de inicialização

       3. Verifique se a expansão é necessária

       4. Tabela de sequência de destruição

       5. Tabela de pedidos de impressão

Três, quatro funções

       1. Adicione dados

                    plugue de cabeça

                    plugue de cauda

                    Especificar inserção de subscrito

       2. Excluir dados

                    exclusão de cabeçalho

                    exclusão de cauda

                    Especificar exclusão de subscrito

       3. Encontre dados

       4. Modificar dados

Quarto, o código total

       1 、 SeqList.h

       2 、 SeqList.c

       3、Teste.c

---

1. Introdução à tabela de sequências

• conceito e estrutura

A tabela de sequência é uma estrutura linear na qual os elementos de dados são armazenados sequencialmente em um segmento de unidades de armazenamento com endereços físicos consecutivos, geralmente usando armazenamento em array. Adição, exclusão, pesquisa e modificação completas de dados na matriz.

A tabela de sequência geralmente pode ser dividida em:

1. Tabela de ordem estática: use um array de tamanho fixo para armazenar elementos.

2. Tabela de sequência dinâmica: use armazenamento em array desenvolvido dinamicamente.

• Exigir:

A tabela de sequência requer que os dados a serem armazenados comecem em 0 e sejam armazenados continuamente em sequência, não podendo haver espaço no meio.

• implementação de interface

Uma tabela de sequência estática só é útil se você souber a quantidade de dados que precisa armazenar. A matriz de comprimento fixo da tabela de sequência estática faz com que N seja grande e o espaço seja muito desperdiçado, e menos não é suficiente . Portanto, na realidade, a tabela de sequência dinâmica é basicamente usada , e o tamanho do espaço é alocado dinamicamente de acordo com as necessidades, então implementaremos a tabela de sequência dinâmica abaixo.

• Observação:

Este artigo criará três pastas, SeqList.h, SeqList.c e Test.c, que são usadas para declarar, definir e implementar, respectivamente.

O texto começa:

2. Preparações

1. Crie uma tabela de sequência

• Arquivo SeqList.h:

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

2. Tabela de sequência de inicialização

• Arquivo SeqList.h:

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

• Arquivo SeqList.c:

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

3. Verifique se a expansão é necessária

• Arquivo SeqList.h:

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

• Arquivo 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;
		}
	}
}

• Perceber:

Quando o ponteiro de realloc está vazio, realloc é equivalente a malloc

4. Tabela de sequência de destruição

• Arquivo SeqList.h:

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

• Arquivo SeqList.c:

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

5. Tabela de pedidos de impressão

• Pensei:

Basta imprimir o loop for sequencialmente

• Arquivo SeqList.h:

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

• Arquivo SeqList.c:

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

Três, quatro funções

1. Adicione dados

plugue de cabeça

• Pensei:

É um pouco mais complicado do que o plugue de cauda. O plugue de cabeça é mover o último número para trás e, em seguida, mover o número anterior para trás, e assim por diante, até que a primeira posição seja desocupada, mas a premissa é garantir que haja espaço suficiente. Não é suficiente para expandir

• Arquivo SeqList.h:

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

• Arquivo 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++;
}

• Arquivo teste.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;
}

• O efeito é o seguinte:

plugue de cauda

• Pensei:

Na verdade, o tamanho do subscrito do array a é a próxima posição do último dado.A inserção da cauda só precisa inserir um dado em ps->size, mas a premissa é verificar primeiro se a capacidade está cheia.

• Arquivo SeqList.h:

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

• Arquivo SeqList.c:

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

• Arquivo teste.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;
}

• O efeito é o seguinte:

Especificar inserção de subscrito

• Pensei:

Na verdade, a ideia de inserir em uma posição especificada é muito semelhante à inserção de cauda acima, mas é necessário garantir que a posição de inserção especificada esteja dentro do intervalo de tamanho de dados válido, caso contrário, cruzará o limite e não será uma tabela de seqüência.

• Arquivo SeqList.h:

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

• Arquivo 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++;
}

• Arquivo teste.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;
}

• O efeito é o seguinte:

• Perceber:

Quando implementamos a inserção de subscrito especificada, descobrimos que quando pos=size, a implementação é a inserção de cauda

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

Da mesma forma, quando pos=0, o cabeçalho é implementado da seguinte forma:

//头插
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. Excluir dados

exclusão de cabeçalho

• Pensei:

A exclusão de cabeçalho não precisa considerar a expansão. A exclusão de cabeçalho precisa mover o segundo número para frente e, em seguida, mover o próximo número para frente e assim por diante. Observe que, ao excluir dados, certifique-se de que o tamanho de dados válido seja constante >=0 para garantir que os dados subsequentes podem ser adicionados normalmente.

• Arquivo SeqList.h:

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

• Arquivo 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--;
	}
}

• Arquivo teste.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;
}

• O efeito é o seguinte:

exclusão de cauda

• Pensei:

Aqui o tamanho é o número de dados válidos na matriz criada. Você só precisa definir o número de dados válidos para -1. Ao imprimir, os últimos dados originais serão naturalmente excluídos, mas deve-se notar que, se o número de exclusões for muito grande, será eficaz. O tamanho dos dados pode se tornar negativo. Para evitar esse fenômeno, só é necessário garantir que ele seja decrementado quando tamanho>0. Da mesma forma, para evitar o ponteiro nulo de entrada, apenas a afirmação assertiva é necessária.

• Arquivo SeqList.h:

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

• Arquivo SeqList.c:

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

• Arquivo teste.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;
}

• O efeito é o seguinte:

Especificar exclusão de subscrito

• Pensei:

Na verdade, a ideia não é complicada. Primeiramente, é necessário afirmar que não é um ponteiro nulo e, em segundo lugar, garantir que o subscrito pos<size, não possa ser =size, pois o valor do subscrito size está vazio, dados não válidos, if =size, exclua um número sem sentido , o próximo passo é semelhante à exclusão de cabeça, mova a última posição de pos para a anterior e substitua-a pela próxima e assim por diante.

• Arquivo SeqList.h:

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

• Arquivo 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--;
}

• Arquivo teste.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;
}

• O efeito é o seguinte:

•  Perceber:

Quando pos=size-1, o último número é excluído e a exclusão da cauda é implementada, então a exclusão da cauda pode ser escrita da seguinte forma:

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

Quando pos=0, o primeiro número é excluído e o cabeçalho é excluído, portanto, a exclusão do cabeçalho também pode ser resolvida dessa maneira.

//头删
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. Encontre dados

• Pensei:

Iterar sobre a matriz.

• Arquivo SeqList.h:

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

• Arquivo 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;
}

• Arquivo teste.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;
}

• O efeito é o seguinte:

4. Modificar dados

• Pensei:

Você só precisa modificar o número do subscrito especificado, desde que o número modificado seja um dado válido

• Arquivo SeqList.h:

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

• Arquivo SeqList.c:

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

• Arquivo teste.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;
}

• O efeito é o seguinte:

Quarto, o 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、Teste.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;
}