单链表的排序（一）

最近准备整理一些数据结构与算法的一些东西，由于时间有限，直接上算法的代码，希望多某些朋友有些帮助：

代码已经过大概的测试，写的不好，欢迎大家发言讨论

先是插入排序，选择排序，冒牌排序算法

// Link_Node_Operate.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <assert.h>
using namespace std;
typedef struct t_Link_Node{
	int value;
	struct t_Link_Node *p_Next;
}Link_Node;

class Link_Node_Op{

private:	
	Link_Node *p_Node;

private:
	void Insert_sort_Swap_Node(Link_Node *old_froMax_Node, Link_Node *old_Max_Node,Link_Node *froMax_Node, Link_Node *Max_Node)
	{
		Link_Node *tmp = Max_Node->p_Next;
		
		if(old_Max_Node->p_Next == Max_Node)
		{
			old_froMax_Node->p_Next = Max_Node;
			Max_Node->p_Next = old_Max_Node;
			old_Max_Node->p_Next = tmp;
		}
		else
		{
			old_froMax_Node->p_Next = Max_Node;
			Max_Node->p_Next = old_Max_Node->p_Next;

			froMax_Node->p_Next = old_Max_Node;
			old_Max_Node->p_Next = tmp;
		}
	}

public:
	Link_Node_Op()
		:p_Node(NULL)
	{

	}

	~Link_Node_Op()
	{
		while (p_Node)
		{
			Link_Node *tmp_node = p_Node;
			p_Node = p_Node->p_Next;
			delete tmp_node;
		}
	}
	
	void List_Print()
	{
		if(!p_Node)
		{
			cout<< "list head is null!" <<endl;
			return;
		}
		else if(!p_Node->p_Next)
		{
			cout<< "list has no elements!"<<endl;
			return;
		}

		Link_Node *p = p_Node->p_Next;


		while(p)
		{
			cout << p->value << " ";
			p = p->p_Next;
		}

		cout << endl;
	}

	void Create_Link_List(int nsize) 
	{
		assert(p_Node == NULL);

		p_Node = new Link_Node;// node head
		p_Node->value = 0;
		p_Node->p_Next = NULL;

		for (int i = 0; i < nsize; i++)
		{
			Link_Node *new_node = new Link_Node;
			cin >> new_node->value;
			if(new_node->value == 0)
			{
				printf("value equals 0 means head, invalid input, try again!");
				delete new_node;
				i--;
			}
			new_node->p_Next = p_Node->p_Next;
			p_Node->p_Next = new_node;
		}
	}
	
	void Insert_sort()
	{
		if(!p_Node || !p_Node->p_Next)
			return;

		Link_Node *p = p_Node->p_Next;
		int ncount = 0;
		while (p)
		{
			ncount++;
			p = p->p_Next;
		}
		
		p = p_Node;
		Link_Node *fro_Node, *froMax_Node;
		Link_Node *cur_Node, *Max_Node;
		for (int i = 0; i < ncount - 1; i++)
		{
			froMax_Node = p;
			Max_Node = p->p_Next;

			fro_Node = p->p_Next;
			cur_Node = fro_Node->p_Next;
			
			while(cur_Node)
			{
				if(Max_Node->value < cur_Node->value)
				{
					froMax_Node = fro_Node;
					Max_Node = cur_Node;
				}
				
				fro_Node = cur_Node;
				cur_Node = cur_Node->p_Next;
			}
			
			if(Max_Node != p->p_Next)
				Insert_sort_Swap_Node(p, p->p_Next,froMax_Node, Max_Node);

			p = p->p_Next;

		}
	}

	void bubble_sort2() //交换节点
	{
		if(!p_Node || !p_Node->p_Next)//头结点为NULL，或者没有Node
			return;
		Link_Node *p = p_Node->p_Next;
		int ncount = 0;
		while (p)
		{
			ncount++;
			p = p->p_Next;
		}

		Link_Node *fro_Node ;
		Link_Node *cur_Node ;

		for (int i = ncount - 1; i > 0; i--)
		{
			int j = i;
			
			fro_Node = p_Node;
			cur_Node = p_Node->p_Next;

			while (j > 0)
			{
				if (cur_Node->value > cur_Node->p_Next->value)
				{
					p = cur_Node->p_Next;
					fro_Node->p_Next = p;
					cur_Node->p_Next = p->p_Next;
					p->p_Next = cur_Node;
				}
				
				cur_Node = fro_Node->p_Next->p_Next;
				fro_Node = fro_Node->p_Next;
				j--;
			}
			
		}
	}

	void bubble_sort()//冒泡排序，不交换节点，仅交换数值
	{
		if(!p_Node || !p_Node->p_Next)
			return;
		Link_Node *p = p_Node->p_Next;
		int ncount = 0;
		while (p)
		{
			ncount++;
			p = p->p_Next;
		}

		p = p_Node->p_Next;
		for (int i = ncount - 1; i > 0; i--)
		{
			int j = i;
			while(j > 0)
			{
				if(p->value > p->p_Next->value)
				{
					int tmp = p->value;
					p->value = p->p_Next->value;
					p->p_Next->value = tmp;
				}

				p = p->p_Next;
				j--;
			}

			p = p_Node->p_Next;
		}
	}

	void select_sort()
	{
		if(!p_Node || !p_Node->p_Next)
			return;

		Link_Node *p_order_link = NULL;
		Link_Node *p_Cur_Node = p_Node->p_Next;
		Link_Node *p_fro_Cur_Node = p_Node;
		Link_Node *p_fro_Max_Node = NULL, *p_Max_Node = NULL;

		while(p_Cur_Node)
		{

			p_fro_Max_Node = p_fro_Cur_Node;
			p_Max_Node = p_Cur_Node;
			for(p_Cur_Node; p_Cur_Node != NULL;p_fro_Cur_Node = p_Cur_Node, p_Cur_Node = p_Cur_Node->p_Next)
			{
				if(p_Max_Node->value < p_Cur_Node->value)
				{
					p_fro_Max_Node = p_fro_Cur_Node;
					p_Max_Node = p_Cur_Node;
				}
			}
			
			//从老的link中抽出这个最大的Node，并插入新的有序的link中
			p_fro_Max_Node->p_Next = p_Max_Node->p_Next;

			if(p_order_link == NULL)
			{
				p_order_link = p_Max_Node;
				p_order_link->p_Next = NULL;
			}
			else
			{
				p_Max_Node->p_Next = p_order_link;
				p_order_link = p_Max_Node;
			}
			
			//从头开始
			p_fro_Cur_Node = p_Node;
			p_Cur_Node = p_Node->p_Next;

		}

		p_Node->p_Next = p_order_link;
	}
};


//test case
int _tmain(int argc, _TCHAR* argv[])
{

	Link_Node_Op Node_List;
	int ncount = 0;

	cout<< "input node count you want to create:" << endl;
	cin >> ncount;
	cout << "Node List length:" << ncount<< endl;
	Node_List.Create_Link_List(ncount);
	
	cout << "print nodes value:" << endl;
	Node_List.List_Print();
	
	cout << "do sort operation!" << endl;
	//Node_List.bubble_sort();
	//Node_List.bubble_sort2();
	//Node_List.Insert_sort();
	Node_List.select_sort();
	cout << "print nodes value:" << endl;
	Node_List.List_Print();

	return 0;
}