数据结构基本操作学习

链表笔记

点击查看代码

#include <stdio.h>
#include <stdlib.h>

#define OK 1

// 定义单链表节点结构
typedef struct LNode {
	ElemType data;				// 数据域，这里假设存储整型数据
	struct LNode* next;		// 指针域，指向下一个节点
}LNode,*LinkList;


// 初始化单链表的函数
Status InitList_L(LinkList& L) {
	L = new LNode;	// 或 L=(LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	return OK;
}

// 判断链表是否为空
int ListEmpty(LinkList L) {
	if (L->next)	// 非空
		return 0;
	else
		return 1;
}

// 销毁单链表
Status DestroyList_L(LinkList& L) {
	Lnode* p;
	while (L) {
		p = L;
		L = L->next;
		delete p;
	}
	return OK;
}

// 清空单链表
Status ClearList_L(LinkList& L) {
	Lnode* p, * q;
	p = L->next;
	while (p) {
		q = p->next;
		delete p;
		p = q;
	}
	L->next = NULL;		// 头结点指针域为空
	return OK;
}

// 求单链表表长
int ListLength_L(LinkList& L) {
	LNode* p;	// 表示指向单链表中一个结点的一个指针
	p = L->next;	// p指向首元结点
	int i = 0;
	while (p) {		// 遍历单链表，统计结点数
		++i;
		p = p->next;
	}
	return i;
}

// 取值——取单链表中第i个元素的内容
Status GetElem_L(LinkList& L,int i,ElemType &e) {
	p = L->next;	// p指向首元结点
	j = 1;
	while (p&&j<i) {		// 遍历单链表，统计结点数
		p = p->next;
		++j;
	}
	if (!p || j > i) {
		return ERROR;
	}
	e = p->data;
	return OK;
}

// 按值查找——根据指定数据获取该数据所在的位置（地址）
LNode* LocateElem_L(LinkList L, ElemType e) {
	//在线性表L中查找值为e的数据元素
	//找到，贝则返回L中值为e的数据元素的地址，查找失败返回NULL
	p = L->next;
	while (p && p->data != e) {
		//++i;
		p = p->next;
	}
	return p;
}

int LocateElem_L(LinkList L, Elemtype e) {
	//返回L中值为e的数据元素的位置序号，查找失败返回0
	p = L->next;
	j = 1;
	while (p && p->data != e) {
		p = p->next;
		j++;
	}
	if (p) {
		return j;
	}
	else {
		return 0;
	}
}

// 插入操作
Status ListInsert_L(LinkList& L, int i, ElemType e) {
	p = L, j = 0;
	while (p && j < i - 1) {
		p = p->next;
		++j;
	}
	if (!p || j > i--1) {
		return ERROR;
	}
	s = new LNode;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}

// 删除第i个结点
Status ListDelete_L(LinkList& L, int i) {
	p = L, j = 0;
	while (p->next && j < i - 1) {
		p = p->next;
		++j;
	}
	if (!p || j > i-1) {
		return ERROR;
	}
	q = p->next;
	p->next = p->next->next;
	e = q->data;
	delete p->next;
	return OK;
}

// 头插法建立单链表
void CreateList_H(Link& L, int n) {
	L = new LNode;
	L->next = NULL;
	for (i = n; i > 0; --i) {
		p = new LNode;
		cin >> p->data;
		p->next = L->next;
		L->next = p;
	}
}

// 尾插法建立单链表
void CreateList_R(LinkList& L, int n) {
	L = new LNode;
	L->next = NULL;
	r = L;
	for (i = 0; i < n; ++i) {
		p = new LNode;
		cin >> p->data;
		p->next = NULL;
		r->next = p;	// 插入到表尾
		r = p;	// r指向新的尾结点
	}
}

// 两个循环链表合并 时间复杂度O(1)
LinkList Connect(LinkList Ta, LinkList Tb) {
	p = Ta->next;
	Ta->next = Tb->next->next;
	delete Tb->next;
	Tb->next = p;
	return Tb;		
}

// 双向链表
typedef struct DuLNode {
	Elemtype data;
	struct DulNode* prior, * next;
}NuLNode,*DuLinkList;
// 插入
void ListInsert_DuL(DuLinkList& L, int i, ElemType e) {
	if (!(p = GetElemP_DuL(L, i))) return ERROR;
	s = new DuLNode;
	s->data = e;
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return OK;
}
// 删除
void ListDelete_DuL(DuLink& L, int i, ElemType& e) {
	if (!(p = GetElemP_DuL(L, i))) {
		return ERROR;
	}
	e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return OK;
}

// 线性表的合并(相同值的元素不重复添加)
void union(List& La, ListLb) {
	La_len = ListLength(La);
	Lb_len = ListLength(Lb);
	for (i = 1; i <= Lb_len; i++) {
		GetElem(Lb, i, e);
		if (!LocateElem(La, e)) {
			ListInsert(&La, ++La__len, e);
		}
	}
}
// 有序表合并（相同元素重复添加）
void union(List& La, ListLb) {

	La_len = ListLength(La);
	Lb_len = ListLength(Lb);
	for (i = 1; i <= Lb_len; i++) {
		GetElem(Lb, i, e);
		if (!LocateElem(La, e)) {
			ListInsert(&La, ++La__len, e);
		}
	}
}
//用顺序表实现两个有序表合并，并按非递减的顺序排列
void MergeList_Sq(SqList LA, SqList LB, SqList& LC) {
	pa = LA.elem;	// 指针pa和pb的初值分别指向两个表的第一个元素
	pb = LB.elem;	
	LC.length = LA.length + LB.length;//新表长度为带合并两表的长度之和
	LC.elem = new ElemType[LC.length];//为合并后的新表分配一个数组空间
	pc = LC.elem;	// 指针pc指向新表的第一个元素
	pa_last = LA.elem + LA.length - 1;//指针pa_last指向LA表的最后一个元素
	pb_last = LB.elem + LB.length - 1;
	while (pa <= pa_last && pb <= pb_last) {//两个表都非空
		if (*pa <= *pb) {	// 依次"摘取"两表中值较小的结点
			*pc++ = *pa++;
		}
		else {
			*pc++ = *pb++;
		}
	}
	while (pa <= pa_last) {
		*pc++ = *pa++;	//LB表已到达表尾，将LA中剩余元素加入LC
	}
	while (pb <= pb_last) {
		*pc++ = *pb++;	//LA表已到达表尾，将LB中剩余元素加入LC
	}
}
//用链表实现两个有序表合并，并按非递减的顺序排列
void MergeList_L(SqList La, SqList Lb, SqList& Lc) {
	pa = La->next;
	pb = Lb->next;
	pc = Lc = La;	// 用La的头结点作为Lc的头结点
	while (pa && pb) {
		if (pa->data <= pb->data) {
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else {
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;	// 插入剩余段
	delete Lb;	// 释放Lb的头结点
}

案例分析1 一元多项式的运算：实现两个多项式加、减、乘运算