数据结构：静态顺序表

一，头文件及结构体定义

    #include<stdio.h>
	#include<stdlib.h>
	#define N 100    //定义数组长度，即最大存储数
	typedef struct seqlist
	{
		int data[N]; //用来存储数据的顺序表
		int last;    //有效元素的个数 
	}seqlist_t;

二，函数声明

	seqlist_t* create_empty_seqlist() //创建空顺序表  
	int is_full_seqlist(seqlist_t* p) //判断顺序表是否为满
	int is_emptyseqlist(seqlist_t* p) //判断顺序表是否为空
    int insert_into_seqlist(seqlist_t* p, int post, int x) //向指定位置插入元素
	int delete_from_seqlist(seqlist_t* p,int post) //删除指定位置元素 
	int search_date_seqlist(seqlist_t* p, int x) //查找指定元素的位置 
	void show_seqlist(seqlist_t* p) //遍历顺序表  
	int length_seqlist(seqlist_t* p) //求表长  
	void clear_seqlist(seqlist_t* p) //清空顺序表 

三，函数体

        1）创建空顺序表 

    seqlist_t* create_empty_seqlist()
	{
		//在堆区申请一个结构空间大小
		seqlist_t* p = malloc(sizeof(seqlist_t));
		if(p == NULL)
		{
			printf("createEmptySeqlist malloc failed!!\n");
			return NULL;//申请失败
		}
		p->last = 0; //last表示有效元素，这里赋值为0表示是空的顺序表
		return p;
	}

        2）向指定位置插入元素

	int insert_into_seqlist(seqlist_t* p, int post, int x)
	{
		//0.容错判断,满足任意一个条件，都不允许插入
		if(post < 1 || post > p->last+1 || is_full_seqlist(p))
		{
			printf("insertIntoSeqlist failed!!\n");
			return -1;
		}
		//1.将从最有一个有效元素下标last-1 到插入位置post-1下标 整体向后移动一个位置
		int i;
		for(i = p->last-1; i >= post-1; i--)
			p->data[i+1] = p->data[i];
		//2.向插入位置放上数据ｘ
		p->data[post-1] = x;//post-1得到插入位置对应的数组下标
		//3.有效元素个数+1
		p->last++;
		return 0;
	}

        3）判断顺序表是否为满  

    int is_full_seqlist(seqlist_t* p)
	{
		return p->last == N ? 1 : 0;
	}

        4）判断顺序表是否为空   

    int is_empty_seqlist(seqlist_t* p)
	{
		return p->last == 0 ? 1 : 0;
	}

        5）删除指定位置元素   

    int delete_from_seqlist(seqlist_t* p,int post)
	{
		//0.容错判断 
		if(post < 1 || post > p->last || is_empty_seqlist(p))
		{
			printf("deleteFromSeqlist failed!!\n");
			return -1;
		}
		//1.将删除位置的后一位置的下标post 到 最后一个有效元素下标p->last-1
		//整体向前移动一个位置
		int i;
		for(i = post; i <= p->last-1; i++)
			p->data[i-1] = p->data[i];
		//2.有效元素个数-1
		p->last--;
		return 0;

        6）查找指定元素的位置 

    int search_date_seqlist(seqlist_t* p, int x)
	{
		int i;
		for(i = 0; i < p->last; i++)
		{
			if(p->data[i] == x)
				return i;
		}
		return -1;//代表没有找到
	}

        7）遍历顺序表   

    void show_seqlist(seqlist_t* p)
	{
		int i;
		for(i = 0; i < p->last; i++)
		{
			printf("%d ",p->data[i]);
		}
		printf("\n");
	}

        8）求表长 

    int length_seqlist(seqlist_t* p)
	{
		return p->last;//有效元素的个数，就是表的长度
	}

        9）清空顺序表

    void clear_seqlist(seqlist_t* p)
	{
		p->last = 0;//有效元素个数赋值为０，就是清空表
	}
	

四，主函数

int main(int argc, const char *argv[])
{
	seqlist_t* p = NULL;
	p = create_empty_seqlist();//创建空的顺序表
	insert_into_seqlist(p, 1, 10);
	insert_into_seqlist(p, 2, 20);
	insert_into_seqlist(p, 3, 30);
	insert_into_seqlist(p, 4, 40);
	insert_into_seqlist(p, 5, 50);
	show_seqlist(p);
	insert_into_seqlist(p,2,1000);
	show_seqlist(p);
	delete_from_seqlist(p,2);
	show_seqlist(p);
	printf("len is %d\n",length_seqlist(p));
	int post = search_date_seqlist(p, 30);
	if(post == -1)
		printf("没有找到30!!\n");
	else
		printf("找到了%d,下标是%d\n",p->data[post],post);
	clear_seqlist(p);
	show_seqlist(p);
	printf("len is %d\n",length_seqlist(p));
	free(p);
	return 0;
}

五，运行演示

六，总结

(1)顺序表存储结构：本质是操作数组，在内存当中是连续存储的，顺序存储结构
(2)缺点：
        a. 插入和删除麻烦
        b. 存在表满的情况，长度是固定的
(3)优点：

        a.查找方便，可以直接通过数组的下标，访问顺序表的元素
        b.顺序表可以实现随机访问(只要你有了数组的下标，就可以访问顺序表中的任意一个元素)