2.数据结构--线性表之链表实现

#include<iostream>
using namespace std;

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

typedef struct LNode {
	int data; //结点的数据域
	struct LNode *next; //结点的指针域
} LNode, *LinkList; //LinkList为指向结构体LNode的指针类型

Status InitList_L(LinkList &L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}

Status DestroyList_L(LinkList &L)
{
	LinkList p;
	while (L)
	{
		p = L;
		L = L->next;
		delete p;
	}
	return OK;
}

Status ClearList_L(LinkList &L)
{
	// 将L重置为空表 
	LinkList p = L->next;   //p指向第一个结点
	while (p)       //没到表尾 
	{
		LinkList q = p->next; 
		delete p;     
		p = q;
	}
	L->next = NULL;   //头结点指针域为空 
	return OK;
}

int ListLength_L(LinkList L)
{
	//返回L中数据元素个数
	LinkList p;
	p = L->next;  //p指向第一个结点
	int i = 0;
	while (p)
	{//遍历单链表,统计结点数
		i++;
		p = p->next;
	}
	return i;
}

int ListEmpty_L(LinkList L)
{
	//若L为空表，则返回1，否则返回0 
	if (L->next)   //非空 
		return 0;
	else
		return 1;
}

Status GetElem_L(LinkList L, int i, ElemType &e)
{
	LinkList p = L->next; 
	int j = 1; //初始化
	while (p && j<i){	//向后扫描，直到p指向第i个元素或p为空 
		p = p->next; 
		++j;
	}
	if (!p || j>i)return ERROR; //第i个元素不存在 
	e = p->data; //取第i个元素 
	return OK;
}

// LinkList LocateELem_L(LinkList L,ElemType e)
// {
// 	//返回L中值为e的数据元素的地址，查找失败返回NULL
// 	LinkList p = L->next;
// 	while (p && p->data != e)
// 		p = p->next;
// 	return p;
// }
// 
// int LocateELem_L(LinkList L,ElemType e) {
// 	//返回L中值为e的数据元素的位置序号，查找失败返回0 
// 	LinkList p = L->next; 
// 	int 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)
{
	LinkList p = L; 
	int j = 0;
	while (p && j< i-1)//寻找第i−1个结点 
	{ 
		p = p->next;
		++j; 
	}	
	if (!p || j>i-1)  return ERROR;	//i大于表长 + 1或者小于1  
	LinkList s = new LNode;			//生成新结点s 
	s->data = e;      		           //将结点s的数据域置为e 
	s->next = p->next;	   	          //将结点s插入L中 
	p->next = s;
	return OK;
}//ListInsert_L 

//将线性表L中第i个数据元素删除
Status ListDelete_L(LinkList &L, int i, ElemType &e)
{
	LinkList p = L; 
	int j = 0;
	while (p->next &&j < i - 1){//寻找第i个结点，并令p指向其前驱 
		p = p->next; 
		++j;
	}
	if (!(p->next) || j>i - 1) return ERROR; //删除位置不合理 
	LinkList q = p->next; //临时保存被删结点的地址以备释放 
	p->next = q->next; 	//改变删除结点前驱结点的指针域 
	e = q->data; 	//保存删除结点的数据域 
	delete q; 	//释放删除结点的空间 
	return OK;
}//ListDelete_L 

void CreateList_F(LinkList &L, int n)
{
	L = new LNode;
	L->next = NULL; //先建立一个带头结点的单链表 
	for (int i = n; i > 0; --i){
		LinkList p = new LNode; //生成新结点 
		cin >> p->data; //输入元素值 
		p->next = L->next; 
		L->next = p; 	//插入到表头 
	}
}//CreateList_F 

void CreateList_L(LinkList &L, int n)
{
	//正位序输入n个元素的值，建立带表头结点的单链表L 
	L = new LNode;
	L->next = NULL;
	LinkList r = L; 	//尾指针r指向头结点 
	for (int i = 0; i < n; ++i)
	{
		LinkList p = new LNode;
		cin >> p->data;   		//输入元素值 
		p->next = NULL; 
		r->next = p; 	    	//插入到表尾 
		r = p; 	//r指向新的尾结点 
	}
}//CreateList_L 

void PrintOut(LinkList L)
{
	LinkList P = L->next;
	while (P)
	{
		cout << P->data << " ";
		P = P->next;
	}
	cout << endl;
}

/************************************************************************/
/* 两个非递减的有序链表合并为一个非递减的有序链表，表中允许有重复数字      */
/************************************************************************/
void MergeList_1(LinkList &La, LinkList &Lb, LinkList &Lc) 
{
	LinkList pa = La->next;
	LinkList pb = Lb->next;
	LinkList 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的头结点
}

/************************************************************************/
/* 两个非递减的有序链表合并为一个非递减的有序链表，表中不允许有重复数字      */
/************************************************************************/
void MergeList_2(LinkList &La, LinkList &Lb, LinkList &Lc)  //归并元素，不允许有重复的元素
{
	LinkList pa = La->next;
	LinkList pb = Lb->next;
	LinkList pc = Lc = La;             //用La的头结点作为Lc的头结点 
	while (pa && pb)
	{
		if (pa->data < pb->data)
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else if (pa->data == pb->data)
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;

			LinkList Tmp = pb; //删除LB中和LA重复的元素
			pb = pb->next;
			delete Tmp;
		}
		else
		{
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;    //插入剩余段  
	delete Lb;             //释放Lb的头结点
}

/************************************************************************/
/* 两个非递减的有序链表合并为一个非递增的有序链表，表中允许有重复数字      */
/************************************************************************/
void MergeList_3(LinkList &La, LinkList &Lb, LinkList &Lc)
{
	LinkList pa = La->next;
	LinkList pb = Lb->next;
	LinkList pc = Lc = La;             //用La的头结点作为Lc的头结点 
	Lc->next = NULL;

	while (pa && pb)
	{
		if (pa->data <= pb->data)
		{
			LinkList pa_next = pa->next;
			pa->next = Lc->next;
			Lc->next = pa;
			pa = pa_next;
		}
		else
		{
			LinkList pb_next = pb->next;
			pb->next = Lc->next;
			Lc->next = pb;
			pb = pb_next;
		}
	}
	
	//插入剩余段
	while (pa)
	{
		LinkList pa_next = pa->next;
		pa->next = Lc->next;
		Lc->next = pa;
		pa = pa_next;
	}

	while (pb)
	{
		LinkList pb_next = pb->next;
		pb->next = Lc->next;
		Lc->next = pb;
		pb = pb_next;
	}
	delete Lb;             //释放Lb的头结点
}



int main()
{
	LinkList L1,L2;
	InitList_L(L1);
	ListInsert_L(L1, 1, 3);
	ListInsert_L(L1, 2, 4);
	ListInsert_L(L1, 3, 8);
	PrintOut(L1);

	InitList_L(L2);
	ListInsert_L(L2, 1, 3);
	ListInsert_L(L2, 2, 4);
	ListInsert_L(L2, 3, 8);
	PrintOut(L2);

	LinkList L3;
	MergeList_3(L1, L2, L3);
	PrintOut(L3);
}