线性表之顺序表

线性表的定义     定义n个数据元素的有限序列，记作（a1, a2, …, an）ai 是表中数据元素，n 是表长度。

线性表的特点

1. 除第一个元素外，其他所有元素都只有一个直接前驱。

2. 除最后一个元素外，其他所有元素都只有一个直接后继。

顺序表的定义和特点

定义  ：”将线性表中的元素相继存放在一个连续的存储空间中，

               可利用一维数组描述存储结构 。

特点  ：线性表的顺序存储方式 。

遍历  ：顺序访问, 可以随机存取 。

以下就是对顺序表的一些操作：

头文件以及宏定义，函数申明：

#ifndef _SEQUENCELIST_H
#define _SEQUENCELIST_H 

#define SIZE       10
#define SUCCESS    10000
#define FAILURE    10001
#define TRUE       10002
#define FALSE      10003

typedef int ElemType;

struct SequenceList
{
	int length;
	ElemType *data;    
};

typedef struct SequenceList SeList;

int SequenceInit(SeList *l);
int SequenceInsrt(SeList *l, int p, ElemType e);
int SequenceLength(SeList l);
int GetElem(SeList l, int p, ElemType *e);
int SequenceTraverse(SeList l, void (*p)(ElemType));
int SequenceEmpty(SeList l);
int LocateElem(SeList l, ElemType e, int (*p)(ElemType, ElemType));
int SequenceDelete(SeList *l, int p, ElemType *e);
int SequenceClear(SeList *l);
int SequenceDestroy(SeList *l);
#endif

接下来是功能子函数：

包含一下头文件：

#include "SequenceList.h"
#include <stdlib.h>

初始化操作，建立一个空的顺序表：

int SequenceInit(SeList *l)
{
	if (NULL == l)     //入参判断
	{
		return FAILURE;
	}

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

	return SUCCESS;
}

若顺讯表为空，返回true，否则返回false：

int SequenceEmpty(SeList l)
{
	return (l.length == 0) ? TRUE : FALSE; 
}

将顺训表清空：

int SequenceClear(SeList *l)
{
	if (l == NULL)
	{
		return FAILURE;
	}
	
	l->length = 0;

	return SUCCESS;
}

 

将顺序表中的第i个位置的元素，返回给e：

int GetElem(SeList l, int p, ElemType *e)
{
	if (p < 1 || p > l.length)
	{
		return FAILURE;
	}

	*e = l.data[p - 1];
	return SUCCESS;
}

在顺序表中查找与给定值e相等的元素：

int LocateElem(SeList l, ElemType e, int (*p)(ElemType, ElemType))
{
	int i;

	for (i = 0; i < l.length; i++)
	{
		//if (e == l.data[i])
		if (p(e, l.data[i]) == TRUE)
		{
			return i + 1;
		}
	}

	return FAILURE;
}

在顺序表第i个位置插入元素e：

int SequenceInsrt(SeList *l, int p, ElemType e)
{
	int i;

	if (NULL == l || NULL == l->data)
	{
		return FAILURE;
	}
	if (p > l->length + 1 || l->length >= SIZE || p < 1)
	{
		return FAILURE;
	}

	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;
}

删除顺序表中的第i个位置元素：

int SequenceDelete(SeList *l, int p, ElemType *e)
{
	if (NULL == l)
	{
		return FAILURE;
	}

	if (p < 1 || 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 SequenceLength(SeList l)
{
	return l.length;
}

销毁顺序表：

int SequenceDestroy(SeList *l)
{
	if (l == NULL)
	{
		return FAILURE;
	}

	l->length = 0;
	free(l->data);
	l->data = NULL;

	return SUCCESS;
}

遍历顺序表：

int SequenceTraverse(SeList l, void (*p)(ElemType))
{
	if (p == NULL)
	{	
		return FAILURE;
	}
	int i;

	for (i = 0; i < l.length; i++)
	{
		p(l.data[i]);
	}

	return SUCCESS;
}

下面是测试的主函数：

#include "SequenceList.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void print(ElemType e)
{
	printf("%d ", e);
}

int Equal(ElemType e1, ElemType e2)
{
	return (e1 == e2) ? TRUE : FALSE;
}

int main()
{
	int ret, i;
	SeList list;

	srand(time(NULL));

	ret = SequenceInit(&list);
	if (ret == SUCCESS)
	{
		printf("Init Success!\n");
	}
	else 
	{
		printf("Init Failure!\n");
	}

	for (i = 0; i < 8; i++)
	{
		ret = SequenceInsrt(&list, i + 1, rand() % 10);
		if (FAILURE == ret)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success!\n");
		}
	}

	ret = SequenceLength(list);
	printf("length is %d\n", ret);

	ret = SequenceEmpty(list);
	if (ret == TRUE)
	{
		printf("is empty!\n");
	}
	else
	{
		printf("not empty!\n");
	}

	int p = 3;   //位置
	ElemType e;
	ret = GetElem(list, p, &e);
	if (FAILURE == ret)
	{
		printf("Get Element Failure!\n");
	}
	else
	{
		printf("%dth element is %d\n", p, e);
	}

	ret = SequenceTraverse(list, print);   //顺序表遍历
	if (ret == FAILURE)
	{
		printf("Traerse Failure!\n");
	}
	else
	{
		printf("Traverse Success!\n");
	}

	e = 3;
	ret = LocateElem(list, e, Equal);
	if (ret == FAILURE)
	{
		printf("%d not exist!\n", e);
	}
	else
	{
		printf("%d is %dth element!\n", e, ret);
	}

	p = 3;
	ret = SequenceDelete(&list, p, &e);
	if (SUCCESS == ret)
	{
		printf("Delete %d Success!\n", e);
	}
	else
	{
		printf("Delete Failure!\n");
	}

	ret = SequenceTraverse(list, print);   //顺序表遍历
	if (ret == FAILURE)
	{
		printf("Traerse Failure!\n");
	}
	else
	{
		printf("Traverse Success!\n");
	}

	ret = SequenceClear(&list);
	if (SUCCESS == ret)
	{
		printf("Clear Success!\n");
	}
	else
	{
		printf("Clear Failure!\n");
	}
		
	ret = SequenceTraverse(list, print);   //顺序表遍历
	if (ret == FAILURE)
	{
		printf("Traerse Failure!\n");
	}
	else
	{
		printf("Traverse Success!\n");
	}

	ret = SequenceDestroy(&list);
	if (SUCCESS == ret)
	{
		printf("Destroy Success!\n");
	}
	else
	{
		printf("Destroy Failure!\n");
	}

	for (i = 0; i < 8; i++)
	{
		ret = SequenceInsrt(&list, i + 1, rand() % 10);
		if (FAILURE == ret)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success!\n");
		}
	}

	return 0;
}