C++笔记（3-2）：链表(结构体构成或者类构成)的交换节点的冒泡排序

0引言：

链表的排序可以采用 

1. 交换内容，节点不动；

我的  https://blog.csdn.net/Zhao_Water/article/details/104887993  这篇文章里用的是冒泡排序，并且是交换内容的方式，链表为 双向循环链表。

2. 交换节点，内容跟着节点走；

为了 对 不同的链表实验，这此使用  单向不循环 链表，采用冒泡排序法。排序的实质是交换节点。

1程序：

包含main的完整程序，可以直接使用

#include <iostream>
#include <string>
#include <cstdlib>

using namespace std;

class  User{
	string Name;
	int Money;
public:
	static int User_Count ;
	User* _next;
	User(){ User_Count++ ; }
	User( string str , int data){ User_Count++ ; Name = str , Money = data; }
	string Get_Name() { return Name;}
	int Get_Money() { return Money;}
	~User(){}
};
int User::User_Count = 0;


User* BubbleSort( User *List);
void  Print_User( User *List);
User* Creat_List() ;

int main(){

	User *Head = Creat_List();
	cout << "***** 原始数据 ******* \n\n" ;
 	Print_User( Head);
	
	Head = BubbleSort( Head );
	cout<< " \n **************冒泡排序结果，从小到大***********\n\n" ;
	Print_User( Head);

	delete Head ;
	Head = NULL ; 
	return 0;
}

User * Creat_List()
{
	string name[6] = { "翠花" , "狗剩" , "嘎子" , "大红" , "二蛋" , "石头" };
	int data[6] = { 6,5,4,3,2,1 } ;
	User *Head = new User( name[0] , data[0]) ; 
	User *temp = Head;

	short i = 0;
	while( ++i != 6 )
	{
		User *node = new User( name[i] , data[i]) ;
		temp->_next = node;
		temp = node;
	}
	temp->_next = NULL;
	return Head;
}


void Print_User( User *List)
{
	User* temp = List ; 
	while( temp != NULL )
	{
		cout <<  '\t' << temp->Get_Name() << '\t' << temp->Get_Money() << endl; 
		temp = temp->_next;
	}
}

User* BubbleSort( User *List)
{
	int count = 0 ;
	User* p = new User();
	User* q = new User();
	User *qPro = List ;
	
	cout << "排序具体过程：\n\n ";
	for ( int k = 0 ; k<User::User_Count ; k++ )  // 第一个循环
	{  
		count = 0;  // 这个计数值是q的位置，为了后续找到 q的前驱，从而可以交换节点
		for ( q = List; q->_next != NULL ; )
		{
			count++;	
			if ( q->Get_Money() > q->_next->Get_Money()) // 由小到大冒泡排序
			{  
				// 交换两个节点: q 和 q的下一个节点进行交换
				//将 q->_next和q先交换位置
				User *temp = q->_next;
				q->_next = q->_next->_next;
				temp->_next = q ; 
				// 将 q->_next 穿入链表中去
				if ( q == List )	// q是头节点
				{
					List = temp ;  // 改变头结点
					cout << "------涉及头节点-交换节点：---------\n";
					Print_User( List);
				}
				else			 // q为非头节点
				{  	
					qPro = List;  
					// qPro 是 q 的前节点，因为是 单向链表 ，
					// 所以无法直接找到前驱，利用count记下当前位置,在由此循环找到前驱节点
					for( int i = 1 ; i<count-1 ; i++ ){ qPro = qPro->_next;}
					qPro->_next = temp;
	
					cout << "-------不涉及头结点交换节点：----------\n";
					Print_User( List);
				}
			}
			else
			{
				q = q->_next;
			}
		}
	}
	return List;
}

2. 自己有需求就想着自己多思考思考，时间复杂度和空间复杂度可能都不太好，自己的思考，仅供参考，欢迎大家提意见。

网上有比我写的好的：比如这个 就很不错： https://www.cnblogs.com/orion7/p/7227627.html 。