写一篇《详解顺序表》

文章目录

• 系列文章目录
• 前言
• 1. 顺序表的定义及其特点；
  2. 顺序表的运算（概述）；
  3. 顺序表的实现（详细的介绍及C程序代码、执行结果）；
  4. 完整的Demo；
  5. 总结；
   

---

前言

提示：顺序表是线性表的一种，线性表是线性排列的一组具有相同数据类型的元素的有限集合。

顺序表是在计算机内存中以数组的形式保存的线性表，除第一个元素外，所有的元素都有且只有一个直接后驱，除最后一个元素外，所有的元素都有且只有一个直接前驱，它是数据结构中最常用也是最基本的数据结构。

---

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

一、顺序表的定义及其特点

1. 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。
2. 顺序表具有元素间的逻辑关系通过数组下标来体现、数据元素在内存中占一块连续的存储空间、数据元素的存储空间在内存中是连续的等特性。

二、顺序表的运算（概述）

顺序表的基本运算包括创建、插入、删除、查找和遍历等操作。

1. 创建顺序表需要确定元素类型和表的大小，在内存中分配一段连续的空间用来存储元素，创建顺序表的时间复杂度为O(1)。
2. 插入操作是将一个元素插入到顺序表的指定位置，插入操作需要移动插入位置后面的元素以腾出空间，如果插入位置在表尾，直接在表尾添加元素即可，插入操作的时间复杂度为O(n)。
3. 删除操作是将顺序表中的一个元素删除，删除操作需要将删除位置后面的元素向前移动以填补删除位置，如果删除位置在表尾，直接删除即可，删除操作的时间复杂度为O(n)。
4. 查找操作是在顺序表中查找一个元素，顺序表可以通过下标直接访问元素，因此查找操作的时间复杂度为O(1)。
5. 遍历操作是依次访问顺序表中的每个元素，遍历操作可以使用for循环或while循环实现，遍历操作的时间复杂度为O(n)。

三、顺序表的实现详细的介绍及C程序代码执行结果

顺序表是一种使用数组来存储数据元素的线性表数据结构。下面是对顺序表实现的一些详细介绍和示例C程序代码：

顺序表的实现:

1. 定义结构体

首先，我们需要定义一个结构体来表示顺序表，结构体中包含一个元素类型为数据元素的数组和表示顺序表长度的变量。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXSIZE 100 // 定义最大长度为100

typedef struct {
        int data[MAXSIZE]; // 存储数据的数组
        int length; // 顺序表的长度
} SeqList;

1. 初始化顺序表

我们需要提供一个初始化顺序表的函数，用于创建空的顺序表。

void InitList(SeqList *L) {
        L->length = 0; // 将顺序表长度初始化为0
}

1. 插入元素

插入操作需要移动插入位置后面的元素以腾出空间，并将新元素插入到指定位置。如果插入位置不合法或者顺序表已满，插入操作失败。

int InsertList(SeqList *L, int index, int value) {
        if (index < 1 || index > L->length + 1 || L->length >= MAXSIZE) {
                return 0; // 插入位置不合法或者顺序表已满，插入操作失败
        }
        for (int i = L->length; i >= index; i--) {
                L->data[i] = L->data[i - 1]; // 将插入位置后面的元素向后移动一位
        }
        L->data[index - 1] = value; // 将新元素插入到指定位置
        L->length++; // 将顺序表长度加1
        return 1; // 插入操作成功
}

1. 删除元素

删除操作需要将删除位置后面的元素向前移动以填补删除位置。如果删除位置不合法，删除操作失败。

int DeleteList(SeqList *L, int index) {
        if (index < 1 || index > L->length) {
                return 0; // 删除位置不合法，删除操作失败
        }
        for (int i = index; i < L->length; i++) {
                L->data[i - 1] = L->data[i]; // 将删除位置后面的元素向前移动一位
        }
        L->length--; // 将顺序表长度减1
        return 1; // 删除操作成功
}

1. 查找元素

查找操作可以通过下标直接访问元素，如果查找的位置不合法，查找操作失败。

int FindList(SeqList *L, int index) {
        if (index < 1 || index > L->length) {
                return -1; // 查找位置不合法，查找操作失败
        }
        return L->data[index - 1]; // 返回找到的元素值
}

四、完整的Demo

代码实现：

#include <stdio.h>
#include "SeqList.h"
//#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("请输入删除元素位置：");
            scanf("%d,%d",&i,&x);
            if(!delete(&L,i,&x))
            {
                printf("元素已删除!\n");
            }
            else{
                printf("元素删除失败!\n") ;
            }
            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 顺序表实现
*/
#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 10002;
    }
 
    /*移动元素,向后移动*/
    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) {
    int j;
    //判断输入元素的位置是否合法
    if(i<1 || i>length(L)+1) {
        printf("Error[10002],位置i不合法！\n");
        return 10002;
    }
    x=L->data[i] ;
    for(j=i; j<L->length-1; j++)
        L->data[j]=L->data[j+1];
         L->length--;
        return 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");
}

运行结果：

---

总结感受：

1. 顺序表是一种简单的数据结构，使用数组来存储数据元素，在数组上完成数据的增删查改。
2. 顺序表的特点是简单易懂，物理储存结构直观，但插入、删除操作复杂，只适用于小规模数据处理。