链表的表示和实现

include<iostream>
using namespace std;
typedef struct Lnode
{
	int data;
	struct Lnode* next;
}Lnode, * Linklist;//单链表和循环链表结点结构
typedef struct duLnode
{
	int data;
	struct duLnode* prior, * next;
}duLnode, * duLinklist;//双向链表结点结构
typedef struct SqLnode
{
	int* elem;
	int length;
}sqlist;//顺序表结点结构
typedef struct duox
{
	int expn;
	int data;
	struct duox* next;
}duox, * linklist;
bool lnitList(Linklist& L)
{
	L = new Lnode;
	L->next = NULL;
	return 1;
}
bool destroylist(Linklist& L)
{
	Lnode* p;
	while (L)
	{
		p = L;
		L = L->next;
		delete p;
	}
	return 1;
}
bool clearlist(Linklist& L)
{
	Lnode* p, * q;
	p = L->next;
	while (p)
	{
		q = p->next;
		delete p;
		p = q;
	}
	L->next = NULL;
	return 1;
}
int listLength(Linklist& L)
{
	Lnode* p;
	p = L->next;
	int i = 0;
	while (p)
	{
		i++;
		p = p->next;
	}
	return i;
}
bool Getelem(Linklist& L, int i, int& e)
{
	Lnode* p;
	p = L->next;
	int j = 1;
	if (p && j < i)
	{
		j++;
		p = p->next;
	}
	if (!p || j > i)
	{
		return 0;
	}
	e = p->data;
	return 1;
}
int locateelem(Linklist& L, int e)
{
	Lnode* p;
	p = L->next;
	int j = 1;
	while (e != p->data && p)
	{
		j++;
		p = p->next;
	}
	if (!p)
	{
		return 0;
	}
	return j;
}
Lnode* Locateelem(Linklist L, int e)
{
	Lnode* p;
	p = L->next;
	while (e != p->data && p)
	{
		p = p->next;
	}
	return p;
}
bool listinsert(Linklist& L, int i, int e)
{
	Lnode* p;
	p = L;
	int j = 0;
	while (p && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i - 1)
	{
		return 0;
	}
	Lnode* s = new Lnode;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return 1;
}
bool listdelete(Linklist& L, int i, int& e)
{
	Lnode* p;
	p = L;
	int j = 0;
	while (j < i - 1 && p->next)
	{
		p = p->next;
		j++;
	}
	if (j > i - 1 || !p->next)
	{
		return 0;
	}
	Lnode* q;
	q = p->next;
	p->next = q->next;
	delete q;
	return 1;
}
void createlist_h(Linklist& L, int n)
{
	L = new Lnode;
	L->next = NULL;
	for (int i = 0;i < n;i++)
	{
		Lnode* p;
		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;
	Lnode* r = L;//尾结点初始化
	Lnode* p;
	for (int i = 0;i < n;i++)
	{
		p = new Lnode;
		p->next = NULL;
		cin >> p->data;
		r->next = p;
		r = p;
	}
}
Linklist connect(Linklist Ta, Linklist Tb)//两个单链表（循环链表）合并
{
	Lnode* p = Ta->next;
	Ta->next = Tb->next->next;
	delete Tb->next;
	Tb->next = p;
	return Tb;
}
duLnode* getelem_dul(duLinklist L, int i)//在带头结点的双向循环链表L中获取第i个结点的地址
{
	duLnode* p;
	p = L->next;
	int j = 1;
	while (p && j < i)
	{
		p = p->next;
	}
	if (!p || j > i)
	{
		return NULL;
	}
	return p;
}
bool listinsert_duL(duLinklist& L, int i, int e)//在带头结点的双向循环链表L中第i个位置之前插入元素e
{
	duLnode* p;
	if (!(p = getelem_dul(L, i)))
	{
		return 0;
	}
	duLnode* s;
	s = new duLnode;
	s->data = e;
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return 1;
}
bool listdelete_dul(duLinklist& L, int i, int& e)
{
	duLnode* p;
	if (!(p = getelem_dul(L, i)))
	{
		return 0;
	}
	e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	delete p;
	return 1;
}
void Union(Linklist La, Linklist Lb)//线性表合并
{
	int e;
	int La_len = listLength(La);
	int Lb_len = listLength(Lb);
	for (int i = 1;i <= Lb_len;i++)
	{
		Getelem(Lb, i, e);
		if (locateelem(La, e))
		{
			listinsert(La, ++La_len, e);
		}
	}


}
void merge_Sq(sqlist La, sqlist Lb, sqlist& Lc)
{
	int* pa = La.elem;
	int* pb = Lb.elem;
	Lc.length = La.length + Lb.length;
	Lc.elem = new int[Lc.length];
	int* pc = Lc.elem;
	int* pa_last = La.elem + La.length - 1;
	int* 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++;
	}
	while (pb <= pb_last)
	{
		*pc++ = *pb++;
	}
}//有序顺序表合并
void merge_L(Linklist& La, Linklist& Lb, Linklist& Lc)
{
	Lnode* pa = La->next;
	Lnode* pb = Lb->next;
	Lnode* pc = Lc = La;
	while (pa && pb)
	{
		if (pa->data <= pb->data)
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else
		{
			pc->next = pa;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;
	delete Lb;
}//有序表合并用链表
void plus_duox(linklist& La, linklist& Lb, linklist& Lc)
{
	duox* pa, * pb, * pc, * sup;
	pa = La->next;
	pb = Lb->next;
	pc = Lc = La;
	while (pa && pb)
	{
		if (pa->expn < pb->expn)
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else
			if (pa->expn > pb->expn)
			{
				pc->next = pb;
				pc = pb;
				pb = pb->next;
			}
			else
				if (pa->expn == pb->expn)
				{
					if (pa->data + pb->data == 0)
					{
						sup = pa;
						pa = pa->next;
						delete sup;
						sup = pb;
						pb = pb->next;
						delete sup;
					}
					else
					{
						sup = pb;
						pa->data = pa->data + pb->data;
						pc->next = pa;
						pc = pa;
						pa = pa->next;
						pb = pb->next;
						delete sup;
					}
				}
	}
	pc->next = pa ? pa : pb;
	delete Lb;
}//多项式合并
void createduox(linklist& L, int n)
{
	L = new duox;
	L->next = NULL;
	duox* s, * r, * pre;
	for (int i = 0;i < n;i++)
	{
		s = new duox;
		cin >> s->data >> s->expn;
		pre = L;
		r = L->next;
		while (r && r->expn < s->expn)
		{
			pre = r;
			r = r->next;
		}
		s->next = r;
		pre->next = s;
	}
}//多项式链式线性表升序建立
void printduox(linklist& L)
{
	duox* p = L->next;
	while (p)
	{
		cout << p->data << endl;
		p = p->next;
	}
	cout << "ok";
}//多项式输出


int main()
{
	linklist La, Lb, Lc;
	createduox(La, 2);
	createduox(Lb, 2);
	plus_duox(La, Lb, Lc);
	printduox(Lc);
	return 0;
}