顺序表实现案例

范例1

## list.c
#include <stdio.h>
#include <stdlib.h>
typedef int data_t;

typedef struct list{
	int size;   //容器能保存的元素个数
	int last; //保存最后一个有效元素的下标
	data_t data[0]; //不定长数组名 必须放于 结构体的最后一个成员
}list_t;
/*返回创建好的 空顺序表 的地址*/



list_t *creat_list(int size)
{
	list_t *p;
	p = malloc(sizeof(list_t) + (sizeof(data_t) * size));//申请空间
	p->size = size;
	p->last = -1;  //初始化 结构内部相应内容

	return p;
}
/*
 * p： 顺序表的地址
 * index：插入的下标位置
 * data：插入的数据
 *
 * return：成功返回0 ；失败返回-1
 * */
int ins_index_list(list_t *p,int index,const data_t *data)
{

	//1.将插入位置的数据向下移动
	//  1.1 移动最后一个 到下一个位置   data[last + 1] = data[last];
	//  1.2 移动倒数第二个             
	//  1.3 。。。。
	//
	//2.写入数据到对应位置
	//3. last ++
	
	int i;
	
	if(p->size - 1 == p->last) // 如果容器满 直接退出
		return -1;
	if(index < 0 || index > p->last + 1)
		return -2;

	for(i = p->last;i >= index;i --){
		p->data[i + 1] = p->data[i];
	}

	p->data[index] = *data;

	p->last ++; // (*p).last

	return 0;
}

int del_index_list(list_t *p,int index)
{
	//1.移动删除位置之下的数据
	//   1.1 index + 1 位置的数据到 index
	//   1.2 index + 2              index + 1
	//   ....
	//2.laint main(int argc, const char *argv[])
	
	int i;
	if(-1 == p->last)  //如果为空，则退出
		return -1;
	if(index < 0 || index > p->last)
		return -2;

	for(i = index;i < p->last;i ++){
		p->data[i] = p->data[i + 1];
	}

	p->last --; //p->last // (*p).last
	
	return 0;
}

int get_index_list(list_t *p,int index,data_t *databuf)
{
	if(-1 == p->last)  //如果为空，则退出
		return -1;
	if(index < 0 || index > p->last)
		return -2;

	*databuf = p->data[index];

	return 0;
}

int change_index_list(list_t *p,int index,const data_t *newdata)
{
	if(-1 == p->last)  //如果为空，则退出
		return -1;
	if(index < 0 || index > p->last)
		return -2;

	p->data[index] = *newdata;

	return 0;
}
/*如果为满 返回 真1；非满 返回假0*/
int is_full_list(list_t *p)
{

	return (p->size - 1) == p->last;
}

int is_empty_list(list_t *p)
{
	return -1 == p->last;
}

int locate_list(list_t *p,const data_t *data)
{
	int i;

	if(NULL == p || NULL == data)
		return -2;

	for(i = 0;i <= p->last;i ++){
		if(*data == p->data[i])
			return i;
	}

	return -1;
}

int clean_list(list_t *p)
{
	p->last = -1;
	return 0;
}

int dis_list(list_t *p)
{
	free(p);
	
	return 0;
}


void print_list(list_t *p)
{
	int i;
	for(i = 0;i <= p->last;i ++){// 打印数据集合里的内容
		printf("%d ",p->data[i]);
	}
	printf("\n");
	printf("last:%d\n",p->last);//打印
	//最后一个元素位置
	return ;
}

## list.h
#ifndef __LIST_H__
#define __LIST_H__

typedef int data_t;

#define list_t struct list

extern list_t *creat_list(int size);
extern int ins_index_list(list_t *p,int index,const data_t *data);
extern int del_index_list(list_t *p,int index);
extern int change_index_list(list_t *p,int index,const data_t *newdata);
extern int get_index_list(list_t *p,int index,data_t *databuf);
extern int is_full_list(list_t *p);
extern int is_empty_list(list_t *p);
extern int locate_list(list_t *p,const data_t *data);
extern int clean_list(list_t *p);
extern int dis_list(list_t *p);
extern void print_list(list_t *p);

#endif

## main.c


#include "list.h"
int main(int argc, const char *argv[])
{
	list_t *p;
	list_t *p1;
	
	data_t buf;
	int i;

	p = creat_list(15);
	for(i = 0;i < 20;i ++){
		ins_index_list(p,0,&i);
	}

	print_list(p);
	del_index_list(p,4);
	print_list(p);

	buf = 250;
	ins_index_list(p,6,&buf);
	print_list(p);

	buf = 250;
	i = locate_list(p,&buf);
	
	buf = 251;
	change_index_list(p,i,&buf);
	print_list(p);

	//p->data[5];
	get_index_list(p,5,&buf);

	clean_list(p);

	print_list(p);
	dis_list(p);

	return 0;
}

范例2

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

#define SIZE 8
typedef int data_t;
typedeef struct list{
	data_t data[SIZE]; //保存数据的空间
	int last; //保存最后一个有效元素的下标(last不在数组内的)
}list_t;

/*返回创建好的 空顺序表 的地址*/

list_t *creat_list()//创建不需要参数，需要返回一个地址
{
	list_t *p;
	p = malloc(sizeof(list_t));//申请空间
	p->last = -1;  //初始化 结构内部相应内容

	return p;
}
/*
 * p： 顺序表的地址
 * index：插入的下标位置
 * data：插入的数据
 *
 * return：成功返回0 ；失败返回-1
 * */
int ins_index_list(list_t *p,int index,data_t data)
{

	//1.将插入位置的数据向下移动
	//  1.1 移动最后一个 到下一个位置   data[last + 1] = data[last];
	//  1.2 移动倒数第二个             
	//  1.3 。。。。
	//
	//2.写入数据到对应位置
	//3. last ++
	
	int i;
	
	if(SIZE - 1 == p->last) // 如果容器满 直接退出
		return -1;
	if(index < 0 || index > p->last + 1)//如果插入位置和last所指向位置隔了1个元素则，last加1不再指向最后一个元素
		return -2;

	for(i = p->last;i >= index;i --){
		p->data[i + 1] = p->data[i];
	}

	p->data[index] = data;

	p->last ++; // (*p).last

	return 0;
}

int del_index_list(list_t *p,int index)
{
	//1.移动删除位置之下的数据
	//   1.1 index + 1 位置的数据到 index
	//   1.2 index + 2              index + 1
	//   ....
	//2.last --
	
	int i;
	if(-1 == p->last)  //如果为空，则退出
		return -1;
	if(index < 0 || index > p->last)
		return -2;

	for(i = index;i < p->last;i ++){
		p->data[i] = p->data[i + 1];
	}

	p->last --; //p->last // (*p).last
	
	return 0;
}


void print_list(list_t *p)
{
	int i;
	for(i = 0;i <= p->last;i ++){// 打印数据集合里的内容
		printf("%d ",p->data[i]);
	}
	printf("\n");
	printf("last:%d\n",p->last);//打印
								//最后一个元素位置
	return ;
}

int main(int argc, const char *argv[])
{
	list_t *p;
	list_t *p1;

	int i;

	p = creat_list();
	p1 = creat_list();

	for(i = 6;i >= 0;i --){                 //相当于每次都是头插，之前的数据会被后移的
		ins_index_list(p,0,i);
	}

	print_list(p);

	del_index_list(p,7);
	print_list(p);

	return 0;
}