博客写到这里，关于C语言的相关内容就告一段落了，从这篇开始，跟我一起进入一个全新的领域吧。

       前面也为大家介绍了通讯录应该怎样去实现，其实顺序表也与通讯录差不多。顺序表是一种线性表，线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储，关于线性表后面也会介绍很多。

目录

1. 顺序表的基本结构

2. 接口实现

3. 增加数据

        3.1 创建、初始化与销毁

        3.2 增加

                3.2.1 尾插

                3.2.2 头插

4. 删除数据

        4.1 尾删

        4.2 头删

5. 随机插入

6. 随机删除

7. 查找

8. 修改

结尾总结

1. 顺序表的基本结构

       顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储元素。

    像通讯录第一次实现时定义了1000个。

2. 动态顺序表：使用动态开辟的数组存储。

    动态的通讯录

2. 接口实现

       静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小。

       以后会经常用到typedef去对类型重命名，首先就要把顺序表的结构写出来，之后就来实现各种功能。

3. 增加数据

        3.1 创建、初始化与销毁

       再增加数据之前，首先要在主函数创建一个顺序表，再对这个顺序表初始化。还是继续用模块化的方式。

 函数的参数是结构体指针，所以实参传入的时候要对结构体变量取地址。

        3.2 增加

对于增加有两种形式，一种是头插，另一种是尾插。

                3.2.1 尾插

在开始插入时，我们要先对空间进行一个检查，检查空间是否足够我们插入数据。

在检查时，先使用临时变量newcapacity和tmp，如果空间不够，我们直接扩容一倍，在开始的时候，size和capacity都是0，那开始直接先给4个空间，最后检查无误后再赋值。

开始size是0，正好对应下标为0的位置，也就是第一个位置，之后size++，这时数据就可以存入了。

为了检测我们插入的数据是否真的存到了顺序表中，再写一个打印函数 。

之后就测试一下

 

                3.2.2 头插

头插不能在顺序表的头部插入，只能把所有的数据往后挪，再把数据插入。

问题就是需要拿几次，和在存放时的越界问题，但这里应该不会出现这种问题，当size和capacity的值相等的时候就会扩容。

 

 

4. 删除数据

        4.1 尾删

尾删就简单很多，但还是得检查一下size，如果没用数据就不要删了，这种assert的方法比较“暴力”，但感觉方便。

这样就尾删了三个数据。 

        4.2 头删

 

 

 

可以看到什么都没有打印，前面一共有5个数据，尾删了三次，头删两次，所以最后什么也没有，可不是出错啊。

5. 随机插入

   

 

总之就是需要插入的时候就得判断需不需要扩容，既然pos是下标，就要判断pos的有效性。pos=0就是头插，pos=size就是尾插。之后也就可以复用。

一个头插一个尾插测试一下。

 

6. 随机删除

 

 

 

和插入之前的数据一样。

当然，随机删除也是可以复用的。

 

 一个头删一个尾删来测试一下。

7. 查找

 

找到了返回下标，找不到返回-1，毕竟下标没用负数。 

8. 修改

修改就可以使用查找函数，只有找到了才能修改，把SLFind的返回值传入再进行修改。

结尾总结

关于顺序表的大致实现就介绍到这里，数据结构介绍的还是数据存放的形式，顺序表是连续存放的，不存在空缺。Test.c文件中只是潦草的写了一些调试的代码，如果想变得更好，也可以像通讯录的时候写一个菜单，再写的时候一定要创建结构体变量再进行操作，最后把所有的代码放在下面。

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; //容量空间的大小
}SL;

//初始化
void SLInit(SL* ps);
//销毁
void SLDestory(SL* ps);
//打印
void SLPrint(SL* ps);

//尾插/头插/尾删/头删
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);

//随机插入
void SLInsert(SL* ps, int pos, SLDataType x);
//随机删除
void SLErase(SL* ps, int pos);

//查找
int SLFind(SL* ps, SLDataType x);

//修改
void SLModify(SL* ps, int pos, SLDataType x);

Seqlist.c文件

#define _CRT_SECURE_NO_WARNINGS 1

#include "Seqlist.h"

void SLPrint(SL* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SLInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

void SLDestory(SL* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
		ps->a = NULL;
		ps->capacity = ps->size = 0;
	}
}

void SLCheckCapacity(SL* ps)
{
	if (ps->capacity == ps->size)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			return;
		}
		ps->capacity = newCapacity;
		ps->a = tmp;
	}
}

void SLPushBack(SL* ps, SLDataType x)
{
	//assert(ps);
	//SLCheckCapacity(ps);

	//ps->a[ps->size] = x;
	//ps->size++;
	SLInsert(ps, ps->size, x);
}

void SLPushFront(SL* ps, SLDataType x)
{
	//assert(ps);
	//SLCheckCapacity(ps);

	//int end = ps->size;
	//while (end > 0)
	//{
	//	ps->a[end] = ps->a[end - 1];
	//	end--;
	//}
	//ps->a[end] = x;
	//ps->size++;
	SLInsert(ps, 0, x);
}

void SLPopBack(SL* ps)
{
	//assert(ps);
	//assert(ps->size > 0);
	//ps->size--;
	SLErase(ps, ps->size - 1);
}

void SLPopFront(SL* ps)
{
	//assert(ps);
	//assert(ps->size > 0);

	//int end = ps->size - 1;
	//for (int i = 0; i < end; i++)
	//{
	//	ps->a[i] = ps->a[i + 1];
	//}
	//ps->size--;
	SLErase(ps, 0);
}

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);

	//pos就是插入的下标
	int end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SLErase(SL* ps, int pos) 
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void SLModify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	ps->a[pos] = x;
}

#include<iostream>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 100
using namespace std;

typedef int Status;

typedef struct
{
    int *elem;
    int length;
} SqList;
//构建空线性表
Status InistList(SqList &L)
{
    L.elem=new int [MAXSIZE];
    if(!L.elem)exit (OVERFLOW);
    L.length=0;
    return OK;
}
//输入
Status  CreatList(SqList &L,int n)
{
    for(int i=0; i<n; i++)
    {
        cin>>L.elem[i];
    }
    L.length=n;
    return OK;
}
//取值
Status   iGetNumber(SqList &L,int i,int &e)
{
    if(i<1||i>L.length)
    {
        return ERROR;
    }
    e=L.elem[i-1];
    return OK;
}
//查找
int  eLocateList(SqList &L,int e)
{
    for(int i=0; i<L.length; i++)
    {
        if(L.elem[i]==e)
        {
            return i+1;
        }
    }
    return 0;
}

//插入
Status   eInsertList(SqList &L,int i,int e)
{
    if(i<1||i>L.length+1)
    {
        return ERROR;
    }
    if(L.length==MAXSIZE)
    {
        return ERROR;
    }
    for(int j=L.length-1; j>=i-1; j--)
    {
        L.elem[j+1]=L.elem[j];
    }
    L.elem[i-1]=e;
    ++L.length;
    return OK;
}
//删除
Status  aDeleteList(SqList &L,int i)
{
    if(L.length==0){
        return ERROR;
    }
    if((i<1)||(i>L.length))
    {
        return ERROR;
    }
    for(int j=i; j<=L.length-1; j++)
    {
        L.elem[j-1]=L.elem[j];
    }
    --L.length;
    return OK;
}
//输出
void DisplayList(SqList &L)
{
    for(int i=0; i<L.length; i++)
    {
        cout<<L.elem[i]<<" ";
    }
}
//欢迎
void WelcomeMenu()
{
    cout<<"1.初始化\n";
    cout<<"2.输入\n";
    cout<<"3.取值\n";
    cout<<"4.查找\n";
    cout<<"5.插入\n";
    cout<<"6.删除\n";
    cout<<"7.输出\n";
    cout<<"0.退出\n";
    cout<<endl;
}
int main()
{
    SqList L;
    WelcomeMenu();
    bool a=true;
    while(a)
    {
        int N;
        cout<<endl<<"请选择：";
        cin>>N;
        switch(N)
        {
        case 1:
        {
            if(InistList(L))
            {
                cout<<"成功初始化线性表";
            }
            else
            {
                cout<<"初始化线性表失败";
            }
            break;
        }
        case 2:
        {
            int n;
            cout<<"请输入元素个数：";
            cin>>n;
            cout<<"请输入"<<n<<"个元素：";
            CreatList(L,n);
            cout<<"输入完成";
            break;
        }
        case 3:
        {
            int i,e;
            cout<<"请输入一个位置用来取值：";
            cin>>i;
            if(iGetNumber(L,i,e))
            {
                cout<<"取值成功，值为：";
                cout<<e;
            }
            break;
        }
        case 4:
        {
            int e;
            cout<<"请输入所要查找的元素：";
            cin>>e;
            cout<<"查找成功，位置为："<<eLocateList(L,e);
            break;
        }
        case 5:
        {
            int i,e;
            cout<<"请输入插入位置：";
            cin>>i;
            cout<<"请输入插入元素：";
            cin>>e;
            eInsertList(L,i,e);
            cout<<"插入成功！";
            break;
        }
        case 6:
        {
            int a;
            cout<<"请输入所要删除的元素：";
            cin>>a;
            aDeleteList(L,a);
            cout<<"删除成功";
            break;
        }
        case 7:
        {
            cout<<"当前线性表为：";
            DisplayList(L);
            break;
        }
        case 0:
        {
            a=false;
            break;
        }
        }
    }
    return 0;
}

系列文章目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

提示：以下是本篇文章正文内容，下面案例可供参考

一、顺序表的相关描述

二、顺序表的增删查改;

1.定义顺序表

代码如下（示例）：

typedef struct
{
	tempstyle* data;
	//数据域;
	int curpity;
	//链表的容量;
	int cursize;
	//链表的长度; 
}Seqlist;

2.顺序表的初始化

代码如下（示例）：

Seqlist* INIT_list(Seqlist* plist)//顺序表初始化； 
{
	//对链表的容量进行赋值;
	plist->curpity = SEQ_INIT_SIZE;
	plist->cursize = 0;
	plist->data = (tempstyle*)malloc(sizeof(tempstyle) * plist->curpity);
	//申请动态存储空间; 
}

3.顺序表查找，删除，插入；

顺序表本质就是一定长度的具有连续地址的数组，所以数据的查询和删除都是在数组的基础上进行，考察的就是数组的应用。

bool insert_list(Seqlist* plist, int pos, tempstyle val)
{
	assert(plist != NULL);
	if (pos<0 || pos>plist->cursize)
	{
		return false;
	}
	if (INIT_man(plist) == true)
	{
		return false;
	}
	else
	{
		for (int i = plist->cursize; i > pos; i--)
		{
			plist->data[i] = plist->data[i - 1];
		}
		plist->data[pos] = val;
		plist->cursize += 1;
		return true;
		/*
		for(int i=plist->cursize-1;i>=pos;i--)
		{
			plist->data[i+1]=plist->data[i];
		}
		plist->data[pos]=val;
		plist->cursize+=1;
		return true;
		*/
	}
}
//查找函数，对输入的值进行查找;
int FIND_list(Seqlist* plist, tempstyle val)
{
	assert(plist != NULL);
	int pos = plist->cursize;
	while (pos > 0 && plist->data[pos - 1] != val)
	{
		pos--;
	}
	if (pos == 0)
		return -1;
	else
		return pos;
}

4.顺序表的扩容；

顺序表的扩容就是将已有的数据转移到另一个大一点的数组中。可以用realloc函数，也可以用memmove函数，也可以用数组直接单个单个进行转移。以上三种方法我都已经实现。可以自己测试。
bool INIT_seqlist(Seqlist* plist)
{
	assert(plist != NULL);
	int total;
	total = plist->curpity * SEQ_SIZE;
	tempstyle* newnode = (tempstyle*)malloc(sizeof(tempstyle) * total);
	if (plist == NULL)
	{
		return false;
	}
	else
	{
		/*	for(int i=0;i<plist->curpity;i++)
			{
				newnode[i]=plist->data[i];
			}
			memmove(newnode,plist->data,sizeof(tempstyle)*plist->curpity);
			free(plist->data);
			plist->data=newnode;
			plist->curpity=total;
			return true;*/

		plist->data = (tempstyle*)realloc(plist->data, sizeof(tempstyle) * total);//增加到tatol的空间； 
		plist->cursize += 1;
		plist->curpity = total;
		return true;
	}
}

三、顺序表的源代码；

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>  //printf
#include<stdlib.h>  //malloc,realloc,free
#include<assert.h>//assert
#include<string.h>//memmove内存移动函数， 
//#define NDEBUG  //可以对assert函数进行禁用; 
#define SEQ_INIT_SIZE 10
#define SEQ_SIZE 2
typedef int tempstyle;
typedef struct
{
	tempstyle* data;
	//数据域;
	int curpity;
	//链表的容量;
	int cursize;
	//链表的长度; 
}Seqlist;
//功能模块化;
//对链表进行动态空间的申请; 
Seqlist* INIT_list(Seqlist* plist)//顺序表初始化； 
{
	//对链表的容量进行赋值;
	plist->curpity = SEQ_INIT_SIZE;
	plist->cursize = 0;
	plist->data = (tempstyle*)malloc(sizeof(tempstyle) * plist->curpity);
	//申请动态存储空间; 
}
//创建链表; 
void creatlist(Seqlist* plist, int n)
{
	assert(plist != NULL);
	plist->cursize = n;
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &plist->data[i]);
	}
}
//创建打印函数;
void printlist(Seqlist* plist)
{
	assert(plist != NULL);
	printf("输出链表：\n");
	for (int i = 0; i < plist->cursize; i++)
	{
		printf("%5d", plist->data[i]);
	}
	putchar('\n');
}
//判断是否已经满了；
bool INIT_man(const Seqlist* plist)
{
	assert(plist != NULL);
	if (plist->cursize < plist->curpity)
	{
		return false;
	}
	else
		return true;
}
//创建插入函数；
bool insert_list(Seqlist* plist, int pos, tempstyle val)
{
	assert(plist != NULL);
	if (pos<0 || pos>plist->cursize)
	{
		return false;
	}
	if (INIT_man(plist) == true)
	{
		return false;
	}
	else
	{
		for (int i = plist->cursize; i > pos; i--)
		{
			plist->data[i] = plist->data[i - 1];
		}
		plist->data[pos] = val;
		plist->cursize += 1;
		return true;
		/*
		for(int i=plist->cursize-1;i>=pos;i--)
		{
			plist->data[i+1]=plist->data[i];
		}
		plist->data[pos]=val;
		plist->cursize+=1;
		return true;
		*/
	}
}
//查找函数，对输入的值进行查找;
int FIND_list(Seqlist* plist, tempstyle val)
{
	assert(plist != NULL);
	int pos = plist->cursize;
	while (pos > 0 && plist->data[pos - 1] != val)
	{
		pos--;
	}
	if (pos == 0)
		return -1;
	else
		return pos;
}

//判断链表是否为空;
bool INIT_kong(const Seqlist* plist)
{
	assert(plist != NULL);
	if (plist->cursize == 0)
		return true;
	else
		return false;
}
//增加扩容;
bool INIT_seqlist(Seqlist* plist)
{
	assert(plist != NULL);
	int total;
	total = plist->curpity * SEQ_SIZE;
	tempstyle* newnode = (tempstyle*)malloc(sizeof(tempstyle) * total);
	if (plist == NULL)
	{
		return false;
	}
	else
	{
		/*	for(int i=0;i<plist->curpity;i++)
			{
				newnode[i]=plist->data[i];
			}
			memmove(newnode,plist->data,sizeof(tempstyle)*plist->curpity);
			free(plist->data);
			plist->data=newnode;
			plist->curpity=total;
			return true;*/

		plist->data = (tempstyle*)realloc(plist->data, sizeof(tempstyle) * total);//增加到tatol的空间； 
		plist->cursize += 1;
		plist->curpity = total;
		return true;
	}
}
//尾部插入;
void insert_back(Seqlist* plist, tempstyle val)
{
	assert(plist != NULL);
	//也可以调用函数，进行插入; 
	insert_list(plist, plist->cursize, val);
	/*
	plist->data[plist->cursize]=val;
	plist->cursize+=1;
	*/
}
//头部插入; 
void insert_front(Seqlist* plist, tempstyle val)
{
	assert(plist != NULL);
	insert_list(plist, 0, val);
	/*
	for(int i=plist->cursize;i>0;i--)
	{
		plist->data[i]=plist->data[i-1];
	}
	plist->data[0]=val;
	plist->cursize+=1;
	*/
}
void makemenu()
{
	printf("\t创建循环链表：\n");
	putchar('\n');
	printf("\t输入你要输入的值：\n");
	putchar('\n');
	printf("\tn代表链表的长度，val1代表头插入的值，val2代表尾插入的值：\n");
	putchar('\n');
	printf("\t你可以输入pos的值来删除函数中指定位置的数据：\n");
	putchar('\n');
}
//求出链表还差多少字节才能满；
int LENGTH_list(Seqlist* plist)
{
	assert(plist != NULL);
	if (plist->cursize == plist->curpity)
	{
		printf("链表已经满了:\n");
	}
	else
		return plist->curpity - plist->cursize;
}
int length_list(Seqlist* plist)
{
	assert(plist != NULL);
	return plist->cursize;
}
//指定位置删除； 
bool delete_list(Seqlist* plist, int pos)
{
	assert(plist != NULL);
	//需要判断输入的位置是否存在；
	if (pos > 0 && pos <= plist->cursize)
	{
		for (int i = pos - 1; i <= plist->cursize - 1; i++)
		{
			plist->data[i] = plist->data[i + 1];//最后一个给了空值； 
		}
		/*
		for(int i=pos;i<plist->cursize;i++)
		{
		plist->data[i-1]=plist->data[i];
		}
		*/
		plist->cursize -= 1;
		return true;
	}
	else
		return false;
}
//判断一个值是否在这个表中；
bool ADJUST_list(Seqlist* plist, tempstyle val)
{
	assert(plist != NULL);
	int cnt = 0;
	for (int i = 0; i < plist->cursize; i++)
	{
		if (plist->data[i] == val)
		{
			cnt++;
		}
	}
	if (cnt >= 1)
		return true;
	else
		return false;
}
//删除你想删除的值;
int delete_val_list(Seqlist* plist, tempstyle val)//状态返回； 
{
	assert(plist != NULL);
	return	delete_list(plist, FIND_list(plist, val));
}
//摧毁函数;
void destroy_list(Seqlist* plist)
{
	plist->curpity = 0;
	plist->cursize = 0;
	free(plist->data);
}
//链表重置为空；
void clear_list(Seqlist* plist)
{
	assert(plist != NULL);
	plist->cursize = 0;
}
//删除链表中所有等于val的值;

/*void delete_all_list(Seqlist*plist,tempstyle val)
 {
	assert(plist!=NULL);
	int pos;
	while(pos=FIND_list(plist,val)!=-1)
	{
		delete_list(plist,pos);
	}
 }
 */

 /*void delete_all_list(Seqlist*plist,tempstyle val)
 {
	 assert(plist!=NULL);
	 int j=-1;
	 int i=0;
	 for(i;i<plist->cursize;++i)
	 {
		 if(plist->data[i]!=val)
		 {
			 j+=1;
			 plist->data[j]=plist->data[i];
		 }
	 }
	 plist->cursize=j+1;
 }*/
void delete_all_list(Seqlist* plist, tempstyle val)
{
	assert(plist != NULL);
	tempstyle* newnode = (tempstyle*)malloc(sizeof(tempstyle) * plist->curpity);
	int i = 0;
	for (int j = 0; j < plist->cursize; j++)
	{
		if (plist->data[j] != val)
		{
			newnode[i] = plist->data[j];
			i++;
		}
	}
	memmove(plist->data, newnode, i);
	plist->cursize = i;

}
//创建主函数; 
int main()
{
	Seqlist* plist;
	int n;
	int m;
	int pos;
	tempstyle val1, val2, val3;
	system("color 05");
	makemenu();
	scanf("%d", &n);
	INIT_list(plist);
	if (n > 10)
	{
		INIT_seqlist(plist);
	}
	creatlist(plist, n);
	printlist(plist);
	printf("\t输入你要插入的值：\n");
	scanf("%d", &val1);
	insert_front(plist, val1);
	printlist(plist);
	printf("\t输入你要插入的值：\n");
	scanf("%d", &val2);
	insert_back(plist, val2);
	printlist(plist);
	printf("链表的长度为：\n");
	printf("%d\n", length_list(plist));
	if (INIT_man(plist) == true)
	{
		printf("\t链表已经满了:\n");
		return 0;
	}
	if (INIT_kong(plist) == true)
	{
		printf("\t链表为空：\n");
	}
	m = LENGTH_list(plist);
	printf("\t链表还差%d才会满：\n", m);
	printf("\t判断链表中是否有你输入的值：\n");
	scanf("%d", &val3);
	if (ADJUST_list(plist, val3) == true)
	{
		printf("\t有你要查找的数：\n");
	}
	printf("\t现在可以进行删除函数：\n");
	printf("输入n你要删除的数据的位置：\n");
	scanf("%d", &pos);
	delete_list(plist, pos);
	printf("删除后的链表的长度为：\n");
	printf("%d", length_list(plist));
	printlist(plist);
	tempstyle val4;
	printf("\t删除链表中所有指定的值：\n");
	scanf("%d", &val4);
	delete_all_list(plist, val4);
	printlist(plist);
	putchar('\n');
	m = LENGTH_list(plist);
	printf("\t链表还差%d才会满：\n", m);
	//destroy_list(plist); 
	return 0;                                                                                                                                                                                                                                                                                                                                                                                                                               return 0;
}

总结

顺序表想比单链表有操作简单，无需更多的内存空间，查询数据简单。但是链表的长度不容易控制，每次插入数据需要移动大量数据，容易造成数据遗失。