构建链表进行冒泡排序，翻转，链表合并测试

//自构建链表模型
class List
{
public:
	List(int n, List* p=NULL):No(n),pNext(p){}
	~List(){}
public:
	int No;
	List* pNext;
};

List* create(int count)
{
	List* pL=NULL;
	int j = 0;
	for (int i=0; i<count; i++)
	{
		j = rand()%100;

		if (i==0)
		{
			pL=new List(j,NULL);
		}
		else
		{
			pL=new List(j,pL);
		}
	}
	return pL;
}

/**
链表翻转
*/
void reverse(List* l)
{
	if (!l || !l->pNext)
		return;

	List* pre = l;
	List* cur = l->pNext;
	List* next = NULL;
	while(cur->pNext)
	{
		next = cur->pNext;
		cur->pNext = pre;
		pre = cur;
		cur = next;
	}
	//最后一个元素
	cur->pNext = pre;
	l->pNext = NULL;
}

/**
链表冒泡排序：从小到大
*/
List* sort(List* l)
{
	assert(l != NULL);
	List* cur = l;
	List* pre = NULL;
	List* thehead = l; //自始至终要指向表头
	int length = 0;

	//只有一个元素
	if (l->pNext == NULL)
	{
		return thehead;
	}

	//遍历计算链表长度
	List* p = l;
	while(p->pNext != NULL)
	{
		length++;
		p = p->pNext;
	}
	length++;

	while (--length)
	{
		while (cur->pNext != NULL)
		{
			if ((cur->No) > (cur->pNext->No))
			{
				if (cur == thehead) //当前为表头，则要重新设置表头
				{
					thehead = cur->pNext;
				}
				
				List* temp = cur->pNext;
				cur->pNext = cur->pNext->pNext;
				temp->pNext = cur;
				//此处请注意，当前指针不是表头也即pre指针不为NULL，发生移动时需要修改pre指针的指向
				if (pre != NULL) 
				{
					pre->pNext = temp;
				}
				pre = temp;				
			}
			else
			{
				pre = cur;
				cur = cur->pNext;
			}			
		}//end while

		//比较完一次，重置指针，从头开始
		pre = NULL;		
		cur = thehead;
	}//end while
	return thehead;
}

/**
两个链表合并：l1 , l2均为从小到大的顺序排列
*/
List* mergeList(List* l1, List* l2)
{
	assert((l1 != NULL) && (l2 != NULL));
	List* pre1 = NULL;		 //合并时指向表1当前元素的上一个元素，初始为NULL
	List* cur1 = l1;
	List* cur2 = l2;
	List* last_list1 = cur1; //链1 的最后一个元素
	List* last_list2 = cur2; //链2 的最后一个元素

	//自始至终要指向表1头，当元素插到链表1的表头时更新头指针，也只有当原始表2的第一个元素小于表1的头元素时，把表2的该元素插过去，然后更新表1的头元素
	List* updateList1 = cur1; 
	//计算表1的最后一个元素
	while (last_list1->pNext)
	{
		last_list1 = last_list1->pNext; 
	}
	//计算表2的最后一个元素
	while (last_list2->pNext)
	{
		last_list2 = last_list2->pNext;
	}

	/*
	****两种特殊情况
	*/
	//表2的最大元素小于表1的最小元素，直接加表2到表1表头，返回
	if ((last_list2->No) < (cur1->No))
	{
		last_list2->pNext = cur1;
		return cur2;
	}
	//表1的最大元素小于表2的最小元素，直接加表2到表1表尾，返回
	if ((last_list1->No) < (cur2->No))
	{
		last_list1->pNext = cur2;
		return cur1;
	}

	/*
	****一般情况：
	****算法：冒泡的思路，用表2当前元素从表1当前元素开始逐个比较（前面的可不用比，因为前面的是表2插过来的元素，本就比表2当前元素小）,
	****直到表1中第一次比该元素大的元素时停止比较，插入该元素
	*/
	while((cur2))
	{

		while (cur1)
		{
			if ((cur2->No) < (cur1->No)) //链表1中第一个比链表2中当前元素大的节点，进行节点插入
			{
				List* temp = cur2->pNext;				
				if (pre1 == NULL) //特殊情况：原始表1的第一个都比 链表2的第一个元素大，将表2的头元素插到表1前面，并更新表1头，以及表1的pre指针
				{							
					updateList1 = cur2;
					pre1 = cur2;
				}	
				else
				{
					pre1->pNext = cur2;
					pre1 = cur2;
				}
	
				cur2->pNext = cur1;
				cur2 = temp;				
				break;
			}
			else
			{
				pre1 = cur1;
				cur1 = cur1->pNext;
			}
		} //end while
		if (cur1 == NULL) //此时到达链表1 的尾部（表明表1的最后一个元素都不大于表2当前元素）,故直接将链2当前接到其尾部，返回
		{
			pre1->pNext = cur2;
			return updateList1;
		}		

	}//end while
	//比较完毕，返回更新后的表1
	return updateList1;	
}

void TestReverse()
{
	List* p = create(10);
	List* temp = p;
	if (!p)
	{
		return;
	}
	while (p->pNext)
	{
		cout<<endl<<p->No;
		p = p->pNext;
	}
	cout<<endl<<p->No;
	reverse(temp);

	cout<<"翻转后："<<endl;
	while (p->pNext)
	{
		cout<<endl<<p->No;
		p = p->pNext;
	}
	cout<<endl<<p->No;
}

void outputList(List* l)
{
	List* temp = l;
	while (temp->pNext)
	{
		cout<<endl<<temp->No;
		temp = temp->pNext;
	}
	cout<<endl<<temp->No<<endl;
}

void testMergeList()
{
	List* p = create(10);
	List* p1 = create(10);

	cout<<"排序前："<<endl;
	outputList(p);
	List* p_s = sort(p);
	cout<<"排序后："<<endl;
	outputList(p_s);

	cout<<"排序前："<<endl;
	outputList(p1);	
	List* p1_s = sort(p1);
	cout<<"排序后："<<endl;
	outputList(p1_s);
	
	List* mergeL = mergeList(p1_s, p_s);
	cout<<endl<<"两条链表merge后："<<endl;
	while (mergeL->pNext != NULL)
	{
		cout<<endl<<mergeL->No;
		mergeL=mergeL->pNext;
	}
	cout<<endl<<mergeL->No;
}