c/c++单链表（严蔚敏）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/huxiaotong_exp/article/details/44729261

/*单链表，改进版，有头节点、尾指针和当前指针以及链表长度,归并排序*/ 
#include<stdlib.h> 
#include<stdio.h>
typedef int State;

typedef struct {
	int id;
}ElemType;

typedef struct LNode{
	ElemType data;
	struct LNode * next;
} *Link,*Position;

typedef struct{
	Link head,tail,current;
	int lenth;
} LinkList;

const int OK = 1;
const int ERROR = 0;
const int EQUAL = 1;
const int GREATER = 0; 
const int SMALLER = -1; 
const int FALSE = 0;
const int TRUE = 1;
 

/*基本操作*/ 
State makeNode(Link &p,ElemType e);
void freeNode(Link &p);
State initList(LinkList &L);
State destoryList(LinkList &L);
/*引用型操作*/
State isEmpty(LinkList &L);
int getLenth(LinkList &L);
State prior(LinkList &L);
State next(LinkList &L);
State getCurrentElem(LinkList &L,ElemType &e);
State locatePos(LinkList &L,int i);
State locateElem(LinkList &L,ElemType e,State (*compare)(ElemType a,ElemType b));
State travelList(LinkList &L,State (*visit)(Link node));
/*加工型操作*/
State deleteAfter(LinkList &L,ElemType &e); 
State insertAfter(LinkList &L,ElemType e);
State append(LinkList &L,ElemType e);
State setCurElem(LinkList &L,ElemType e);
State clearList(LinkList &L);
State compare(ElemType a,ElemType b);

State merge(LinkList La,LinkList Lb,LinkList &L,State (*cp)(ElemType a,ElemType b));

int main()
{
}
//归并排序
State merge(LinkList La,LinkList Lb,LinkList &L,State (*cp)(ElemType a,ElemType b))
{
	int len_a = La.lenth;
	int len_b = Lb.lenth;
	//如果至少有一张空表 
	if(len_a == 0)
	{
		L.head = Lb.head;
		L.current = Lb.current;
		L.lenth = Lb.lenth;
		L.tail = Lb.tail;
		return OK;
	}
	if(len_b == 0)
	{
		L.head = La.head;
		L.current = La.current;
		L.lenth = La.lenth;
		L.tail = La.tail;
		return OK;
	}
	//初始化
	initList(L);
	int a = 1;
	int b = 1; 
	La.current = La.head->next;
	Lb.current = Lb.head->next;
	ElemType ea,eb;
	while(a<=len_a && b<=len_b)
	{
		getCurrentElem(La,ea);
		getCurrentElem(Lb,eb);
		printf("%d %d ",ea.id,eb.id);
		State rel = (*cp)(ea,eb);
		if( rel == EQUAL || rel == GREATER)
		{
			append(L,eb);
			b++;
			next(Lb);
			printf(" Lb = %d \n",L.tail->data.id);
			
		}
		if(rel == SMALLER)
		{
			append(L,ea);
			a++;
			next(La);
			printf(" La = %d \n",L.tail->data.id);
		 }
	 } 
	 
	 if(a<=len_a)
	 {
	 	for(;a<=len_a;a++)
	 	{
	 		getCurrentElem(La,ea);
	 		append(L,ea);
	 		next(La);
	 		printf(" La = %d \n",L.tail->data.id);
		 }
	 }
	 
	 if(b<=len_b)
	 {
	 	for(;b<=len_b;b++)
	 	{
	 		getCurrentElem(Lb,eb);
	 		append(L,eb);
	 		next(Lb);
			 printf(" Lb = %d \n",L.tail->data.id);	 		
		 }
	 }
	 L.current = L.head->next;
	 for(int i = 0;i<L.lenth;i++)
	 {
		printf("The id = %d\n",L.current->data.id);
		next(L);
	  } 
	return OK;
 } 
//比较两个元素的值，这里比较元素的id 
State compare(ElemType a,ElemType b)
{
	if(a.id == b.id)
		return EQUAL;
	else if(a.id > b.id) 
		return  GREATER;
	else 
		return SMALLER;
}

/*在当前节点之后删除节点*/
State deleteAfter(LinkList &L,ElemType &e)
{
	if(L.current == L.tail)
		return ERROR;//当前节点为尾节点 ,并不能删除下一节点 
	Link temp = L.current->next;
	L.current->next = temp->next;
	e = temp->data;
	freeNode(temp);
	return OK;
}

/*在当前节点之后添加节点*/

State insertAfter(LinkList &L,ElemType e)
{
	Link node;
	if(!makeNode(node,e))
		return ERROR;//创建节点失败
	node->next = L.current->next;
	L.current->next = node;
	L.lenth++;
	return OK;		 
} 

/*在链表末尾添加元素*/
State append(LinkList &L,ElemType e)
{
	Link node ; 
	if(!makeNode(node,e))
		return ERROR;//创建节点失败
	L.tail->next = node;
	L.tail = L.tail->next;
	L.lenth++;
	return OK; 
}


/*设置当前链表元素的值*/
State setCurElem(LinkList &L,ElemType e)
{
	if(L.lenth == 0)
		return ERROR;//链表为空 
	L.current->data = e;
	return OK;
}

/*重置链表为空表*/
State clearList(LinkList &L)
{
	Link temp;
	L.current = L.head->next;
	while(L.current)
	{
		temp = L.current;
		L.current = L.current->next;
		freeNode(temp);
	}	
	L.current = L.head;
	L.lenth = 0;
	return OK;
} 

/*对线性表里面的每一个节点使用visit()方法*/
State travelList(LinkList &L,State (*visit)(Link node))
{
	if(L.lenth == 0)
		return ERROR;//链表为空 
	L.current = L.head->next;
	while(L.current)
	{
		(*visit)(L.current);
		L.current = L.current->next;
	}
	return OK;
} 

/*若表中存在满足compare（）条件的元素，当前节点指向满足条件的第一个节点*/
State locateElem(LinkList &L,ElemType e,State (*compare)(ElemType a,ElemType b))
{
		if(L.lenth == 0)
			return FALSE;//空表，并不存在任何元素 
		L.current = L.head->next;
		while(L.current)
		{
			if((*compare)(L.current->data,e))
				return	TRUE;//存在返回TRUE
			L.current = L.current->next; 
		}		
			return FALSE;//最后一个元素也不满足条件 ,并不存在元素 
} 

/*改变当前指针指向第i个节点*/
State locatePos(LinkList &L,int i)
{
	L.current = L.head;
	if(i<0||i>L.lenth)
		return ERROR;//i不再表长范围内 
	for(;i>=0;i--)
	{
		L.current = L.current->next;
	}
	return OK; 
}

/*返回当前指针所指元素*/
State getCurrentElem(LinkList &L,ElemType &e)
{
	if(isEmpty(L))
		return ERROR;//为空表
	if(!L.current) 
		return ERROR;//current不知道跑哪去了
	if(L.current == L.head)
		return ERROR;//current指向头节点 
	e = L.current->data; 
	return OK; 
}

/*改变当前指针指向后继*/
State next(LinkList &L)
{	
	if(!L.current->next)
		return ERROR;
	L.current = L.current->next;
	return OK; 
}

/*改变当前节点指向前面一个节点*/
State prior(LinkList &L)
{
	Link temp = L.head;
	while(temp->next != L.current)
	{
		temp = temp->next;
	}
	if(!temp->next)
		return ERROR;//当前指针不知道跑哪去了 
	L.current = temp;
	return OK;
}

/*求表长*/
int getLenth(LinkList &L)
{
	return L.lenth;
}

/*判断表空*/
State isEmpty(LinkList &L)
{
	if(L.lenth==0)
		return TRUE;
	else
		return FALSE;
} 

/*链表销毁操作*/
State destoryList(LinkList &L)
{
	Link temp;
	L.current = L.head;
	while(L.current)
	{
		temp = L.current;
		L.current = L.current->next;
		freeNode(temp);
	}
}

/*链表初始化操作*/
State initList(LinkList &L)
{
	ElemType e;
	if(!makeNode(L.head,e))
		return ERROR;//创建节点失败 
	L.tail = L.head;
	L.current = L.head;
	L.lenth = 0;//赋长度为零
	
	return OK; 
}
/*创建一个节点*/ 
State makeNode(Link &p,ElemType e)
{
	p = (Link)malloc(sizeof(Link));
	if(!p)
		return ERROR;//分配失败	
	p->data = e;
	p->next = NULL;
	return OK; 
}

/*销毁一个节点*/
void freeNode(Link &p)
{
	free(p);
}