数据结构-线性表

1，定义

线性表是指n (n>=0)个相同类型的数据元素a₀,a₁,...a_n-1所构成的有限线性序列，其一般描述为：LinearList=(a₀，a₁，…，a_n－1)

1) 其中LinearList称为线性表的名称

2) 每个ai（n-1≥i≥0）称为线性表的数据元素，可以是整数、浮点数、字符或类

3) 表中相邻元素之间存在着顺序关系：将a_i-1称为a_i的直接前趋，a_i+1称为a_i的直接后继

4) 具体n的值称为线性表中包含有数据元素的个数，也称为线性表的长度

5) 当n的值等于0时，表示该线性表是空表

 

离散定义如下：B=<A,R>,其中A包含n个结点的集合(a0,a1,…an-1)，R是关系的集合{(ai-1,ai)|i=1,2,..n}，可见R只有一种类型的关系，即线性关系。

 

抽象数据类型定义如下：

         ADT LinearList

         {

         数据对象:D＝{ai|ai∈元素集合,i=0,1,2,..n-1        n>=0}

         数据关系:R={<ai-1,ai>|ai-1,ai∈元素集合,i=1,2,..n}

         基本操作：{插入，删除，查找等}

         }        ADT LinearList

2，实现

SeqList.h ： 放置功能函数的声明，以及表和表结点的声明

SeqList.h ： 放置功能函数的定义，以及表和表结点的定义

 Main.c ： 主函数，使用功能函数完成各种需求

SeqList.h：

/*
 * SeqList.h
 *
 *  Created on: 2017年1月13日
 *      Author: Administrator
 */

#ifndef _SEQLIST_H_  //防止重复调用
#define _SEQLIST_H_

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);



#endif /* SRC_SEQLIST_H_ */

SeqList.c：

/*
 * SeqList.c
 *
 *  Created on: 2017年1月13日
 *      Author: Administrator
 */

#include <stdio.h>
#include <malloc.h>
#include "SeqList.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList
{
	int capacity;
	int length;
	TSeqListNode* node;
}TSeqList;

SeqList* SeqList_Create(int capacity)
{
	TSeqList* ret = NULL;

	if(ret == NULL)
	{
		ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity);
	}

	if(ret != NULL)
	{
		ret->capacity = capacity;
		ret->length = 0;
		ret->node = (TSeqListNode*)(ret+1);
	}

	return ret;
}

void SeqList_Destroy(SeqList* list)
{
	free(list);
}

void SeqList_Clear(SeqList* list)
{
	TSeqList* sList = (TSeqList*)list;

	if(sList!=NULL)
	{
		sList->length = 0;
	}
}

int SeqList_Length(SeqList* list)
{
	TSeqList* sList = (TSeqList*)list;
	int ret = -1;

	if(sList!=NULL)
	{
		ret = sList->length;
	}

	return ret;
}

int SeqList_Capacity(SeqList* list)
{
	TSeqList* sList = (TSeqList*)list;
	int ret = -1;

	if(sList!=NULL)
	{
		ret = sList->capacity;
	}

	return ret;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
	TSeqList* sList = (TSeqList*)list;
	int ret = (sList!=NULL);
	int i = 0;

	ret = ret && (sList->length+1 <= sList->capacity);
	ret = ret && (pos >= 0);

	if(ret)
	{
		if(pos >= sList->length)
		{
			pos = sList->length;
		}

		for(i=sList->length; i>pos; i--)
		{
			sList->node[i] = sList->node[i-1];
		}

		sList->node[i] = (TSeqListNode)node;

		sList->length++;
	}

	return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos)
{
	TSeqList* sList = (TSeqList*)list;
	SeqListNode* ret = NULL;

	if( (sList!=NULL) && (pos >= 0) && (pos<sList->length) )
	{
		ret = (TSeqListNode*)(sList->node[pos]);
	}

	return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
	SeqListNode* ret = SeqList_Get(list, pos);

	TSeqList* sList = (TSeqList*)list;

	int i = 0;

	if(ret!=NULL)
	{
		for(i=pos+1; i<sList->length; i++)
		{
			sList->node[i-1] = sList->node[i];
		}

		sList->length--;
	}

	return ret;
}

main.c

/*
 * main.c
 *
 *  Created on: 2017年1月13日
 *      Author: Administrator
 */

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

int main(void)
{
	SeqList* list = SeqList_Create(6);

	int i=0, j=1, k=2;
	int x=3, y=4;

	int index = 0;

	SeqList_Insert(list, &i, 0);
	SeqList_Insert(list, &j, 0);
	SeqList_Insert(list, &k, 0);
	SeqList_Insert(list, &x, 0);
	SeqList_Insert(list, &y, 0);

	for(index=0; index<SeqList_Length(list); index++)
	{
		int* p = (int*)SeqList_Get(list, index);

		printf("%d\n", *p);
	}

	while(SeqList_Length(list) > 0)
	{
		int* p = (int*)SeqList_Delete(list, 0);

		printf("%d\n", *p);
	}

	SeqList_Destroy(list);

	return 0;
}

结果：

4
3
2
1
0
4
3
2
1
0

说明：本文参考网络并测试