线性表（C语言版）

1、头文件

#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

头文件的这种格式是为了避免重复包含文件

2、线性表的增、删、改、查、遍历、初始化

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

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

int SequenceLength(SeList l)
{
	return l.length;
}

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

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

	*e = l.data[p - 1];
	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;
}

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

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 SequenceClear(SeList *l)
{
	if (l == NULL)
	{
		return FAILURE;
	}
	
	l->length = 0;

	return SUCCESS;
}

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

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

	return SUCCESS;
}

3、测试函数

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