《详解顺序表》

1. 顺序表的定义及其特点；

定义：顺序表是在计算机内存中以数组的形式保存的线性表。

线性表是一种逻辑结构，表示元素之间一对一的相邻关系，相邻元素之间存在着序偶关系，比如：n（n大于与等于0）个数据元素（结点），a1，a2...an组成的有序序列。

而顺序表是存储结构，顺序表是将表中的线性表的结点按逻辑次序依次存放在计算机内存中一组地址连续的存储单元中。

特点：

有限性：元素个数有限

逻辑上的顺序性：排序有先后顺序 每个元素都相同大小的存储空间，因为表中元素数据类型都相同

连续存储: 顺序表使用数组来存储元素，数组中的元素在内存中是连续存储的。

随机访问: 由于元素在内存中连续存储，可以通过下标直接访问任意位置的元素，具有快速的随机访问能力

插入和删除的复杂度较高: 在顺序表中插入和删除元素时，需要移动其他元素以保持顺序，因此插入和删除的时间复杂度较高

需要预先固定长度:顺序表的长度是固定的，分配足够的内存空间来存储元素。

顺序表的运算特点主要包括随机访问、插入和删除操作不方便、存储密度高以及拓展容量不方便等。在实际应用中，需要根据具体的需求和场景来选择合适的数据结构。

2. 顺序表的运算（概述）；

初始化：创建空的顺序表

插入：指定位置插入新的数据

删除：指定位置删除数据

判断是否为空：检查顺序表是否为空，即是否有没有元素

判断是否为满：检查顺序表是否达到最大容量

输出顺序表；

3. 顺序表的实现（详细的介绍及C程序代码、执行结果）；

初始化

/*顺序表初始化*/
	int init(SeqList * L)
	{
		L->length = 0;
		return 0;
	}

  结果：

插入

/*插入元素*/
int insert(SeqList *L, int i, DataType x)
{
	int j;

	/*判断是否满*/
	if(full(L))
	{
		printf("Error[10001],顺序表已满！\n");
		return 10001;
	}
	/*判断位置i合法性*/
	if(i<1 || i>length(L)+1)
	{
		printf("Error[10002],位置i不合法！\n");
		return 10003;
	}

	/*移动元素,向后移动*/
	for(j=L->length;j>=i;j--)
	{
		L->data[j] = L->data[j-1];
	}
	L->data[j] = x;
	L->length++;
	return 0; /*ok!*/
}

  结果：

删除

/*删除元素*/
int delete(SeqList *L, int i, DataType *x) {
    if (i < 1 || i > L->length) {
        // 越界检查，判断是否给定的位置 i 合法
        return 0; // 删除失败，返回0
    }
    *x = L->data[i - 1];
    for (int j = i; j < L->length; j++) {
        L->data[j - 1] = L->data[j];
    }
    L->length--;
    return 1; // 删除成功，返回1
}

 结果： 

判断是否为空

/*是否空*/
int empty(SeqList *L)
{
	return (L->length == 0)?1:0;
}

 结果：

判断是否为满

/*顺序表是否满*/
int full(SeqList *L)
{
	return (L->length == MAXSIZE)?1:0;
}

 结果：

输出顺序表

/*输出顺序表*/
void print(SeqList *L)
{
	int i;

	if(empty(L))
	{
		printf("顺序表为空！");
		return ;
	}
	printf("顺序表为:");
	for(i=0;i<L->length;i++)
	{
		printf(" %d ", L->data[i]);
	}
	printf("\n");
}

结果：

4. 完整的Demo；

main.c

#include <stdio.h>
#include <strings.h>
#include "SeqList.c"
#include "welcome.h"

int main(int argc, char *argv[]) {
    SeqList L;
    int cmd;
    int i;
    int m, n;

    DataType x;

    for (i = 0; i < strlen(welcome); i++) {
        printf("%c", welcome[i]);
        for (m = 0; m < 10000; m++)
            for (n = 0; n < 1000; n++) { ;
            }
    }
    printf("\n\n\n");
    printf("-----------顺序表演示程序----------\n");
    do {
        printf("1. 初始化顺序表\n");
        printf("2. 插入元素\n");
        printf("3. 删除元素\n");
        printf("4. 判断顺序表是否为空\n");
        printf("5. 判断顺序表是否满\n");
        printf("6. 输出顺序表\n");
        printf("10. 帮助\n");
        printf("0. 退出\n");
        printf("请输入您要进行的操作（1~6,0退出）：");
        scanf("%d", &cmd);
        switch (cmd) {
            case 1:
                if (!init(&L)) {
                    printf("顺序表已初始化！\n");
                }
                break;
            case 2:
                printf("请输入位置i，插入元素x（i，x）：");
                scanf("%d,%d", &i, &x);
                if (!insert(&L, i, x)) {
                    printf("元素（%d）已插入位置[%d]\n", x, i);
                }
                break;
            case 3:
                printf("请输入要删除的位置i：");
                scanf("%d", &i);
                if (delete(&L, i, &x)) {
                    printf("删除成功，被删除的元素为：%d\n", x);
                } else {
                    printf("删除失败，位置[%d]不合法\n", i);
                }
                break;
            case 4:
                if (empty(&L)) {
                    printf("顺序表为空！\n");
                } else {
                    printf("顺序表不为空！\n");
                }
                break;
            case 5:
                if (full(&L)) {
                    printf("顺序表已满！\n");
                } else {
                    printf("顺序表未满！\n");
                }
            case 6:
                print(&L);
                break;
            case 10:
                printf(" 本程序为顺序表的演示程序，有XXX设计开发，程序完成了。。。。功能！。。。\n");
                break;

        }
    } while (cmd != 0);

    return 0;
}

SeqList.c

/*
	SeqList.c 顺序表实现
*/
#include "SeqList.h"


/*顺序表初始化*/
int init(SeqList *L)
{
	L->length = 0;
	return 0;
}


/*顺序表的长度*/
int length(SeqList *L)
{
	return L->length;
}

/*顺序表是否满*/
int full(SeqList *L)
{
	return (L->length == MAXSIZE)?1:0;
}

/*是否空*/
int empty(SeqList *L)
{
	return (L->length == 0)?1:0;
}

/*插入元素*/
int insert(SeqList *L, int i, DataType x)
{
	int j;

	/*判断是否满*/
	if(full(L))
	{
		printf("Error[10001],顺序表已满！\n");
		return 10001;
	}
	/*判断位置i合法性*/
	if(i<1 || i>length(L)+1)
	{
		printf("Error[10002],位置i不合法！\n");
		return 10003;
	}

	/*移动元素,向后移动*/
	for(j=L->length;j>=i;j--)
	{
		L->data[j] = L->data[j-1];
	}
	L->data[j] = x;
	L->length++;
	return 0; /*ok!*/
}

/*删除元素*/
int delete(SeqList *L, int i, DataType *x) {
    if (i < 1 || i > L->length) {
        // 越界检查，判断是否给定的位置 i 合法
        return 0; // 删除失败，返回0
    }
    *x = L->data[i - 1];
    for (int j = i; j < L->length; j++) {
        L->data[j - 1] = L->data[j];
    }
    L->length--;
    return 1; // 删除成功，返回1
}

/*输出顺序表*/
void print(SeqList *L)
{
	int i;

	if(empty(L))
	{
		printf("顺序表为空！");
		return ;
	}
	printf("顺序表为:");
	for(i=0;i<L->length;i++)
	{
		printf(" %d ", L->data[i]);
	}
	printf("\n");
}

SeqList.h

/*

	SeqList.h 顺序表定义
*/

#define MAXSIZE 1000

typedef int DataType;

/*顺序表*/
typedef struct
{
	DataType data[MAXSIZE];
	int length;
}SeqList;

/*顺序表初始化*/
int init(SeqList *L);

/*顺序表的长度*/
int length(SeqList *L);

/*顺序表是否满*/
int full(SeqList *L);

/*是否空*/
int empty(SeqList *L);

/*插入元素*/
int insert(SeqList *L, int i, DataType x);

/*删除元素*/
int delete(SeqList *L, int i, DataType *x);

/*输出顺序表*/
void print(SeqList *L);

WelCome.h

char welcome[] = "DDQ337";

5. 小结；

顺序表最主要的特点是可以进行 随机访问，即可以通过表头元素的地址和元素的编号 (下标)
顺序表的不足之处是插入和删除操作需要移动大量的元素，从而保持逻辑上和物理上的连续性。

6. 参考文献

顺序表--《百度》

《数据结构C语言》--李刚  刘万辉