数据结构_顺序表的基本操作（c）

线性表是最常用且最简单的一种数据结构，因此线性表的学习很重要。

线性表：n（n>=0）个数据元素组成的一个有限序列，可以再其任意位置上进行插入和删除操作的线性数据结构，从数据在物理内存存储形式上线性表可分为：顺序表和链表。

顺序表用一段地址连续的存储单元依次存储数据元素的线性结构，它具有随机访问内存的能力，在C语言中，一般可以用一维数组来表示线性表。

数组有静态数组和动态数组之分，所以顺序表分为静态顺序表和动态顺序表：

    

    1.静态顺序表，申请固定的大小

//   静态顺序表

#define MAX_SIZE

typedef int DataType;

struct SeqList

{

    DataType arr[MAX_SIZE];

    int size;

};

    2.动态顺序表，增加一个指针，当数据满时，可以开辟一块更大的内存

//    动态顺序表

typedef struct SeqList

{

    DataType* array;       // 数据块指针

    size_t size;                  //  当前有效数据个数

    size_t capicity;             // 容量

}SeqList;

下面是一些静态顺序表的基本操作：

// 头文件

  6 #include<stdlib.h>                                                                                                                

  7 #include<stdio.h>                                                                                                                 

  8 #include<string.h>                                                                                                                

  9 #include<stddef.h>                                                                                                                

10                                                                                                                                   

11 #define SeqListMax 100                                                                                                            

12                                                                                                                                   

13                                                                                                                                   

14 typedef char SeqListType;                                                                                                         

15                                                                                                                                   

16 typedef struct SeqList{                                                                                                           

17     SeqListType data[SeqListMax];                                                                                                 

18     size_t size;                                                                                                                  

19 }SeqList; 

1.顺序表初始化

    5 void SeqListInit(SeqList* seqlist)   //初始化静态数组                                                                           

    6 {                                                                                                                               

    7     if(seqlist == NULL){                                                                                                        

    8         //  非法输入                                                                                                            

    9         return ;                                                                                                                

   10     }                                                                                                                           

   11     seqlist->size = 0;                                                                                                          

   12 }

2.尾插、尾删

    尾插：插入新元素，增加元素个数，直接赋值；尾删：删除一个元素，减少有效元素个数

   14 void SeqListPushBack(SeqList* seqlist, SeqListType value)  //尾插                                                               

   15 {                                                                                                                               

   16     if(seqlist == NULL){                                                                                                        

   17         // 非法输入                                                                                                             

   18         return ;                                                                                                                

   19     }                                                                                                                           

   20     if(seqlist->size >= SeqListMax){                                                                                            

   21         //  顺序表已满                                                                                                          

   22         return ;                                                                                                                

   23     }                                                                                                                           

   24     seqlist->data[seqlist->size] = value;                                                                                       

   25     ++ seqlist->size;                                                                                                           

   26     return ;                                                                                                                    

   27 }