单链表的表示和实现 数据结构

欢迎访问我的新博客：http://www.milkcu.com/blog/

原文地址：

基本概念

链式存储结构，不要求逻辑上相邻的元素在物理上也相邻，没有顺序存储结构所具有的的弱点（在作插入或删除操作是，需移动大量元素），但同时也失去了顺序表可随机存取的优点。

单链表的结点由数据域和指针域构成，多个结点链结成一个链表。

代码实现

# include <stdio.h>
# include <stdlib.h>
# define OK 1
# define ERROR -1
# define OVERFLOW -2

typedef int ElemType;
typedef int Status;

typedef struct Lnode {
	ElemType data;
	struct Lnode * next;
} Lnode, * LinkList;

Status GetElem_L(LinkList L, int i, ElemType & e);
Status ListInsert_L(LinkList & L, int i, ElemType e);
Status ListDelete_L(LinkList & L, int i, ElemType & e);
void CreateList_L(LinkList & L, int n);
void MergeList_L(LinkList & La, LinkList & Lb, LinkList & Lc);
Status ShowList_L(LinkList L);

int main(void)
{
	//测试函数
	LinkList L;
	CreateList_L(L, 8);
	ShowList_L(L);    //print create
	ListInsert_L(L, 3, 3);
	ShowList_L(L);    //print insert
	ElemType e;
	ListDelete_L(L, 4, e);
	printf("delete e = %d\n", e);    //print e delete
	ShowList_L(L);    //print delete
	GetElem_L(L, 5, e);
	printf("getelem e = %d\n", e);    //print getelem
	LinkList Lb;
	CreateList_L(Lb, 5);
	ShowList_L(Lb);    //print Lb
	LinkList Lc;
	MergeList_L(L, Lb, Lc);
	ShowList_L(Lc);    //print Lc
	return 0;
}

Status GetElem_L(LinkList L, int i, ElemType & e)
{
	//算法2.8
	//L为带头结点的单链表的头指针
	Lnode * p = L->next;
	int j = 1;
	for(j = 1; p && j < i; j++) {
		p = p->next;
	}
	if(!p) {
		return ERROR;
	}
	e = p->data;
	return OK;
}

Status ListInsert_L(LinkList & L, int i, ElemType e)
{
	//算法2.9
	//在带头结点的单链线性表L中第i个位置之前插入元素e
	Lnode * p = L->next;
	int j = 1;
	Lnode * s = (Lnode * ) malloc(sizeof(Lnode));
	s->data = e;
	for(j =1; p && j < i - 1; j++) {
		p = p->next;
	}
	if(!p) {
		return ERROR;
	}
	s->next = p->next;
	p->next = s;
	return OK;
}

Status ListDelete_L(LinkList & L, int i, ElemType & e)
{
	//算法2.10
	Lnode * p = L->next;
	int j = 1;
	for(j = 1; p && j < i - 1; j++) {
		p = p->next;
	}
	if(!p) {
		return ERROR;
	}
	Lnode * q;
	q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return OK;
}

void CreateList_L(LinkList & L, int n)
{
	//算法2.11
	//逆位序输入n个元素的值，建立带表头结点的单链线性表L
	L = (LinkList) malloc(sizeof(Lnode));
	L->next = NULL;
	for(int i = 0; i < n; i++) {
		Lnode * p = (Lnode * ) malloc(sizeof(Lnode));
		scanf("%d", & p->data);
		p->next = L->next;
		L->next = p;
	}
}

void MergeList_L(LinkList & La, LinkList & Lb, LinkList & Lc)
{
	//算法2.12
	//归并非递减排列的La和Lb到Lc
	//用La的头结点作为Lc的头结点
	//本算法具有副作用 
	Lnode * pa = La->next;
	Lnode * pb = Lb->next;
	Lc = La;
	Lnode * pc = Lc;
	while(pa && pb) {
		if(pa->data <= pb->data) {
			pc->next = pa;
			pc = pc->next;
			pa = pa->next;
		} else {
			pc->next = pb;
			pc = pc->next;
			pb = pb->next;
		}
	}
	pc = (pa ? pa : pb);
	free(Lb);
}

Status ShowList_L(LinkList L)
{
	Lnode * p = L->next;
	if(!p) {
		return ERROR;
	}
	while(p) {
		printf("%d  ", p->data);
		p = p->next;
	}
	putchar('\n');
	return OK;
}

算法分析

GetElem_L()、ListInsert_L()、ListDelete_L()的时间复杂度均为O(n)。

对于算法2.9的ListInsert_L()也可通过下面改进算法实现，该算法对于在单链表中指定结点前插入结点比较实用（时间复杂度为O(1)），代码如下：

Status ListInsert_L(LinkList & L, int i, ElemType e)
{
	//算法2.9改进版
	//在带头结点的单链线性表L中第i个位置之前插入元素e
	Lnode * p = L->next;
	int j = 1;
	Lnode * s = (Lnode * ) malloc(sizeof(Lnode));
	for(j = 1; p && j < i; j++) {
		p = p->next;
	}
	if(!p) {
		return ERROR;
	}
	//最终目的是在p前插入s 
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
}

对于算法2.10的ListDelete_L()也可通过下面函数实现，该算法对在于单链表中删除指定结点比较实用（时间复杂度为O(1)），代码如下：

Status ListDelete_L(LinkList & L, int i, ElemType & e)
{
	//算法2.10改进版
	//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
	//未引入临时变量
	Lnode * p = L->next;
	int j = 1;
	for(j = 1; p && j < i; j++) {
		p = p->next;
	}
	if(!p) {
		return ERROR;
	}
	e = p->data;
	p->data = p->next->data;
	p->next = p->next->next;
	free(& p->next);
	return OK;
}

其实上面两个改进算法，在填空选择中经常用到。

参考资料

• 《数据结构：C语言版》（严蔚敏，吴伟民编著）

（全文完）