C语言数据结构（1）——线性表

线性表的顺序存储结构

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 1000

typedef int ElemType;
typedef int Status;

typedef struct
{
	ElemType data[MAXSIZE];
	int length;
}Sqlist;

获得元素操作

Status GetElem(Sqlist L, int i, ElemType* e)
{
	if (L.length == 0 || i<1 || i>L.length)	//如果为空表或i不在正常范围内 抛出异常
		return ERROR;
	*e =L.data[i - 1];	//获得元素
	return OK;
}

插入操作

Status ListInsert(Sqlist* L,int i, ElemType e)
{
	int k;
	if (L->length == MAXSIZE)	//	如果插入位置不合理 抛出异常
		return ERROR;
	if (i<1 || i>L->length + 1)	//如果i不在范围内 抛出异常
		return ERROR;
	if (i <= L->length)	//如果插入数据的位置不在表尾
	{
		for (k = L->length - 1; k >= i - 1; k--)
		{
			L->data[k + 1] = L->data[k];	//将要插入位置后的数据元素向后移动一位
		}
	}
	L->data[i - 1] = e;	//插入新元素
	L->length++;	//更新表长度
	return OK;	
}

删除操作

//删除L的第i个元素，并用e返回其值
Status ListDelete(Sqlist* L, int i, ElemType* e)
{
	int k;
	if (L ->length == 0)	//如果表为空 抛出异常
		return ERROR;
	if (i<1 || i>L->length)		//如果删除位置不在正确范围内 抛出异常
		return ERROR;
	//对可能出错情况判断结束，开始进行删除操作

	*e = L->data[i - 1];
	if (i < L->length)	//如果删除的不是最后一个元素 
	{
		for (k = i; k < L->length;k++)
		{
			L->data[k - 1] = L->data[k];	//将删除位置后继元素前移
		}
	}
	L->length--;	//更新表的长度
	return OK;
}

线性表的链式存储结构

typedef struct Node
{
	ElemType data;
	struct Node* next;
}Node;
typedef struct Node* LinkList;

单链表的读取

//用e返回L中第i个数据的值
Status GetElem(LinkList L, int i, ElemType* e)
{
	int j;
	LinkList p;
	p = L->next;	//让p指向链表L的第一个节点
	j = 1;	//计数器
	while (p && j < i)	//p不为空且计数器j还没有等于i时，循环继续
	{
		p = p->next;	//p指向下一个节点
		++j;
	}
	if (!p || j > i)	//如果第i个节点不存在 抛出异常
		return ERROR;
	*e = p->data;	//取出第i个节点的数据
	return OK;
}

单链表的插入

//在L中第i个节点位置之前插入新的数据元素e
Status ListInsert(LinkList *L, int i, ElemType e)
{
	int j;
	LinkList p, s;
	p = *L;
	j = 1;
	while (p && j < i)	//寻找第i个节点
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)
		return ERROR;	//第i个节点不存在
	s = (LinkList)malloc(sizeof(Node));	//生成新节点
	s->data = e;	//插入e

	s->next = p->next;	//将p的后继节点赋值给s的后继
	p->next = s;	//将s赋值给p的后继节点

	return OK;
}

单链表的删除操作

//删除L的第i个节点 并用e返回其值
Status ListDelete(LinkList* L, int i, ElemType* e)
{
	int j;
	LinkList p, q;
	p = *L;
	j = 1;
	while (p->next && j < i)	//寻找第i个节点
	{
		p = p->next;
		++j;
	}

	if (!(p->next) || j > i)	//第i个节点不存在
		return ERROR;
	q = p->next;	//将与删除的节点p->next赋值给q
	p->next = q->next;	//标准删除语句
	*e = q->data;
	free(q);
	return OK;
}

头插法

void CreateListHead(LinkList* L,int n)
{
	LinkList p;
	int i;
	//srand((unsigned)time(NULL));
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;	//先建立一个带头节点的单链表
	for (i = 0; i < n; i++)
	{
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		p->next = (*L)->next;
		(*L)->next = p;		//插入到表头
	}
}

尾插法

void CreateListTail(LinkList* L, int n)
{
	LinkList  p, r;
	int i;
	*L = (LinkList)malloc(sizeof(Node));
	r = *L;
	for (i = 0; i < n; i++)
	{
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		r->next = p;
		r = p;
	}
	r->next = NULL;
}

单链表的整表删除

//单链表的整表删除
Status ClearList(LinkList* L)
{
	LinkList p, q;
	p = (*L)->next;
	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;
	return OK;
}

静态链表

typedef struct
{
	ElemType data;
	int cur;
}Component,StaticLinkList[MAXSIZE];

模拟malloc

int Malloc_SLL(StaticLinkList space)
{
	int i = space[0].cur;

	if (space[0].cur)
	{
		space[0].cur = space[i].cur;
	}

	return i;
}

模拟free

void Free_SSL(StaticLinkList  space, int k)
{
	space[k].cur = space[0].cur;
	space[0].cur = k;
}

初始化静态链表

Status InitList(StaticLinkList space)
{
	int i;
	for (i = 0; i < MAXSIZE - 1;i++)
	{
		space[i].cur = i + 1;
	}
	space[MAXSIZE - 1].cur = 0;	//最后一个元素的cur值为0
	/*
	for (i = 0; i < MAXSIZE - 1;i++)
	{
		if(i!=MAXSIZE-1)	space[i].cur = i + 1;
		else space[i].cur=0;
	}
	*/
	return OK;
}

获取静态链表中数据元素个数

int ListLength(StaticLinkList L)
{
	int j = 0;
	int i = L[MAXSIZE - 1].cur;
	while (i)
	{
		i = L[i].cur;
		j++;
	}
	return j;
}

静态链表的插入

//在L中第i个元素之前插入新的数据元素e
Status LinkInsert(StaticLinkList L, int i, ElemType e)
{
	int j, l, k;
	k = MAXSIZE - 1;
	if (i<1 || i>ListLength(L) + 1)
		return ERROR;
	j = Malloc_SLL(L);
	if (j)
	{
		L[j].data = e;
		for (l = 1; l <= i - 1; l++)
		{
			k = L[k].cur;
		}
		L[j].cur = L[k].cur;
		L[k].cur = j;
		return OK;
	}
	return ERROR;
}

静态链表的删除

//删除L中的第i个元素e
Status ListDelete(StaticLinkList L, int i)
{
	int j, k;
	if (i<1 || i>ListLength(L)) return ERROR;
	k = MAXSIZE - 1;
	for (j = 1; j <= i - 1; j++)
	{
		k = L[k].cur;
	}
	j = L[k].cur;
	L[k].cur = L[j].cur;
	Free_SSL(L, j);
	return OK;
}