数据结构链表练习题1（基础篇）

题目要求：

1. 构造单链表 La(25, 12, 78, 34, 100, 88) 和单链表Lb(88, 10, 15, 25, 32)
2. 将数据元素38插入单链表La中第i(i=3)个结点之后，然后输出单链表
3. 删除单链表Lb中第第i(i=4)个结点并返回其值，然后输出单链表
4. 查找单链表La中与100相等的元素，若找到返回指向该元素的指针
5. 将单链表La和Lb合并存储于La中，对值相同的数量元素只保留一个，合并后不保留Lb。要求输出合并后的单链表。

代码实现：

#define OK 1
#define ERROR 0
typedef int ElemType;

#include <iostream>
#include <iomanip>
#include <stdlib.h>
using namespace std;

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

int InitList_L(LinkList& L)
{
	L = new LNode;
	if (!L) exit(OVERFLOW);
	L->next = NULL;
	return OK;
}

int CreateList_L(LinkList& L, int n, ElemType* arr)
{
	L = new LNode;
	L->next = NULL;

	for (int i = n-1; i >=0; i--)
	{
		LNode* p = new LNode;
		p->data = arr[i];
		p->next = L->next;
		L->next = p;
	}
	return OK;
}

void OutputList_L(LinkList& L)
{
	LNode* p = L->next;

	if (!p) { cout << "空链表" << endl; return; }
	while (p) {
		cout << setw(6) << setfill(' ') << p->data;
		p = p->next;
	}
	cout << endl;
}

int InsertElem_L(LinkList& L, int i, ElemType e)
{
	LNode* p =L;
	int j = 0;

	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i) return ERROR;
	
	LNode* S=new LNode;
	S->data = e;
	S->next = p->next;
	p->next = S;

	return OK;
}

int DeleteElem_L(LinkList& L, int i, ElemType& e)
{
	LNode* p = L;
	ElemType j = 0;

	while (p->next && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i - 1)  return ERROR;

	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	delete q;

	return e;
}

//求链表的长度
int ListLength(LinkList L)
{
	LNode* p = L->next;
	int i = 0;
	while (p)
	{
		p = p->next;
		i++;
	}
	return i;
}

LNode* GetElem_L(LinkList L, int value, int length)
{
	LNode* p = L->next;
	ElemType j = 0;

	while (p && j < length - 1)
	{
		p = p->next;
		j++;
	}
	if (!p && j > length) return ERROR;

	return p;
}

int LocateList_L(LinkList L, LNode* q)
{
	LNode* p = L->next;
	while (p)
	{
		if (q->data == p->data)
			return 0;
		p = p->next;
	}
	return OK;
}
void InsertList_L(LinkList& L, LNode* q)
{
	LNode* p = L->next;
	LNode* node = new LNode;  //建立一个新结点存储数据
	node->data = q->data;
	node->next = NULL;

	while (p->next)
		p = p->next;
	p->next = node;
}//边比较边插入
void MergeList_L(LinkList& La, LinkList& Lb)
{
	LNode* pb = Lb->next;  lb的第一个元素开始遍历
	while (pb)
	{
		if (LocateList_L(La, pb))  //判断lb在la里边有没有相等的，有就返回0，没有就开始插入单个元素
			InsertList_L(La, pb);  //插入元素
		pb = pb->next;
	}
	delete Lb;
}	
//先删除Lb中与La中相等的元素，再归并
	//LNode* pa = La->next;
	//while (pa)
	//{
	//	LNode* pb = Lb;
	//	while (pb->next!=NULL)  //判断pb指向下一个元素的地址是否为空，
	//	{						//原因在于pb得指向要删除元素的前一个元素的地址
	//		if (pb->next->data == pa->data)
	//		{
	//			LNode* q = pb->next;  //如果pb指向的下一个元素的值与La中的相同，
	//			pb ->next= q->next;
	//			delete q;  //删去
	//		}
	//		else pb = pb->next;
	//	}
	//	if (pa->next == NULL)//如果p指向La中最后一个元素的地址，
	//		break;			//直接退出循环，避免再次指向NULL，造成后续无法直接将Lb归并到La
	//	pa = pa->next;
	//}
	//pa->next = Lb->next;
	//delete Lb;

int DestoryList_L(LinkList& L)
{
	LNode* p = L;
	while (L)
	{
		p = L;
		L = L->next;
		delete p;
	}
	return OK;
}

int main()
{
	ElemType e;
	ElemType a[6] = { 25, 12, 78, 34, 100, 88};
	ElemType b[5] = { 88, 10, 15, 25, 32 };

	LinkList La, Lb;

	//构造空单链表
	InitList_L(La);
	InitList_L(Lb);

	//创建含有n个元素的单链表
	CreateList_L(La, 6, a);
	cout << "链表a已成功被创建！" << endl;
	OutputList_L(La);
	CreateList_L(Lb, 5, b);
	cout << "链表b已成功被创建！" << endl;
	OutputList_L(Lb);

	//在链表的第三个元素后插入38
	if(InsertElem_L(La, 3, 38))
		cout << "插入的元素后的表为：" << endl;
	OutputList_L(La);

	//删除位序为4的元素
	if (DeleteElem_L(Lb, 4, e))
		cout << "删去位序为4的元素后表为：" << endl;
	OutputList_L(Lb);
	
	//查找La中值为100的元素，返回其指针
	cout << "元素100的在内存空间地址为：" << GetElem_L(La, 100, ListLength(La)) << endl;

	//保留La的合并操作
	MergeList_L(La, Lb);
	cout << "合并后的链表为：" << endl;	
	OutputList_L(La);

	//销毁链表
	DestoryList_L(La);
	cout << "链表a成功被销毁！" << endl;

	return OK;
}

实验结果：