数据结构学习（1）

（一）顺序表
定义： 将线性表中的元素相继存放在一个连续的存储空间中（可利用一维数组描述存储结构）。
特点： 线性表的顺序存储方式，直接前驱，直接后驱。
遍历： 顺序访问, 可以随机存取。
代码
SequenceList.h

#ifndef   SEQUENCE_LIST
#define  SEQUENCE_LIST
#define  SIZE              10
#define  SUCCESS     1000
#define  FAILURE        1001
typedef   int  ElemType; 
struct  sequence
{
	ElemType *data;
	int length;
};
struct sequence Seq;
int InitList(Seq *l);//初始化
int InsertList(Seq *l, int p, Elemtype e);//插入数据
int TraverseList(Seq l, void(*p)(ElemType e));//显示数据
int GetElem(Seq l, int p, ElemType e);//获取元素
int ListEmpty(Seq l00);//判断线性表为空
int ListLength(Seq l);//查看元素个数
int LocateElem(Seq l, ElemType e, int (*p)(int ,int ));//查找元素
int ListDelete(Seq *l, int p, ElemType *e);//删除元素
int ClearList(Seq *l);//清空线性表
int DestoryList();//销毁线性表
#endif

SequenceList.c

int InintList(Seq *l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	l->data = (ElemType *)malloc(sizeof(ElemType) * SIZE);
	if(NULL == l->data)
	{
		return FAILURE;
	}
	l->length = 0;
	return SUCCESS;
}

int InsertList(Seq *l, int p, ElemType e)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	if(p <= 0 || p > l-> length + 1 || l->length >= SIZE)
	{
		return FAILURE;
	}
	int i;
	for(i = 0; i < l->length - p + 1; i++)
	{
		l->data[l->length - i] = l->data[l->length - i - 1];
	}
	l->data[p - 1] = e;
	l->length++;
	return SUCCESS;
}

int TraverseList(Seq l, void (*p)(ElemType))
{
	int i;
	for(i = 0; i < l.length; i++)
	{
		p(l.data[i]);
	}
	return SUCCESS;
}

int GetElem(Seq l, int p, ElemkType *e)
{
	if(p > l.length)
	{
		return FAILURE;
	}
	*e = l.data[p - 1];
	return SUCCESS;
}

int ListEmpty(Seq l)
{
	return (l.length == 0) ? SUCCESS : FAILURE;
}

int ListLength(Seq l)
{
	return l.length;
}

int LocateElem(Seq l, ElemType e, int (*p)(int ,int))
{
	int i;
	for(i = 0; i < l.length; i++)
	{
		if(p(l.data[i], e))
		{
			return i + 1;
		}
	}
	return FAILURE;
}

int ListDElete(Seq *l, int p, ElemType *e)
{
	if(NULL == l || p <= 0 || p > l->length)
	{
		 return FAILURE;
	}
	int i;
	*e = l->data[p -1];
	for(i = 0; i < l->length - p; i++)
	{
		l->data[p - 1 + i] = l->data[p + i];
	}
	l->length--;
	return SUCCESS;
}

int ClearList(Seq *l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	l->length = 0;
	return SUCCESS;
}
int DestoryList(Seq *l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	free(l->data);
	l->data = NULL;
	return SUCCESS;
}

main.c

void show(ElemType e)
{
	printf("%s\n",e);
}

int equal(int x, int y)
{
	return (x == y) ? 1:0;
}

int main()
{
	Seq s;
	int ret, i;

	ret = InitList(&s);
	if(FAILURE == ret)
	{
		printf("init failure!\n");
		exit(1);
	}
	else if(SUCCESS == ret)
	{
		printf("init success!\n");
	}
	
	for(i = 0; i < 5; i++)
	{
		ret = InsertList(&s, i + 1, i + 1);
		if(FAILURE == ret)
		{
			printf("sert %d failure!\n", i + 1);
		}
		else if(SUCCESS == ret)
		{
			printf("sert %d success!\n", i + 1);
		}
	}

	ret = TraverseList(s,show);
	if(SUCCESS == ret)
	{
		printf("\n traverse success!\n");
	}
	else if(FAILURE == ret)
	{
		printf("\n traverse failure!\n");
	}

	int p = 3;
	ElemType e;
	ret = GetElem(s, p, &e);
	if(FAILURE == ret)
	{
		printf(“get elemtype failure!\n”);
	}
	else if(SUCCESS == ret)
	{
		printf("%d-th element is %d\n", p, e);
	}

	ret = ListEmpty(s);
	if(SUCCESS == ret)
	{
		printf("线性表是空\n");
	}
	else if(FAILURE == ret)
	{
		printf("线性表不是空!\n");
	}

	ret = ListLength(s);
	printf("length is %d\n", ret);

	e = 100;
	ret = LocateElem(s, e, equal);
	if(FAILURE == ret)
	{
		printf("element %d is not exit!\n", e);
	}
	else 
	{
		printf("element %d id %d-th!\n", e, ret);
	}
	
	for(i = 0; i < 3; i++)
	{
		ret = ListDelete(&s, i + 1, &e);
		if(SUCCESS == ret)
		{
			printf("delete %d success!\n", e);
		}
		else if(FAILURE == ret)
		{
			pri"delete %d failure!\n", e);
		}
	}
	return 0;
}