数据结构——线性表

线性表（List）：零个或多个数据元素的有限序列

1.线性表的顺序存储结构——用一段地址连续的存储单元依次存储线性表的数据元素。

/*线性表顺序存储*/
#define MAXSIZE 20; /*存储空间初始分配量*/
typedef int ElemType;  /*ElemType 类型根据实际情况而定，这里假设为 int*/
typedef struct {
	ElemType data[MAXSIZE];  /*数组存储数据元素，最大值为 MAXSIZE*/
	int length;  /* 线性表当前长度*/
}SqList;	

/*插入*/
Status ListInsert(SqList *L, int i, ElemType e) {

	int k;

	if(L->length == MAXSIZE) {  /*已满*/
		return ERROR;
	}

	if(i < 1 || i > L->length) {  /*当要插入的位置不在范围内*/
		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;
}

/*删除*/
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];  /*将最后一个元素赋给e*/

	if(i < L->length) {  /*如果删除的位置不是在最后*/

		for(k = i; k < L->length; k++) {  /*将删除位置后继元素前移*/
			L->data[k - 1] = L-data[k];
		}
	}

	L->length--;  /*表长减一*/
	return OK;
}

2.线性表的链式存储结构

/*单链表*/
typedef struct Node {
	ElemType data;
	struct Node *next;
} Node;
typedef struct Node *LinkList;

/*单链表插入*/
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) {  /*第 i 个节点不存在*/
		return ERROR;
	}

	s = (LinkList)malloc(sizeof(Node));  /*生成新的节点*/

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

	return Ok;
}

/*单链表删除*/
Status ListDelete(LinkList *L, int i, ElemType *e) {

	int j;
	LinkList p, q;
	p = *L;
	j = 1;

	while(p->next && j < i) {  /*遍历寻找第 i - 1 个节点*/
		p = p->next;
		++j;
	}

	if(!(p->next) || j > i) {  /*第 i 个节点不存在*/
		return ERROR;
	}

	q = p->next;
	p->next = q->next;  /*将 q 的后继赋值给 p 的后继*/
	*e = q->data;  /*将 q  节点中的数据赋值给 e*/
	free(q);  /*回收此节点，释放内存*/

	return OK;
}

3.循环链表

单链表的尾指针为空；循环链表只需将 尾指针指向 头指针 即可。

判断 循环链表 是否为空，让 p->next 不等于头结点即可。

4.双向链表——在单链表的每个节点中，再设置一个指向其前驱节点的指针域。

/*双向链表*/
typedef struct DulNode {
	ElemType data;
	struct DulNode *prior;  /*直接前驱指针*/
	struct DulNode *next;  /*直接后继指针*/
}DulNode, *DuLinkList;

/*双向链表插入关键步骤*/
s->prior = p;
s->next = p->next;
p->next->prior = s;
p->next = s;

/*双向链表插入关键步骤*/
p->prior->next = p->next;
p->next->prior = p->prior;