SeqList

main.c 

#include"seqList.h"
//比较函数
int compare(elemType e1, elemType e2)
{
	   if(e1 == e2) 
	   {   
		   return TRUE;        
	   }   
	   else
	   {   
	   		return FALSE;   
   	   }   
}

//如下为验证过程
void main()
{
	
	seqList L;
	
	int stat = initSeqList(&L);
	if(OVERFLOW == stat)
	{
		printf("init error\n");	
	}

	displayList(&L);

	insertList(&L,3,1);
	insertList(&L,4,1);
	insertList(&L,5,3);
	insertList(&L,6,2);
	insertList(&L,7,1);
	insertList(&L,1,1);
	insertList(&L,2,1);

	displayList(&L);

	int a;
	
	deleteListElem(&L,1,&a);
	printf("a=%d\n",a);


	displayList(&L);

	int loc = locateElem(&L,3,compare);
	printf("loc=%d\n",loc);
	
	displayList(&L);

	int b;
	getListElem(&L,2,&b);
	printf("b=%d\n",b);

	displayList(&L);
	
	destroySeqList(&L);		
	
}

 SeqList.c

/***************************************
author:xxxx
mail:xxxxxx
desc:链表的线性实现函数

**************************************/

#include<assert.h>
#include"seqList.h"

/*
return:
	OK：表示初始化成功
	OVERFLOW:表示初始化失败，内存未开成功
parm:
	*list：表示要开辟的空间的线性表的地址

*/
int initSeqList(seqList *list)
{
	assert(NULL != list);
	
	(*list).elem=(elemType*)malloc(sizeof(elemType)*SEQ_MAX_SIZE);
	if(NULL == (*list).elem)
	{
		printf("init memory overflow\n");
		return	OVERFLOW;
	}
	(*list).length = 0;
	(*list).maxseqlistsize = SEQ_MAX_SIZE;
	return OK;
}

/*
return:
	无
parm:
	*list：要销毁的线性表

*/
void destroySeqList(seqList *list)
{
	assert(NULL != list);

	free((*list).elem);
	(*list).elem = NULL;
	(*list).length = 0;
	(*list).maxseqlistsize = 0;
	
}
/*
return:
	TRUE：为空
	FALSE:表示非空
parm:
	*list：表示要判断的线性表

*/

int isEmptyList(seqList *list)
{
	assert(NULL != list);
	
	if(0 == (*list).length)
	{
		return TRUE;	
	}
	else
	{
		return FALSE;	
	}
	
}
/*
return:
	线性表的长度
parm:
	*list：要获得长度的线性表

*/

int getListSize(seqList *list)
{
	assert(NULL != list);
	
	return (*list).length;
}
/*
return:
	OK:表示获取成功
	FALSE:表示获取失败
parm:
	*list：线性表
	i:表示获得第几个元素
	e：表示存储拿到的值

*/

int getListElem(seqList *list, int i, elemType *e)
{
	assert(NULL != list);

	if(i<=0 || i>(*list).length)
	{
		printf("beyond size\n");
		return FALSE;	
	}

	*e = (*list).elem[i-1];

	return OK;
	
}
/*
return:
	返回第几个元素
	FALSE:表示没有相同的值
parm:
	*list：线性表
	e：表示要比较的值
	compare:表示比较的函数

*/

int locateElem(seqList *list, elemType e, int (compare)(elemType e1, elemType e2))
{
	assert(NULL != list);

	int i;
	for(i=0;i<(*list).length;i++)
	{
		if(TRUE == compare(e,(*list).elem[i]))
		{
			return i+1;
		}
			
	}

	return FALSE;
}

/*
return:
	OVERFLOW：表示开内存错误
	FALSE:表示插入范围有问题
	OK：插入成功
parm:
	*list：线性表
	e：表示要插入的值
	i：表示在那个位置插入

*/

int insertList(seqList *list, elemType e, int i)
{
	assert(NULL != list);

	if(i<=0 || i>(*list).length+1)
	{
		printf("beyond size\n");
		return FALSE;	
	}
	
	if((*list).length+1 > (*list).maxseqlistsize)
	{
		(*list).elem = (elemType*)realloc((*list).elem,((*list).maxseqlistsize+SEQ_INC_SIZE)*sizeof(elemType));
		if(NULL == (*list).elem)
		{
			printf("realloc overflow\n");
			return OVERFLOW;	
		}

		(*list).maxseqlistsize = (*list).maxseqlistsize + SEQ_INC_SIZE;
	}

	int j;
	for(j=(*list).length-1;j>=i-1;j--)
	{
		(*list).elem[j+1] = (*list).elem[j];
	}

	(*list).elem[i-1] = e;
	(*list).length ++;

	return OK;
}
/*
return:
	OVERFLOW：表示开内存错误
	OK：表示删除成功
parm:
	*list：线性表
	e：拿到删除的值
	i：表示在那个位置删除

*/

int deleteListElem(seqList *list, int i, elemType *e)
{
	assert(NULL != list);
	
	if(i<0 || i>(*list).length-1)
	{
		printf("beyond size\n");
		return OVERFLOW;	
	}
	
	*e = (*list).elem[i-1];
	
	int j;	
	for(j=i-1;j<(*list).length-2;j++)
	{
		(*list).elem[j] = (*list).elem[j+1];
	}

	(*list).length --;
	return OK;
}
/*
return:
	无
parm:
	*list：线性表

*/

void displayList(seqList *list)
{
	assert(NULL != list);

	printf("the list length is:%d\n",(*list).length);
	printf("the list data is:\n");
	
	int i = 0;
	for(i=0;i<(*list).length;i++)
	{
		printf("   %d",(*list).elem[i]);
	}

	printf("\n");
}

SeqList.h 

#ifndef SEQLIST_H
#define SEQLIST_H

#include<stdio.h>
#include<stdlib.h>
//定义宏常量
#define SEQ_MAX_SIZE 100
#define SEQ_INC_SIZE 10

#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
#define OK 1

//设置一个数据类型
typedef int elemType;

//顺序表结构体
typedef struct seqList{
	elemType *elem;
	int length;
	int maxseqlistsize;
}seqList;

//如下为所有顺序表的函数声明

int initSeqList(seqList *list);

void destroySeqList(seqList *list);

int isEmptyList(seqList *list);

int getListElem(seqList *list, int i, elemType *e);

int locateElem(seqList *list, elemType e, int (compare)(elemType e1, elemType e2));

int insertList(seqList *list, elemType e, int i);

int deleteListElem(seqList *list, int i, elemType *e);

void displayList(seqList *list);


#endif

makefile

main:main.o seqList.o
	gcc -g main.o seqList.o -o main
main.o:main.c seqList.h
	gcc -g -c main.c -o main.o
seqList.o:seqList.c seqList.h
	gcc -g -c seqList.c -o seqList.o

clean:
	rm -fr *.o
	rm -fr main