基于静态数组的顺序表的一些基本操作（1）

基于静态数组的顺序表的一些基本操作

1. 顺序表初始化
2. 顺序表尾插
3. 顺序表尾删
4. 顺序表头插
5. 顺序表头删
6. 读取顺序表任意位置元素
7. 修改顺序表任意位置元素
8. 查找顺序表中指定元素的下标
9. 在顺序表任意位置插入元素

10.删除顺序表中任意位置的元素

先要建立一个结构体

  1 #include<stdio.h>
  2 #pragma once
  3 #define SeqListMaxSize 100
  4 typedef char SeqListType;
  5 
  6 typedef struct SeqList
  7 {
  8     SeqListType data[SeqListMaxSize];
  9     size_t size;
 10 }SeqList;

1. 顺序表初始化 

首先要对顺序表进行判空，若不为空，则将顺序表进行初始化。

3 //初始化顺序表 4 void SeqListInit(SeqList *seqlist) 5 { 6 if(seqlist == NULL) 7 { 8 return ; 9 } 10 seqlist->size=0; 11 } 12

2. 顺序表尾插 

定义函数SeqListPushBack需要两个参数，一个是顺序表，一个是要插入的元素Value。

首先要对顺序表是否为空和顺序表是否已满进行判断，然后将顺序表的最后一个元素赋值成要插入的元素。

 13 //尾插
 14 void SeqListPushBack(SeqList *seqlist,SeqListType value)
 15 {
 16     if(seqlist == NULL)
 17     {
 18         //非法输入
 19         return ;
 20     }
 21     if(seqlist->size>=SeqListMaxSize)
 22     {
 23         //顺序表满了
 24         return ;
 25     }
 26     seqlist->data[seqlist->size]=value;
 27     ++seqlist->size;
 28     return ;
 29 }

3. 顺序表尾删

定义函数SeqListPopBack仅需要一个参数。

首先要对顺序表是否为空进行判断，然后将顺序表的最后一个元素进行删除。

 31 //尾删
 32 void SeqListPopBack(SeqList *seqlist)
 33 {
 34     if(seqlist == NULL)
 35     {
 36         //非法输入
 37         return ;
 38     }
 39     if(seqlist->size==0)
 40     {
 41         //空顺序表
 42         return ;
 43     }
 44     --seqlist->size;
 45     return ;
 46 }

4. 顺序表头插

定义函数SeqListPushFront需要两个参数，一个是顺序表，一个是要插入的元素Value。

首先要对顺序表是否为空和顺序表是否已满进行判断，然后将顺序表后面的元素依次后移，然后将第一个元素赋值成要插入的元素。

 48 //头插
 49 void SeqListPushFront(SeqList *seqlist,SeqListType value)
 50 {
 51     if(seqlist == NULL)
 52     {
 49 void SeqListPushFront(SeqList *seqlist,SeqListType value)
 50 {
 51     if(seqlist == NULL)
 52     {
 53         //非法输入
 54         return ;
 55     }
 56     if(seqlist->size>=SeqListMaxSize)
 57     {
 58         //顺序表满了
 59         return ;
 60     }
 61     ++seqlist->size;
 62     size_t i=seqlist->size-1;
 63     for(;i>0;--i)
 64     {
 65         seqlist->data[i]=seqlist->data[i-1];
 66     }
 67     seqlist->data[0]=value;
 68     return ;
 69 }

5. 顺序表头删

定义函数SeqListPopFront仅需要一个参数。

首先要对顺序表是否为空进行判断，然后将顺序表后面的元素前移。

 71 //头删
 72 void SeqListPopFront(SeqList *seqlist)
 73 {
 74     if(seqlist == NULL)
 75     {
 76         //非法输入
 77         return ;
 78     }
 79     if(seqlist->size==0)
 80     {
 81         //空顺序表
 82         return ;
 83     }
 84     size_t i=0;
 85     for(;i<seqlist->size-1;++i)
 86     {
 87         seqlist->data[i]=seqlist->data[i+1];
 88     }
 89     --seqlist->size;
 90     return ;
 91 }
 92 

6. 读取顺序表任意位置元素

定义函数SeqListGetValue需要两个参数，一个是顺序表，一个是要读取元素的位置pos。

 93 //读取pos位置的元素
 94 void SeqListGetValue(SeqList *seqlist,size_t pos)
 95 {
 96     if(seqlist == NULL)
 97     {
 98         //非法输入
 99         return ;
100     }
101     if(pos>seqlist->size)
102     {
103         //越界查找
104         return ;
105     }
106     printf("查找位置的元素为%c\n",seqlist->data[pos]);
107     return ;
108 }

7. 修改顺序表任意位置元素

定义函数SeqListSetValue需要三个参数，一个是顺序表，一个是要修改元素的位置pos，一个修改后的元素。

首先要对顺序表是否为空和顺序表是否越界进行判断，然后将顺序表pos位置的元素赋值成要修改的元素。

129 //修改pos位置的元素
130 void SeqListSetValue(SeqList *seqlist,size_t pos,SeqListType value)
131 {
132     if(seqlist == NULL)
133     {
134         //非法输入
135         return ;
136     }
137     if(pos>seqlist->size)
138     {
139         //越界访问
140         return ;
141     }
142     seqlist->data[pos]=value;
143     return ;
144 }

8. 查找顺序表中指定元素的下标

定义函数SeqListGetPos需要两个参数，一个是顺序表，一个是指定的元素Value。

首先要对顺序表是否为空进行判断，然后用循环来找到指定的元素。

110 //获取指定元素的下标
111 void SeqListGetPos(SeqList *seqlist,SeqListType value)
112 {
113     if(seqlist == NULL)
114     {
115         //非法输入
116         return ;
117     }
118     size_t i=0;
119     for(;i<SeqListMaxSize;++i)
120     {
121         if(seqlist->data[i]==value)
122         {
123             printf("查找元素的下标为%d\n",i);
124         }
125     }
126     return ;
127 }

9. 在顺序表任意位置插入元素

定义函数SeqListInsert需要三个参数，一个是要插入的位置pos，一个是要插入的元素Value。

首先要对顺序表是否为空和顺序表是否越界以及顺序表是否已满进行判断，然后将要插入的位置pos及之后的元素全部后移，再将要插入的元素Value插入到pos位置。

157 //在任意位置插入元素
158 void SeqListInsert(SeqList *seqlist,size_t pos,SeqListType value)
159 {
160     if(seqlist == NULL)
161     {
162     //非法输入
163     return ;
164     }
165     if(pos>seqlist->size)
166     {
167     //越界访问
168     return ;                                                                                              
169     }
170     if(seqlist->size>=SeqListMaxSize)
171     {
172     //顺序表满了
173     return ;
174     }
175     if(pos==0)
176     {
177     SeqListPushFront(seqlist,value);
178     return ;
179     }
180     ++seqlist->size;
181     size_t i=seqlist->size-1;
182     for(;i-1>=pos;--i)
183     {
184     seqlist->data[i]=seqlist->data[i-1];
185     }
186     seqlist->data[pos]=value;                                                                             
187 }

10.删除顺序表中任意位置的元素

定义函数SeqListErase需要两个参数，一个是顺序表，一个是要删除的元素的位置。

首先要对顺序表进行是否为空和顺序表是否已满进行判断，然后将要删除的位置pos之后的元素全部向前移一位顺。

178 //删除指定位置的元素
179 void SeqListErase(SeqList *seqlist,size_t pos)
180 {
181     if(seqlist == NULL)
182     {
183         //非法输入
184         return ;
185     }
186     if(seqlist->size == 0)
187     {
188         //空顺序表
189         return ;
190     }
191     if(pos>=seqlist->size)
192     {
193         //越界访问
194         return ;
195     }
196     size_t i=pos;
197     for(;i<seqlist->size-1;++i)
198     {
199         seqlist->data[i]=seqlist->data[i+1];
200     }
201     --seqlist->size;
202     return ;
203

注：在写完每个函数之后，最好对函数进行单元测试，来检查代码是否书写正确。

最后测试结果为