├── README.md
├── functions
    └── bubbleSort_node
└── edition_21_2020.6.29


/README.md:
--------------------------------------------------------------------------------
1 | # MIS_studentGrade_node
2 | Use structures and Pointers to manage student performance;
3 | Teacher Yi's 2nd curriculum design ;
4 | 


--------------------------------------------------------------------------------
/functions/bubbleSort_node:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include<iomanip>
  3 | #include <string>
  4 | using namespace std;
  5 | struct Node{
  6 | 	int num;
  7 | 	string name; 
  8 | 	int score;
  9 | 	Node *next;
 10 | }stu7{7,"stu7",50,0},stu6{6,"stu6",52,&stu7},stu5{5,"stu5",54,&stu6},stu4{4,"stu4",57,&stu5},stu3{3,"stu3",59,&stu4},stu2{2,"stu2",51,&stu3},stu1{1,"stu1",53,&stu2};
 11 | 
 12 | Node *head = &stu1;
 13 | Node *p1,*p2,*p3;
 14 | bool flag = 1,pFlag = 0,pSort = 0;
 15 | void swap(Node *p1,Node *p2)
 16 | {
 17 | 	Node *pTemp2;
 18 | 	pTemp2 = p1;
 19 | 	p1 = p2;
 20 | 	p2 = pTemp2;
 21 | }
 22 | 
 23 | int main()
 24 | {	
 25 | //before sort
 26 |     Node *p = head;
 27 | 	cout<<"链表上的各个节点为：\n";
 28 | 	cout<<left<<setw(8)<<"学号"<<setw(8)<<"姓名"<<setw(6)<<"成绩"<<'\n';	
 29 | 	while(p != NULL)
 30 | 	{
 31 | 	    cout<<left<<setw(8)<<p->num<<setw(8)<<p->name<<setw(6)<<p->score<<'\n';
 32 |         p = p->next;
 33 |     } 	
 34 |     cout<<'\n';
 35 | //after sort
 36 |     int temp,n,i;
 37 |     p1 = head ,p2 = p1->next,p3=head;  
 38 |     for(i = 0,p = head;p->next->next !=0;i++)//cout node number
 39 |     {
 40 |     	p = p->next;
 41 | 	}
 42 |     for(;i > 0;i--)
 43 |     {
 44 |     	p1 = head ;
 45 | 		p2 = p1->next;
 46 | 		p3=head;
 47 | 		flag = 1;
 48 | 		pSort = 0;//optimize
 49 |     	do
 50 |     	{
 51 |     		if(p2->next == 0)
 52 | 			{
 53 | 				flag = 0;
 54 | 			}
 55 |     		if(p1 == head)//method begining
 56 |         	{
 57 |         		if(p1->score > p2->score)
 58 |     	    	{
 59 |     	    		Node *pTemp = p2; //copy
 60 | 		    		p1->next = p2->next;
 61 | 	    			head = p2;
 62 | 		    	    p2 = pTemp;
 63 | 	    	    	p2->next = p1;
 64 | 	    		    //结点交换后，p1与p2位置颠倒回来
 65 |                     Node *pTemp2;
 66 |                     pTemp2 = p1;
 67 |                 	p1 = p2;
 68 |                  	p2 = pTemp2;
 69 |                  	p = head;
 70 | 		    	}
 71 | 		    	p1 = p1->next;
 72 | 			    p2 = p2->next;
 73 | 			    if(p2->next == 0)//method ending
 74 | 	        	{
 75 | 		    	if(p1->next->score > p2->next->score)
 76 | 		        	{
 77 | 		        		Node *pTemp = p3;//copy
 78 | 		    	    	p3->next = p2;
 79 | 		    	    	p2->next = p1;
 80 | 	    	    		p1->next = 0;
 81 | 		    	    	//结点交换后，p1与p2位置颠倒回来
 82 |                         Node *pTemp2;
 83 |                         pTemp2 = p1;
 84 |                         p1 = p2;
 85 |                         p2 = pTemp2;
 86 |                         p3 = pTemp;  
 87 |                     }   
 88 | 		    	}
 89 | 		    	else//method middle
 90 | 	        	{
 91 | 	    	    	if(p1->score > p2->score)
 92 | 	    	    	{
 93 | 	    	    		Node *pTemp = p3;//copy
 94 | 	    	    		p3->next = p2;
 95 | 	    	    		p1->next = p2->next ;
 96 | 	    	    		p2->next = p1;
 97 | 	    	    		//结点交换后，p1与p2位置颠倒回来,p3恢复
 98 |                         Node *pTemp2;
 99 |                         pTemp2 = p1;
100 |                     	p1 = p2;
101 |                      	p2 = pTemp2;
102 | 			    		p3 = pTemp;    			
103 | 		    		}
104 | 	        	}
105 | 	        //p = head;
106 | 	        p3 = head;
107 | 	        }
108 | 	    	else if(p2->next == 0)//method ending
109 | 	    	{
110 | 		    	if(p1->score > p2->score)
111 | 		    	{
112 | 		    		Node *pTemp = p3;//copy
113 | 		    		p3->next = p2;
114 | 		    		p2->next = p1;
115 | 	    			p1->next = 0;
116 | 		    		//结点交换后，p1与p2位置颠倒回来
117 |                     Node *pTemp2;
118 |                     pTemp2 = p1;
119 |                     p1 = p2;
120 |                     p2 = pTemp2;
121 |                     p3 = pTemp;    				
122 | 		    	}
123 | 	    	}
124 | 	    	else//method middle
125 | 	    	{
126 | 	    		if(p1->score > p2->score)
127 | 	    		{
128 | 	    			Node *pTemp = p3;//copy
129 | 	    	    	p3->next = p2;
130 | 	    	    	p1->next = p2->next ;
131 | 	    	    	p2->next = p1;
132 | 	    			//结点交换后，p1与p2位置颠倒回来,p3恢复
133 |                     Node *pTemp2;
134 |                     pTemp2 = p1;
135 |                     p1 = p2;
136 |                     p2 = pTemp2;
137 | 			    	p3 = pTemp;     			
138 | 				}
139 | 	    	}
140 | 			p1 = p1->next;
141 | 			p2 = p2->next;	
142 | 			p3 = p3->next;	
143 | 	 	}while(flag);
144 | 		if(pSort) break;	
145 |     }
146 |     p = head;
147 | 	cout<<"排序之后为：\n";
148 | 	cout<<left<<setw(8)<<"学号"<<setw(8)<<"姓名"<<setw(6)<<"成绩"<<'\n';	
149 | 	while(p != NULL)
150 | 	{
151 | 	    cout<<left<<setw(8)<<p->num<<setw(8)<<p->name<<setw(6)<<p->score<<'\n';
152 |         p = p->next;
153 |     } 
154 | }
155 | /*	for (i = 0; i < n;i++) 
156 | 	{  
157 | 	    bool flag = true;           
158 | 		for (j = 0; j < n - i;j++) {      //在每一步进行10-i次两两比较
159 | 			if (m[j] > m[j + 1]) {
160 | 				flag = false;
161 | 				temp = m[j];
162 | 				m[j] = m[j + 1];
163 | 				m[j + 1] = temp;
164 | 			}
165 | 		}
166 | 		if(flag) break;
167 | 	}
168 | */
169 | //before sort
170 | 


--------------------------------------------------------------------------------
/edition_21_2020.6.29:
--------------------------------------------------------------------------------
   1 | #include <iostream>
   2 | #include<string>
   3 | #include<iomanip>
   4 | #define NULL 0
   5 | using namespace std;
   6 | void Menu();
   7 | //struction defination
   8 | int order = 0; 
   9 | struct Node {
  10 |   int num;
  11 |   string name;
  12 |   int scoreMath;
  13 |   int scoreEnglish;
  14 |   int scorePhysics;
  15 |   int scoreAll;
  16 |   struct Node *next;
  17 | } ;
  18 | 	
  19 | Node *head = 0;
  20 | bool warmFlag = 0;
  21 | 
  22 | //输入链表上各节点的值 
  23 | Node *create(Node *head,bool warmFlag)
  24 | {
  25 | 	
  26 | 	system("cls");
  27 | 	int dataTemp; 
  28 | 	Node *p = 0,*pend = 0;
  29 | 	if(head != 0)
  30 | 	{
  31 | 		cout<<"该操作将会覆盖原有数据! 若要修改单个节点建议您使用2 3 4功能。\n";
  32 | 		cout<<"是否执行重新输入Y/N？： ";
  33 | 		char judge;//confirm operation
  34 | 		cin>>judge;
  35 | 		if(judge == 'Y' || judge == 'y')
  36 | 		{
  37 | 			head = 0;
  38 | 			system("cls");
  39 | 			cout<<"恭喜您，数据覆盖成功！请重新输入\n";
  40 | 		}
  41 | 		else return head;
  42 | 	}
  43 | 	cout<<"请输入学号1~30，回车确定（0表示结束输入）:";
  44 | 	cin>>dataTemp;
  45 | 	if(dataTemp == 0) return head;
  46 | 	while(dataTemp < 0 || dataTemp >30)
  47 | 	{
  48 | 		cout<<"学号错误！请检查后重新输入（0表示结束输入）：";
  49 | 		cin>>dataTemp;
  50 | 	}
  51 | 	while(dataTemp != 0)
  52 | 	{	
  53 | 		p=new Node; //creat new one
  54 | 		p->num = dataTemp;
  55 | 		cout<<"请用拼音和数字输入姓名:";
  56 | 		cin>>p->name;
  57 | 		cout<<"请输入数学分数:";
  58 | 		cin>>dataTemp;
  59 | 		while(dataTemp < 0 || dataTemp >100)
  60 |     	{
  61 | 	    	cout<<"输入错误！请检查后重新输入数学：" ;
  62 |     		cin>>dataTemp;
  63 |     	}
  64 |     	p->scoreMath = dataTemp; 
  65 | 		cout<<"请输入英语分数:";
  66 | 		cin>>dataTemp;
  67 | 		while(dataTemp < 0 || dataTemp >100)
  68 |     	{
  69 | 	    	cout<<"输入错误！请检查后重新输入英语：" ;
  70 |     		cin>>dataTemp;
  71 |     	}
  72 | 		p->scoreEnglish = dataTemp; 
  73 | 		cout<<"请输入物理分数:";
  74 | 		cin>>dataTemp;
  75 | 		while(dataTemp < 0 || dataTemp >100)
  76 |     	{
  77 | 	    	cout<<"输入错误！请检查后重新输入物理：" ;
  78 |     		cin>>dataTemp;
  79 |     	}
  80 | 		p->scorePhysics = dataTemp; 
  81 | 		p->scoreAll = p->scoreMath + p->scoreEnglish + p->scorePhysics;
  82 | 		cout<<"该同学总分为："<<p->scoreAll<<'\n'; 
  83 | 		system("pause");
  84 | 		system("cls");
  85 | 		if(head == 0)
  86 | 		{
  87 | 			head = p;
  88 | 			pend = p;
  89 | 		} 
  90 | 		else
  91 | 		{
  92 | 			pend->next = p;
  93 | 			pend = p;
  94 | 		}
  95 | 		cout<<"请输入学号，回车确定（0表示结束输入）:";
  96 | 		cin>>dataTemp; 
  97 | 		while(dataTemp < 0 || dataTemp >30)
  98 |     	{
  99 | 	    	cout<<"输入错误！请检查后重新输入学号（0表示结束输入）：" ;
 100 |     		cin>>dataTemp;
 101 |     	}
 102 | 	} 
 103 | 	pend->next = NULL;
 104 | 	warmFlag = 1;
 105 | 	return head;
 106 | }
 107 | //输出链表上各节点的值 
 108 | void print(Node *head)
 109 | {	
 110 |     //冒泡排序核心 
 111 |     Node *p1,*p2,*p3,*p = head; 
 112 |     int i;
 113 |     if(head == 0)//空链表 
 114 |     {
 115 |     	cout<<"系统内没有数据，建议您使用功能1依次初始化录入：";	
 116 | 	}
 117 | 	else
 118 | 	{
 119 | 		for(i = 1;p->next !=0;i++)//cout node number
 120 |         {
 121 |         p = p->next;
 122 |         }
 123 |         if(i == 1)//只有1个数据
 124 |         {
 125 |         	p = head; 
 126 | 	        cout<<"根据学号排序阅览为：\n";  //print 
 127 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 128 |         	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 129 | 		}
 130 | 		else if(i == 2)//只有2个数据
 131 | 		{
 132 | 			p = p1 = head ,p2 = p1->next;
 133 |      		if(p1->num > p2->num)
 134 |     		{
 135 |      			head = p2;
 136 |      			p2->next = p1;
 137 |      			p1->next = 0;
 138 |             } 
 139 |             cout<<"根据学号排序阅览为：\n"; //print 
 140 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 141 |             while(p != NULL)
 142 |             {
 143 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 144 |                 p = p->next;
 145 |             }
 146 |             p = head;
 147 | 		}
 148 | 		else if( i== 3)//只有3个数据
 149 | 		{
 150 | 			p = p1 = head,p2 = head->next,p3 = p2->next;//3个if实现简单冒泡排序 
 151 |      		if(p1->num > p2->num)
 152 |     		{
 153 | 	    		head = p2;
 154 | 	    		p2->next = p1;
 155 | 	    		p1->next = p3;
 156 | 	    		//结点交换后，p1与p2位置颠倒回来
 157 |                 Node *pTemp;
 158 |                 pTemp = p1;
 159 |                 p1 = p2;
 160 |                 p2 = pTemp;
 161 |                 p = head;
 162 |     		}
 163 |    	    	if(p2->num > p3->num)
 164 | 	    	{
 165 | 	    		p1->next = p3;
 166 | 	    		p3->next = p2;
 167 | 	    		p2->next =0;
 168 | 	    		//结点交换后，p2与p3位置颠倒回来
 169 |                 Node *pTemp;
 170 |                 pTemp = p2;
 171 |                 p2 = p3;
 172 |                 p3 = pTemp;
 173 |                 p = head;
 174 | 	      	}
 175 | 	    	if(p1->num > p2->num)
 176 | 	    	{
 177 | 	    	    head = p2;
 178 | 	    		p2->next = p1;
 179 | 	    		p1->next = p3;
 180 | 	    		//结点交换后，p1与p2位置颠倒回来
 181 |                 Node *pTemp;
 182 |                 pTemp = p1;
 183 |                 p1 = p2;
 184 |                 p2 = pTemp;
 185 |                 p = head;   
 186 |     		} 
 187 |     		cout<<"根据学号排序阅览为：\n"; //print 
 188 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 189 |             while(p != NULL)
 190 |             {
 191 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 192 |                 p = p->next;
 193 |             }
 194 |             p = head;
 195 |  		}
 196 |  		else//3个数据以上 
 197 |  		{
 198 |  			bool flag = 1,pFlag = 0,sortFlag = 0;
 199 |             int temp,n;
 200 |     	    p = p1 = head ,p2 = p1->next,p3=head; 
 201 |     	    for(i = 0,p = head;p->next !=0;i++)//cout node number
 202 |             {
 203 |             	p = p->next;
 204 |           	}
 205 |             for(;i > 0;i--)
 206 |             {
 207 |             	p1 = head ;
 208 |         		p2 = p1->next;
 209 |         		p3=head;
 210 |     	    	flag = 1;
 211 |     	    	sortFlag = 0;//optimize
 212 |             	do
 213 |              	{
 214 |             		if(p2->next == 0)
 215 |     	    		{
 216 |     	    			flag = 0;
 217 |     	    		}
 218 |         	    	if(p1 == head)//method begining
 219 |                 	{
 220 |                 		if(p1->num > p2->num)
 221 |          	        	{
 222 |         	        		Node *pTemp = p2; //copy
 223 |     		        		p1->next = p2->next;
 224 | 	        	    		head = p2;
 225 | 		            	    p2 = pTemp;
 226 | 	        	        	p2->next = p1;
 227 | 	            		    //结点交换后，p1与p2位置颠倒回来
 228 |                             Node *pTemp2;
 229 |                             pTemp2 = p1;
 230 |                         	p1 = p2;
 231 |                         	p2 = pTemp2;
 232 |                         	p = head;
 233 | 		            	}
 234 | 		            	p1 = p1->next;
 235 | 		        	    p2 = p2->next;
 236 | 		    	        if(p2->next == 0)//method ending
 237 | 	                	{
 238 | 		             	if(p1->next->num > p2->next->num)
 239 | 		                	{
 240 | 		                		Node *pTemp = p3;//copy
 241 | 		            	    	p3->next = p2;
 242 | 		            	    	p2->next = p1;
 243 | 	    	            		p1->next = 0;
 244 | 		    	            	//结点交换后，p1与p2位置颠倒回来
 245 |                                 Node *pTemp2;
 246 |                                 pTemp2 = p1;
 247 |                                 p1 = p2;
 248 |                                 p2 = pTemp2;
 249 |                                 p3 = pTemp;  
 250 |                             }   
 251 | 		            	}
 252 | 		            	else//method middle
 253 | 	                 	{
 254 | 	    	            	if(p1->num > p2->num)
 255 | 	    	            	{
 256 | 	    	            		Node *pTemp = p3;//copy
 257 | 	    	            		p3->next = p2;
 258 | 	    	                 	p1->next = p2->next ;
 259 | 	    	            		p2->next = p1;
 260 | 	    	            		//结点交换后，p1与p2位置颠倒回来,p3恢复
 261 |                                 Node *pTemp2;
 262 |                                 pTemp2 = p1;
 263 |                             	p1 = p2;
 264 |                              	p2 = pTemp2;
 265 | 			            		p3 = pTemp;    			
 266 | 		        	    	}
 267 | 	                	}
 268 | 	                //p = head;
 269 | 	                p3 = head;
 270 | 	                }
 271 | 	            	else if(p2->next == 0)//method ending
 272 | 	            	{
 273 | 		            	if(p1->num > p2->num)
 274 | 		             	{
 275 | 		            		Node *pTemp = p3;//copy
 276 | 		            		p3->next = p2;
 277 | 		            		p2->next = p1;
 278 | 	            			p1->next = 0;
 279 | 		            		//结点交换后，p1与p2位置颠倒回来
 280 |                             Node *pTemp2;
 281 |                             pTemp2 = p1;
 282 |                             p1 = p2;
 283 |                             p2 = pTemp2;
 284 |                             p3 = pTemp;    				
 285 | 		             	}
 286 | 	            	}
 287 | 	             	else//method middle
 288 | 	             	{
 289 | 	            		if(p1->num > p2->num)
 290 | 	            		{
 291 | 	            			Node *pTemp = p3;//copy
 292 | 	            	    	p3->next = p2;
 293 | 	            	    	p1->next = p2->next ;
 294 | 	            	    	p2->next = p1;
 295 | 	            			//结点交换后，p1与p2位置颠倒回来,p3恢复
 296 |                             Node *pTemp2;
 297 |                             pTemp2 = p1;
 298 |                             p1 = p2;
 299 |                             p2 = pTemp2;
 300 | 	    	    	    	p3 = pTemp;     			
 301 | 	    	    		}
 302 | 	            	}
 303 | 	    	    	p1 = p1->next;
 304 | 	          		p2 = p2->next;	
 305 | 	     	    	p3 = p3->next;	
 306 | 	         	}while(flag);
 307 |     	    	if(sortFlag) break;	
 308 |             }
 309 |             p = head;
 310 |         	cout<<"根据学号排序阅览为：\n";  //print 
 311 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 312 |         	while(p != NULL)
 313 |         	{
 314 |         	    cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 315 |                 p = p->next;
 316 |             }
 317 | 		}
 318 | 		
 319 | 	}
 320 |     cout<<"\n请直接输入操作指令："; 
 321 | }
 322 | //更改学生成绩 
 323 | void replace(Node *head)
 324 | {
 325 | 	
 326 | 	system("cls");
 327 | 	int stuID;
 328 |     Node *p = head,*p1 = head;
 329 |     cout<<"请输入想替换的学号：";
 330 |     cin>>stuID;
 331 |     if (head == NULL)
 332 |     {   
 333 | 	    cout<<"\n链表为空，无学生数据可替换."<<endl; //空链表 
 334 |     }
 335 |     else if (p->num == stuID) //更改首链表 
 336 |     {
 337 |     	int dataTemp; 
 338 |     	cout<<"该学生数据如下：\n"; 
 339 |         cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 340 |         cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 341 |      	cout<<"请用拼音和数字输入更改后的姓名:";
 342 | 		cin>>p->name; 
 343 | 	    cout<<"请输入该学生更改后的数学成绩：";
 344 |     	cin>>dataTemp;
 345 |     	while(dataTemp < 0 || dataTemp >100)
 346 |         {
 347 |     	    cout<<"输入错误！请检查后重新输入数学：" ;
 348 |          	cin>>dataTemp;
 349 |         }
 350 |         p->scoreMath = dataTemp; 
 351 |     	cout<<"请输入该学生更改后的英语成绩：";
 352 |     	cin>>dataTemp;
 353 |     	while(dataTemp < 0 || dataTemp >100)
 354 |         {
 355 |     	    cout<<"输入错误！请检查后重新输入英语：" ;
 356 |          	cin>>dataTemp;
 357 |         }
 358 |         p->scoreEnglish = dataTemp; 
 359 |     	cout<<"请输入该学生更改后的物理成绩：";
 360 |     	cin>>dataTemp;
 361 |     	while(dataTemp < 0 || dataTemp >100)
 362 |         {
 363 |     	    cout<<"输入错误！请检查后重新输入物理：" ;
 364 |          	cin>>dataTemp;
 365 |         }
 366 |         p->scorePhysics = dataTemp; 
 367 |     	p->scoreAll = p->scoreMath + p->scoreEnglish + p->scorePhysics;
 368 |      	cout<<"该同学更改后的总分为："<<p->scoreAll<<'\n';  
 369 |      	cout<<"\n恭喜您，更改成功！" ; 
 370 |     }
 371 |     else  //更改中间和尾部链表 
 372 |     {   
 373 | 	    while(p->num != stuID && p->next != NULL)
 374 |         {   
 375 | 		    p1 = p;        //保存前一个节点 
 376 |             p = p->next;  //寻找下一个节点
 377 |         }
 378 |         if(p->num == stuID)
 379 |         {
 380 |         	cout<<"该学生数据如下：\n"; 
 381 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 382 |             cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 383 |          	cout<<"请用拼音和数字输入更改后的姓名:";
 384 | 	    	cin>>p->name; 
 385 | 	        cout<<"请输入该学生更改后的数学成绩：";
 386 | 	        cin>>p->scoreMath;
 387 |         	cout<<"请输入该学生更改后的英语成绩：";
 388 |         	cin>>p->scoreEnglish;
 389 |         	cout<<"请输入该学生更改后的数学成绩：";
 390 |         	cin>>p->scorePhysics;
 391 |         	p->scoreAll = p->scoreMath + p->scoreEnglish + p->scorePhysics;
 392 |         	cout<<"该同学更改后的总分为："<<p->scoreAll<<'\n';
 393 |         	cout<<"\n恭喜您，更改成功！" ; 
 394 | 		}
 395 |         else
 396 | 		{
 397 | 		    cout<<"\n对不起，没有根据学号找到您想要更改的数据。"<<endl;
 398 | 		} 
 399 |     }
 400 |     system("pause"); 
 401 | }
 402 | //删除具有指定值链表的节点
 403 | Node *delete_node(Node *head)
 404 | { 
 405 |     system("cls");
 406 |     int stuID;
 407 |     cout<<"请输入想删除的学号：";
 408 |     cin>>stuID;
 409 | 	while(stuID <= 0 || stuID >=30) //judge
 410 |     {
 411 | 	    cout<<"输入错误！请检查后重新输入学号：" ;
 412 |     	cin>>stuID;
 413 |     }
 414 |     if (head == NULL)
 415 |     {   
 416 | 	    cout<<" 链表为空，无学生数据可删!\n"; //空链表 
 417 | 	    system("pause"); 
 418 | 	    return NULL; 
 419 |     }
 420 |     if (head->num == stuID) //删除首链表 
 421 |     { 
 422 |         Node *p5 = head;
 423 | 		head = head->next;
 424 |         delete p5;
 425 |         cout<<"\n恭喜您，该学生删除成功!"<<endl;
 426 |     }
 427 |     else  //删除中间链表 
 428 |     {   
 429 |         Node *p4 = head,*p5 = head;
 430 | 	    while(p5->num != stuID && p5->next != NULL)
 431 |         {   
 432 | 		    p4 = p5;        //保存前一个节点 
 433 |             p5 = p5->next;  //寻找下一个节点 
 434 |         }
 435 |         if(p5->num == stuID)
 436 |         {
 437 |         	p4->next = p5->next;
 438 |             delete p5;
 439 |             cout<<"\n恭喜您，该学生删除成功!"<<endl;
 440 | 		}
 441 |         else
 442 | 		{
 443 | 		    cout<<"\n对不起，没有根据学号找到您想要删除的数据。"<<endl;
 444 | 		} 
 445 |     }
 446 |     system("pause"); 
 447 |     return head;
 448 | }
 449 |  //插入链表的节点
 450 |  Node *insert(Node *head)
 451 |  {
 452 |  	int dataTemp;
 453 |  	system("cls");
 454 |  	Node *pInsert = new Node;
 455 |  	cout<<"请输入添加学生的学号：";
 456 |  	cin>>dataTemp;
 457 | 	while(dataTemp <= 0 || dataTemp >=30)
 458 |     {
 459 | 	    cout<<"输入错误！请检查后重新输入学号：" ;
 460 |     	cin>>dataTemp;
 461 |     }
 462 |     pInsert->num = dataTemp; 
 463 | 	cout<<"请用拼音输入姓名:";
 464 | 	cin>>pInsert->name; 
 465 | 	cout<<"请输入该学生的数学成绩：";
 466 | 	cin>>dataTemp;
 467 | 	while(dataTemp < 0 || dataTemp >100)
 468 |     {
 469 | 	    cout<<"输入错误！请检查后重新输入数学：" ;
 470 |     	cin>>dataTemp;
 471 |     }
 472 |     pInsert->scoreMath = dataTemp; 
 473 | 	cout<<"请输入该学生的英语成绩：";
 474 | 	cin>>dataTemp;
 475 | 	while(dataTemp < 0 || dataTemp >100)
 476 |     {
 477 | 	    cout<<"输入错误！请检查后重新输入英语：" ;
 478 |     	cin>>dataTemp;
 479 |     }
 480 |     pInsert->scoreEnglish = dataTemp; 
 481 | 	cout<<"请输入该学生的数学成绩：";
 482 | 	cin>>dataTemp;
 483 | 	while(dataTemp < 0 || dataTemp >100)
 484 |     {
 485 | 	    cout<<"输入错误！请检查后重新输入数学：" ;
 486 |     	cin>>dataTemp;
 487 |     }
 488 |     pInsert->scorePhysics = dataTemp; 
 489 | 	pInsert->scoreAll = pInsert->scoreMath + pInsert->scoreEnglish + pInsert->scorePhysics;
 490 |  	cout<<"该同学总分为："<<pInsert->scoreAll<<'\n'; 
 491 | 	Node *p1 = 0,*p2 = 0;
 492 |  	if(head == 0) //empty
 493 |     {
 494 |  		head = pInsert;
 495 |  		pInsert->next = 0;
 496 |  		return head;
 497 |     }
 498 | 	if(head->num >= pInsert->num) //begining
 499 | 	{
 500 | 	 	pInsert->next = head;
 501 | 	 	head = pInsert;
 502 | 	 	return head;
 503 | 	}
 504 | 	p1 = p2 = head;
 505 | 	while(p2->next != 0 && p2->num < pInsert->num) //locating
 506 | 	{
 507 | 	 	p1 = p2;
 508 | 	 	p2 = p2->next;
 509 | 	}
 510 | 	if(p2->num < pInsert->num) //ending
 511 | 	{
 512 | 	 	p2->next = pInsert;
 513 | 	 	pInsert->next = 0;
 514 | 	}
 515 | 	else
 516 | 	{
 517 | 	 	pInsert->next = p2; //middle
 518 | 	 	p1->next = pInsert;
 519 | 	}
 520 | 	cout<<"学号插入成功！；"; 
 521 | 	system("pause");
 522 | 	return head;
 523 |  }
 524 |  //链表中查询学号
 525 |  void search(Node *head) 
 526 |  { 
 527 |     system("cls");
 528 |     int stuID;
 529 |     cout<<"请输入想查找的学号：";
 530 |     cin>>stuID;
 531 |     Node *p,*p1;
 532 |     p = p1 = head;
 533 |     if (head == NULL)
 534 |     {   
 535 | 	    cout<<" 链表为空，查询无效"<<endl; //空链表 
 536 |     }
 537 |     else if (p->num == stuID)   //查询头链表 
 538 |     {
 539 |         {
 540 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 541 |             cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 542 |         }
 543 |     }
 544 |     else  //查询中间链表 
 545 |     {   
 546 | 	    while(p->num != stuID && p->next != NULL)
 547 |         {   
 548 | 		    p1 = p;        //copy
 549 |             p = p->next;  //跳过节点 
 550 |         }
 551 |         if(p->num == stuID)
 552 |         {
 553 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<setw(6)<<"英语"<<setw(6)<<"物理"<<setw(6)<<"总分"<<'\n';	
 554 |             cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<setw(6)<<p->scoreEnglish<<setw(6)<<p->scorePhysics<<setw(6)<<p->scoreAll<<'\n';
 555 | 		}
 556 |         else
 557 | 		{
 558 | 		    cout<<"没有找到要查询的学号"<<endl;
 559 | 		} 
 560 |     }
 561 |     system("pause"); 
 562 | }
 563 | //数学冒泡排序链表内数据 
 564 | void bubbleSort_scoreMath(Node *head)
 565 | {
 566 | 	system("cls"); 
 567 | 	//冒泡排序核心 
 568 |     Node *p1,*p2,*p3,*p = head; 
 569 |     int i;
 570 |     if(head == 0)//空链表 
 571 |     {
 572 |     	cout<<"系统内没有数据，请使用功能1依次录入：";	
 573 | 	}
 574 | 	else
 575 | 	{
 576 | 		for(i = 1;p->next !=0;i++)//cout node scoreMathber
 577 |         {
 578 |         p = p->next;
 579 |         }
 580 |         if(i == 1)//只有1个数据
 581 |         {
 582 |         	p = head; 
 583 | 	        cout<<"数学成绩排序为：\n";  //print 
 584 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<'\n';	
 585 |         	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<'\n';
 586 | 		}
 587 | 		else if(i == 2)//只有2个数据
 588 | 		{
 589 | 			p = p1 = head ,p2 = p1->next;
 590 |      		if(p1->scoreMath > p2->scoreMath)
 591 |     		{
 592 |      			head = p2;
 593 |      			p2->next = p1;
 594 |      			p1->next = 0;
 595 |             } 
 596 |             cout<<"数学成绩排序为：\n";  //print 
 597 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<'\n';	
 598 |             while(p != NULL)
 599 |             {
 600 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<'\n';
 601 |                 p = p->next;
 602 |             }
 603 |             p = head;
 604 | 		}
 605 | 		else if( i== 3)//只有3个数据
 606 | 		{
 607 | 			p = p1 = head,p2 = head->next,p3 = p2->next;//3个if实现简单冒泡排序 
 608 |      		if(p1->scoreMath > p2->scoreMath)
 609 |     		{
 610 | 	    		head = p2;
 611 | 	    		p2->next = p1;
 612 | 	    		p1->next = p3;
 613 | 	    		//结点交换后，p1与p2位置颠倒回来
 614 |                 Node *pTemp;
 615 |                 pTemp = p1;
 616 |                 p1 = p2;
 617 |                 p2 = pTemp;
 618 |                 p = head;
 619 |     		}
 620 |    	    	if(p2->scoreMath > p3->scoreMath)
 621 | 	    	{
 622 | 	    		p1->next = p3;
 623 | 	    		p3->next = p2;
 624 | 	    		p2->next =0;
 625 | 	    		//结点交换后，p2与p3位置颠倒回来
 626 |                 Node *pTemp;
 627 |                 pTemp = p2;
 628 |                 p2 = p3;
 629 |                 p3 = pTemp;
 630 |                 p = head;
 631 | 	      	}
 632 | 	    	if(p1->scoreMath > p2->scoreMath)
 633 | 	    	{
 634 | 	    	    head = p2;
 635 | 	    		p2->next = p1;
 636 | 	    		p1->next = p3;
 637 | 	    		//结点交换后，p1与p2位置颠倒回来
 638 |                 Node *pTemp;
 639 |                 pTemp = p1;
 640 |                 p1 = p2;
 641 |                 p2 = pTemp;
 642 |                 p = head;   
 643 |     		} 
 644 |     		cout<<"数学成绩排序为：\n";  //print 
 645 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"数学"<<'\n';	
 646 |             while(p != NULL)
 647 |             {
 648 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<'\n';
 649 |                 p = p->next;
 650 |             }
 651 |             p = head;
 652 |  		}
 653 |  		else//3个数据以上 
 654 |  		{
 655 |  			bool flag = 1,pFlag = 0,sortFlag = 0;
 656 |             int temp,n;
 657 |     	    p = p1 = head ,p2 = p1->next,p3=head; 
 658 |     	    for(i = 0,p = head;p->next !=0;i++)//cout node scoreMathber
 659 |             {
 660 |             	p = p->next;
 661 |           	}
 662 |             for(;i > 0;i--)
 663 |             {
 664 |             	p1 = head ;
 665 |         		p2 = p1->next;
 666 |         		p3=head;
 667 |     	    	flag = 1;
 668 |     	    	sortFlag = 0;//optimize
 669 |             	do
 670 |              	{
 671 |             		if(p2->next == 0)
 672 |     	    		{
 673 |     	    			flag = 0;
 674 |     	    		}
 675 |         	    	if(p1 == head)//method begining
 676 |                 	{
 677 |                 		if(p1->scoreMath > p2->scoreMath)
 678 |          	        	{
 679 |         	        		Node *pTemp = p2; //copy
 680 |     		        		p1->next = p2->next;
 681 | 	        	    		head = p2;
 682 | 		            	    p2 = pTemp;
 683 | 	        	        	p2->next = p1;
 684 | 	            		    //结点交换后，p1与p2位置颠倒回来
 685 |                             Node *pTemp2;
 686 |                             pTemp2 = p1;
 687 |                         	p1 = p2;
 688 |                         	p2 = pTemp2;
 689 |                         	p = head;
 690 | 		            	}
 691 | 		            	p1 = p1->next;
 692 | 		        	    p2 = p2->next;
 693 | 		    	        if(p2->next == 0)//method ending
 694 | 	                	{
 695 | 		             	if(p1->next->scoreMath > p2->next->scoreMath)
 696 | 		                	{
 697 | 		                		Node *pTemp = p3;//copy
 698 | 		            	    	p3->next = p2;
 699 | 		            	    	p2->next = p1;
 700 | 	    	            		p1->next = 0;
 701 | 		    	            	//结点交换后，p1与p2位置颠倒回来
 702 |                                 Node *pTemp2;
 703 |                                 pTemp2 = p1;
 704 |                                 p1 = p2;
 705 |                                 p2 = pTemp2;
 706 |                                 p3 = pTemp;  
 707 |                             }   
 708 | 		            	}
 709 | 		            	else//method middle
 710 | 	                 	{
 711 | 	    	            	if(p1->scoreMath > p2->scoreMath)
 712 | 	    	            	{
 713 | 	    	            		Node *pTemp = p3;//copy
 714 | 	    	            		p3->next = p2;
 715 | 	    	                 	p1->next = p2->next ;
 716 | 	    	            		p2->next = p1;
 717 | 	    	            		//结点交换后，p1与p2位置颠倒回来,p3恢复
 718 |                                 Node *pTemp2;
 719 |                                 pTemp2 = p1;
 720 |                             	p1 = p2;
 721 |                              	p2 = pTemp2;
 722 | 			            		p3 = pTemp;    			
 723 | 		        	    	}
 724 | 	                	}
 725 | 	                //p = head;
 726 | 	                p3 = head;
 727 | 	                }
 728 | 	            	else if(p2->next == 0)//method ending
 729 | 	            	{
 730 | 		            	if(p1->scoreMath > p2->scoreMath)
 731 | 		             	{
 732 | 		            		Node *pTemp = p3;//copy
 733 | 		            		p3->next = p2;
 734 | 		            		p2->next = p1;
 735 | 	            			p1->next = 0;
 736 | 		            		//结点交换后，p1与p2位置颠倒回来
 737 |                             Node *pTemp2;
 738 |                             pTemp2 = p1;
 739 |                             p1 = p2;
 740 |                             p2 = pTemp2;
 741 |                             p3 = pTemp;    				
 742 | 		             	}
 743 | 	            	}
 744 | 	             	else//method middle
 745 | 	             	{
 746 | 	            		if(p1->scoreMath > p2->scoreMath)
 747 | 	            		{
 748 | 	            			Node *pTemp = p3;//copy
 749 | 	            	    	p3->next = p2;
 750 | 	            	    	p1->next = p2->next ;
 751 | 	            	    	p2->next = p1;
 752 | 	            			//结点交换后，p1与p2位置颠倒回来,p3恢复
 753 |                             Node *pTemp2;
 754 |                             pTemp2 = p1;
 755 |                             p1 = p2;
 756 |                             p2 = pTemp2;
 757 | 	    	    	    	p3 = pTemp;     			
 758 | 	    	    		}
 759 | 	            	}
 760 | 	    	    	p1 = p1->next;
 761 | 	          		p2 = p2->next;	
 762 | 	     	    	p3 = p3->next;	
 763 | 	         	}while(flag);
 764 |     	    	if(sortFlag) break;	
 765 |             }
 766 |             p = head;
 767 |         	cout<<"数学排序之后为：\n";
 768 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"成绩"<<'\n';	
 769 |         	while(p != NULL)
 770 |         	{
 771 |          	    cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreMath<<'\n';
 772 |                 p = p->next;
 773 |             }
 774 |             p = head;
 775 | 		}		
 776 | 	}
 777 |     system("pause");
 778 | }
 779 | //英语冒泡排序链表内数据 
 780 | void bubbleSort_scoreEnglish(Node *head)
 781 | {
 782 | 	system("cls");
 783 | 	//冒泡排序核心 
 784 |     Node *p1,*p2,*p3,*p = head; 
 785 |     int i;
 786 |     if(head == 0)//空链表 
 787 |     {
 788 |     	cout<<"系统内没有数据，请使用功能1依次录入：";	
 789 | 	}
 790 | 	else
 791 | 	{
 792 | 		for(i = 1;p->next !=0;i++)//cout node number
 793 |         {
 794 |         p = p->next;
 795 |         }
 796 |         if(i == 1)//只有1个数据
 797 |         {
 798 |         	p = head; //直接输出 
 799 | 	        cout<<"英语成绩排序为：\n";  //print 
 800 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"英语"<<'\n';	
 801 |         	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreEnglish<<'\n';
 802 | 		}
 803 | 		else if(i == 2)//只有2个数据
 804 | 		{
 805 | 			p = p1 = head ,p2 = p1->next;//单次比较后输出 
 806 |      		if(p1->scoreEnglish > p2->scoreEnglish)
 807 |     		{
 808 |      			head = p2;
 809 |      			p2->next = p1;
 810 |      			p1->next = 0;
 811 |             } 
 812 |             cout<<"英语成绩排序为：\n";  //print 
 813 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"英语"<<'\n';	
 814 |             while(p != NULL)
 815 |             {
 816 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreEnglish<<'\n';
 817 |                 p = p->next;
 818 |             }
 819 |             p = head;
 820 | 		}
 821 | 		else if( i== 3)//只有3个数据
 822 | 		{
 823 | 			p = p1 = head,p2 = head->next,p3 = p2->next;//3个if实现简单冒泡排序 
 824 |      		if(p1->scoreEnglish > p2->scoreEnglish)
 825 |     		{
 826 | 	    		head = p2;
 827 | 	    		p2->next = p1;
 828 | 	    		p1->next = p3;
 829 | 	    		//结点交换后，p1与p2位置颠倒回来
 830 |                 Node *pTemp;
 831 |                 pTemp = p1;
 832 |                 p1 = p2;
 833 |                 p2 = pTemp;
 834 |                 p = head;
 835 |     		}
 836 |    	    	if(p2->scoreEnglish > p3->scoreEnglish)
 837 | 	    	{
 838 | 	    		p1->next = p3;
 839 | 	    		p3->next = p2;
 840 | 	    		p2->next =0;
 841 | 	    		//结点交换后，p2与p3位置颠倒回来
 842 |                 Node *pTemp;
 843 |                 pTemp = p2;
 844 |                 p2 = p3;
 845 |                 p3 = pTemp;
 846 |                 p = head;
 847 | 	      	}
 848 | 	    	if(p1->scoreEnglish > p2->scoreEnglish)
 849 | 	    	{
 850 | 	    	    head = p2;
 851 | 	    		p2->next = p1;
 852 | 	    		p1->next = p3;
 853 | 	    		//结点交换后，p1与p2位置颠倒回来
 854 |                 Node *pTemp;
 855 |                 pTemp = p1;
 856 |                 p1 = p2;
 857 |                 p2 = pTemp;
 858 |                 p = head;   
 859 |     		} 
 860 |     		cout<<"根据学号排序阅览为：\n"; //print 
 861 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"英语"<<'\n';	
 862 |             while(p != NULL)
 863 |             {
 864 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreEnglish<<'\n';
 865 |                 p = p->next;
 866 |             }
 867 |             p = head;
 868 |  		}
 869 |  		else//3个数据以上 
 870 |  		{
 871 |  			bool flag = 1,pFlag = 0,sortFlag = 0;
 872 |             int temp,n;
 873 |     	    p = p1 = head ,p2 = p1->next,p3=head; 
 874 |     	    for(i = 0,p = head;p->next !=0;i++)//cout node number
 875 |             {
 876 |             	p = p->next;
 877 |           	}
 878 |             for(;i > 0;i--)
 879 |             {
 880 |             	p1 = head ;
 881 |         		p2 = p1->next;
 882 |         		p3=head;
 883 |     	    	flag = 1;
 884 |     	    	sortFlag = 0;//optimize
 885 |             	do
 886 |              	{
 887 |             		if(p2->next == 0)
 888 |     	    		{
 889 |     	    			flag = 0;
 890 |     	    		}
 891 |         	    	if(p1 == head)//method begining
 892 |                 	{
 893 |                 		if(p1->scoreEnglish > p2->scoreEnglish)
 894 |          	        	{
 895 |         	        		Node *pTemp = p2; //copy
 896 |     		        		p1->next = p2->next;
 897 | 	        	    		head = p2;
 898 | 		            	    p2 = pTemp;
 899 | 	        	        	p2->next = p1;
 900 | 	            		    //结点交换后，p1与p2位置颠倒回来
 901 |                             Node *pTemp2;
 902 |                             pTemp2 = p1;
 903 |                         	p1 = p2;
 904 |                         	p2 = pTemp2;
 905 |                         	p = head;
 906 | 		            	}
 907 | 		            	p1 = p1->next;
 908 | 		        	    p2 = p2->next;
 909 | 		    	        if(p2->next == 0)//method ending
 910 | 	                	{
 911 | 		             	if(p1->next->scoreEnglish > p2->next->scoreEnglish)
 912 | 		                	{
 913 | 		                		Node *pTemp = p3;//copy
 914 | 		            	    	p3->next = p2;
 915 | 		            	    	p2->next = p1;
 916 | 	    	            		p1->next = 0;
 917 | 		    	            	//结点交换后，p1与p2位置颠倒回来
 918 |                                 Node *pTemp2;
 919 |                                 pTemp2 = p1;
 920 |                                 p1 = p2;
 921 |                                 p2 = pTemp2;
 922 |                                 p3 = pTemp;  
 923 |                             }   
 924 | 		            	}
 925 | 		            	else//method middle
 926 | 	                 	{
 927 | 	    	            	if(p1->scoreEnglish > p2->scoreEnglish)
 928 | 	    	            	{
 929 | 	    	            		Node *pTemp = p3;//copy
 930 | 	    	            		p3->next = p2;
 931 | 	    	                 	p1->next = p2->next ;
 932 | 	    	            		p2->next = p1;
 933 | 	    	            		//结点交换后，p1与p2位置颠倒回来,p3恢复
 934 |                                 Node *pTemp2;
 935 |                                 pTemp2 = p1;
 936 |                             	p1 = p2;
 937 |                              	p2 = pTemp2;
 938 | 			            		p3 = pTemp;    			
 939 | 		        	    	}
 940 | 	                	}
 941 | 	                //p = head;
 942 | 	                p3 = head;
 943 | 	                }
 944 | 	            	else if(p2->next == 0)//method ending
 945 | 	            	{
 946 | 		            	if(p1->scoreEnglish > p2->scoreEnglish)
 947 | 		             	{
 948 | 		            		Node *pTemp = p3;//copy
 949 | 		            		p3->next = p2;
 950 | 		            		p2->next = p1;
 951 | 	            			p1->next = 0;
 952 | 		            		//结点交换后，p1与p2位置颠倒回来
 953 |                             Node *pTemp2;
 954 |                             pTemp2 = p1;
 955 |                             p1 = p2;
 956 |                             p2 = pTemp2;
 957 |                             p3 = pTemp;    				
 958 | 		             	}
 959 | 	            	}
 960 | 	             	else//method middle
 961 | 	             	{
 962 | 	            		if(p1->scoreEnglish > p2->scoreEnglish)
 963 | 	            		{
 964 | 	            			Node *pTemp = p3;//copy
 965 | 	            	    	p3->next = p2;
 966 | 	            	    	p1->next = p2->next ;
 967 | 	            	    	p2->next = p1;
 968 | 	            			//结点交换后，p1与p2位置颠倒回来,p3恢复
 969 |                             Node *pTemp2;
 970 |                             pTemp2 = p1;
 971 |                             p1 = p2;
 972 |                             p2 = pTemp2;
 973 | 	    	    	    	p3 = pTemp;     			
 974 | 	    	    		}
 975 | 	            	}
 976 | 	    	    	p1 = p1->next;
 977 | 	          		p2 = p2->next;	
 978 | 	     	    	p3 = p3->next;	
 979 | 	         	}while(flag);
 980 |     	    	if(sortFlag) break;	
 981 |             }
 982 |             p = head;
 983 |         	cout<<"英语成绩排序为：\n";  //print 
 984 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"英语"<<'\n';	
 985 |         	while(p != NULL)
 986 |         	{
 987 |         	    cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreEnglish<<'\n';
 988 |                 p = p->next;
 989 |             }
 990 |             p = head;
 991 | 		}
 992 | 		
 993 | 	}
 994 |     system("pause");
 995 | }
 996 | //物理冒泡排序链表内数据 
 997 | void bubbleSort_scorePhysics(Node *head)
 998 | {
 999 | 	system("cls"); 
1000 | 	//冒泡排序核心 
1001 |     Node *p1,*p2,*p3,*p = head; 
1002 |     int i;
1003 |     if(head == 0)//空链表 
1004 |     {
1005 |     	cout<<"系统内没有数据，请使用功能1依次录入：";	
1006 | 	}
1007 | 	else
1008 | 	{
1009 | 		for(i = 1;p->next !=0;i++)//cout node num
1010 |         {
1011 |         p = p->next;
1012 |         }
1013 |         if(i == 1)//只有1个数据
1014 |         {
1015 |         	p = head; 
1016 | 	        cout<<"物理成绩排序为：\n";  //print 
1017 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"物理"<<'\n';	
1018 |         	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scorePhysics<<'\n';
1019 | 		}
1020 | 		else if(i == 2)//只有2个数据
1021 | 		{
1022 | 			p = p1 = head ,p2 = p1->next;
1023 |      		if(p1->scorePhysics > p2->scorePhysics)
1024 |     		{
1025 |      			head = p2;
1026 |      			p2->next = p1;
1027 |      			p1->next = 0;
1028 |             } 
1029 |             cout<<"物理成绩排序为：\n";  //print 
1030 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"物理"<<'\n';	
1031 |             while(p != NULL)
1032 |             {
1033 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scorePhysics<<'\n';
1034 |                 p = p->next;
1035 |             }
1036 |             p = head;
1037 | 		}
1038 | 		else if( i== 3)//只有3个数据
1039 | 		{
1040 | 			p = p1 = head,p2 = head->next,p3 = p2->next;//3个if实现简单冒泡排序 
1041 |      		if(p1->scorePhysics > p2->scorePhysics)
1042 |     		{
1043 | 	    		head = p2;
1044 | 	    		p2->next = p1;
1045 | 	    		p1->next = p3;
1046 | 	    		//结点交换后，p1与p2位置颠倒回来
1047 |                 Node *pTemp;
1048 |                 pTemp = p1;
1049 |                 p1 = p2;
1050 |                 p2 = pTemp;
1051 |                 p = head;
1052 |     		}
1053 |    	    	if(p2->scorePhysics > p3->scorePhysics)
1054 | 	    	{
1055 | 	    		p1->next = p3;
1056 | 	    		p3->next = p2;
1057 | 	    		p2->next =0;
1058 | 	    		//结点交换后，p2与p3位置颠倒回来
1059 |                 Node *pTemp;
1060 |                 pTemp = p2;
1061 |                 p2 = p3;
1062 |                 p3 = pTemp;
1063 |                 p = head;
1064 | 	      	}
1065 | 	    	if(p1->scorePhysics > p2->scorePhysics)
1066 | 	    	{
1067 | 	    	    head = p2;
1068 | 	    		p2->next = p1;
1069 | 	    		p1->next = p3;
1070 | 	    		//结点交换后，p1与p2位置颠倒回来
1071 |                 Node *pTemp;
1072 |                 pTemp = p1;
1073 |                 p1 = p2;
1074 |                 p2 = pTemp;
1075 |                 p = head;   
1076 |     		} 
1077 |     		cout<<"物理成绩排序为：\n";  //print 
1078 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"物理"<<'\n';	
1079 |             while(p != NULL)
1080 |             {
1081 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scorePhysics<<'\n';
1082 |                 p = p->next;
1083 |             }
1084 |             p = head;
1085 |  		}
1086 |  		else//3个数据以上 
1087 |  		{
1088 |  			bool flag = 1,pFlag = 0,sortFlag = 0;
1089 |             int temp,n;
1090 |     	    p = p1 = head ,p2 = p1->next,p3=head; 
1091 |     	    for(i = 0,p = head;p->next !=0;i++)//cout node num
1092 |             {
1093 |             	p = p->next;
1094 |           	}
1095 |             for(;i > 0;i--)
1096 |             {
1097 |             	p1 = head ;
1098 |         		p2 = p1->next;
1099 |         		p3=head;
1100 |     	    	flag = 1;
1101 |     	    	sortFlag = 0;//optimize
1102 |             	do
1103 |              	{
1104 |             		if(p2->next == 0)
1105 |     	    		{
1106 |     	    			flag = 0;
1107 |     	    		}
1108 |         	    	if(p1 == head)//method begining
1109 |                 	{
1110 |                 		if(p1->scorePhysics > p2->scorePhysics)
1111 |          	        	{
1112 |         	        		Node *pTemp = p2; //copy
1113 |     		        		p1->next = p2->next;
1114 | 	        	    		head = p2;
1115 | 		            	    p2 = pTemp;
1116 | 	        	        	p2->next = p1;
1117 | 	            		    //结点交换后，p1与p2位置颠倒回来
1118 |                             Node *pTemp2;
1119 |                             pTemp2 = p1;
1120 |                         	p1 = p2;
1121 |                         	p2 = pTemp2;
1122 |                         	p = head;
1123 | 		            	}
1124 | 		            	p1 = p1->next;
1125 | 		        	    p2 = p2->next;
1126 | 		    	        if(p2->next == 0)//method ending
1127 | 	                	{
1128 | 		             	if(p1->next->scorePhysics > p2->next->scorePhysics)
1129 | 		                	{
1130 | 		                		Node *pTemp = p3;//copy
1131 | 		            	    	p3->next = p2;
1132 | 		            	    	p2->next = p1;
1133 | 	    	            		p1->next = 0;
1134 | 		    	            	//结点交换后，p1与p2位置颠倒回来
1135 |                                 Node *pTemp2;
1136 |                                 pTemp2 = p1;
1137 |                                 p1 = p2;
1138 |                                 p2 = pTemp2;
1139 |                                 p3 = pTemp;  
1140 |                             }   
1141 | 		            	}
1142 | 		            	else//method middle
1143 | 	                 	{
1144 | 	    	            	if(p1->scorePhysics > p2->scorePhysics)
1145 | 	    	            	{
1146 | 	    	            		Node *pTemp = p3;//copy
1147 | 	    	            		p3->next = p2;
1148 | 	    	                 	p1->next = p2->next ;
1149 | 	    	            		p2->next = p1;
1150 | 	    	            		//结点交换后，p1与p2位置颠倒回来,p3恢复
1151 |                                 Node *pTemp2;
1152 |                                 pTemp2 = p1;
1153 |                             	p1 = p2;
1154 |                              	p2 = pTemp2;
1155 | 			            		p3 = pTemp;    			
1156 | 		        	    	}
1157 | 	                	}
1158 | 	                //p = head;
1159 | 	                p3 = head;
1160 | 	                }
1161 | 	            	else if(p2->next == 0)//method ending
1162 | 	            	{
1163 | 		            	if(p1->scorePhysics > p2->scorePhysics)
1164 | 		             	{
1165 | 		            		Node *pTemp = p3;//copy
1166 | 		            		p3->next = p2;
1167 | 		            		p2->next = p1;
1168 | 	            			p1->next = 0;
1169 | 		            		//结点交换后，p1与p2位置颠倒回来
1170 |                             Node *pTemp2;
1171 |                             pTemp2 = p1;
1172 |                             p1 = p2;
1173 |                             p2 = pTemp2;
1174 |                             p3 = pTemp;    				
1175 | 		             	}
1176 | 	            	}
1177 | 	             	else//method middle
1178 | 	             	{
1179 | 	            		if(p1->scorePhysics > p2->scorePhysics)
1180 | 	            		{
1181 | 	            			Node *pTemp = p3;//copy
1182 | 	            	    	p3->next = p2;
1183 | 	            	    	p1->next = p2->next ;
1184 | 	            	    	p2->next = p1;
1185 | 	            			//结点交换后，p1与p2位置颠倒回来,p3恢复
1186 |                             Node *pTemp2;
1187 |                             pTemp2 = p1;
1188 |                             p1 = p2;
1189 |                             p2 = pTemp2;
1190 | 	    	    	    	p3 = pTemp;     			
1191 | 	    	    		}
1192 | 	            	}
1193 | 	    	    	p1 = p1->next;
1194 | 	          		p2 = p2->next;	
1195 | 	     	    	p3 = p3->next;	
1196 | 	         	}while(flag);
1197 |     	    	if(sortFlag) break;	
1198 |             }
1199 |             p = head;
1200 |         	cout<<"物理排序之后为：\n";
1201 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"成绩"<<'\n';	
1202 |         	while(p != NULL)
1203 |         	{
1204 |          	    cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scorePhysics<<'\n';
1205 |                 p = p->next;
1206 |             }
1207 |             p = head;
1208 | 		}		
1209 | 	}
1210 |     system("pause");
1211 | }
1212 | //总分冒泡排序链表内数据 
1213 | void bubbleSort_scoreAll(Node *head)
1214 | {	
1215 |     system("cls"); 
1216 | 	//冒泡排序核心 
1217 |     Node *p1,*p2,*p3,*p = head; 
1218 |     int i;
1219 |     if(head == 0)//空链表 
1220 |     {
1221 |     	cout<<"系统内没有数据，请使用功能1依次录入：";	
1222 | 	}
1223 | 	else
1224 | 	{
1225 | 		for(i = 1;p->next !=0;i++)//cout node num
1226 |         {
1227 |         p = p->next;
1228 |         }
1229 |         if(i == 1)//只有1个数据
1230 |         {
1231 |         	p = head; 
1232 | 	        cout<<"总分成绩排序为：\n";  //print 
1233 |         	cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"总分"<<'\n';	
1234 |         	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreAll<<'\n';
1235 | 		}
1236 | 		else if(i == 2)//只有2个数据
1237 | 		{
1238 | 			p = p1 = head ,p2 = p1->next;
1239 |      		if(p1->scoreAll > p2->scoreAll)
1240 |     		{
1241 |      			head = p2;
1242 |      			p2->next = p1;
1243 |      			p1->next = 0;
1244 |             } 
1245 |             cout<<"总分成绩排序为：\n";  //print 
1246 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"总分"<<'\n';	
1247 |             while(p != NULL)
1248 |             {
1249 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreAll<<'\n';
1250 |                 p = p->next;
1251 |             }
1252 |             p = head;
1253 | 		}
1254 | 		else if( i== 3)//只有3个数据
1255 | 		{
1256 | 			p = p1 = head,p2 = head->next,p3 = p2->next;//3个if实现简单冒泡排序 
1257 |      		if(p1->scoreAll > p2->scoreAll)
1258 |     		{
1259 | 	    		head = p2;
1260 | 	    		p2->next = p1;
1261 | 	    		p1->next = p3;
1262 | 	    		//结点交换后，p1与p2位置颠倒回来
1263 |                 Node *pTemp;
1264 |                 pTemp = p1;
1265 |                 p1 = p2;
1266 |                 p2 = pTemp;
1267 |                 p = head;
1268 |     		}
1269 |    	    	if(p2->scoreAll > p3->scoreAll)
1270 | 	    	{
1271 | 	    		p1->next = p3;
1272 | 	    		p3->next = p2;
1273 | 	    		p2->next =0;
1274 | 	    		//结点交换后，p2与p3位置颠倒回来
1275 |                 Node *pTemp;
1276 |                 pTemp = p2;
1277 |                 p2 = p3;
1278 |                 p3 = pTemp;
1279 |                 p = head;
1280 | 	      	}
1281 | 	    	if(p1->scoreAll > p2->scoreAll)
1282 | 	    	{
1283 | 	    	    head = p2;
1284 | 	    		p2->next = p1;
1285 | 	    		p1->next = p3;
1286 | 	    		//结点交换后，p1与p2位置颠倒回来
1287 |                 Node *pTemp;
1288 |                 pTemp = p1;
1289 |                 p1 = p2;
1290 |                 p2 = pTemp;
1291 |                 p = head;   
1292 |     		} 
1293 |     		cout<<"总分成绩排序为：\n";  //print 
1294 |             cout<<left<<setw(8)<<"姓名"<<setw(6)<<"学号"<<setw(6)<<"总分"<<'\n';	
1295 |             while(p != NULL)
1296 |             {
1297 |             	cout<<left<<setw(8)<<p->name<<setw(6)<<p->num<<setw(6)<<p->scoreAll<<'\n';
1298 |                 p = p->next;
1299 |             }
1300 |             p = head;
1301 |  		}
1302 |  		else//3个数据以上 
1303 |  		{
1304 |  			bool flag = 1,pFlag = 0,sortFlag = 0;
1305 |             int temp,n;
1306 |     	    p = p1 = head ,p2 = p1->next,p3=head; 
1307 |     	    for(i = 0,p = head;p->next !=0;i++)//cout node num
1308 |             {
1309 |             	p = p->next;
1310 |           	}
1311 |             for(;i > 0;i--)
1312 |             {
1313 |             	p1 = head ;
1314 |         		p2 = p1->next;
1315 |         		p3=head;
1316 |     	    	flag = 1;
1317 |     	    	sortFlag = 0;//optimize
1318 |             	do
1319 |              	{
1320 |             		if(p2->next == 0)
1321 |     	    		{
1322 |     	    			flag = 0;
1323 |     	    		}
1324 |         	    	if(p1 == head)//method begining
1325 |                 	{
1326 |                 		if(p1->scoreAll > p2->scoreAll)
1327 |          	        	{
1328 |         	        		Node *pTemp = p2; //copy
1329 |     		        		p1->next = p2->next;
1330 | 	        	    		head = p2;
1331 | 		            	    p2 = pTemp;
1332 | 	        	        	p2->next = p1;
1333 | 	            		    //结点交换后，p1与p2位置颠倒回来
1334 |                             Node *pTemp2;
1335 |                             pTemp2 = p1;
1336 |                         	p1 = p2;
1337 |                         	p2 = pTemp2;
1338 |                         	p = head;
1339 | 		            	}
1340 | 		            	p1 = p1->next;
1341 | 		        	    p2 = p2->next;
1342 | 		    	        if(p2->next == 0)//method ending
1343 | 	                	{
1344 | 		             	if(p1->next->scoreAll > p2->next->scoreAll)
1345 | 		                	{
1346 | 		                		Node *pTemp = p3;//copy
1347 | 		            	    	p3->next = p2;
1348 | 		            	    	p2->next = p1;
1349 | 	    	            		p1->next = 0;
1350 | 		    	            	//结点交换后，p1与p2位置颠倒回来
1351 |                                 Node *pTemp2;
1352 |                                 pTemp2 = p1;
1353 |                                 p1 = p2;
1354 |                                 p2 = pTemp2;
1355 |                                 p3 = pTemp;  
1356 |                             }   
1357 | 		            	}
1358 | 		            	else//method middle
1359 | 	                 	{
1360 | 	    	            	if(p1->scoreAll > p2->scoreAll)
1361 | 	    	            	{
1362 | 	    	            		Node *pTemp = p3;//copy
1363 | 	    	            		p3->next = p2;
1364 | 	    	                 	p1->next = p2->next ;
1365 | 	    	            		p2->next = p1;
1366 | 	    	            		//结点交换后，p1与p2位置颠倒回来,p3恢复
1367 |                                 Node *pTemp2;
1368 |                                 pTemp2 = p1;
1369 |                             	p1 = p2;
1370 |                              	p2 = pTemp2;
1371 | 			            		p3 = pTemp;    			
1372 | 		        	    	}
1373 | 	                	}
1374 | 	                //p = head;
1375 | 	                p3 = head;
1376 | 	                }
1377 | 	            	else if(p2->next == 0)//method ending
1378 | 	            	{
1379 | 		            	if(p1->scoreAll > p2->scoreAll)
1380 | 		             	{
1381 | 		            		Node *pTemp = p3;//copy
1382 | 		            		p3->next = p2;
1383 | 		            		p2->next = p1;
1384 | 	            			p1->next = 0;
1385 | 		            		//结点交换后，p1与p2位置颠倒回来
1386 |                             Node *pTemp2;
1387 |                             pTemp2 = p1;
1388 |                             p1 = p2;
1389 |                             p2 = pTemp2;
1390 |                             p3 = pTemp;    				
1391 | 		             	}
1392 | 	            	}
1393 | 	             	else//method middle
1394 | 	             	{
1395 | 	            		if(p1->scoreAll > p2->scoreAll)
1396 | 	            		{
1397 | 	            			Node *pTemp = p3;//copy
1398 | 	            	    	p3->next = p2;
1399 | 	            	    	p1->next = p2->next ;
1400 | 	            	    	p2->next = p1;
1401 | 	            			//结点交换后，p1与p2位置颠倒回来,p3恢复
1402 |                             Node *pTemp2;
1403 |                             pTemp2 = p1;
1404 |                             p1 = p2;
1405 |                             p2 = pTemp2;
1406 | 	    	    	    	p3 = pTemp;     			
1407 | 	    	    		}
1408 | 	            	}
1409 | 	    	    	p1 = p1->next;
1410 | 	          		p2 = p2->next;	
1411 | 	     	    	p3 = p3->next;	
1412 | 	         	}while(flag);
1413 |     	    	if(sortFlag) break;	
1414 |             }
1415 |             p = head;
1416 |         	cout<<"总分排序之后为：\n";
1417 |         	cout<<left<<setw(8)<<"学号"<<setw(6)<<"成绩"<<'\n';	
1418 |         	while(p != NULL)
1419 |         	{
1420 |          	    cout<<left<<setw(8)<<p->num<<setw(6)<<p->scoreAll<<'\n';
1421 |                 p = p->next;
1422 |             }
1423 |             p = head;
1424 | 		}		
1425 | 	}
1426 |     system("pause");
1427 | }
1428 | //UI界面设计
1429 | void Menu()
1430 | { 
1431 |     system("Cls");  //清空界面完成刷新操作; 
1432 | 	cout<<"                --------------------------\n";
1433 | 	cout<<"               |     学生成绩管理系统     |\n";
1434 | 	cout<<"               |      1.录入学生信息      |\n";
1435 | 	cout<<"               |      2.插入学生成绩      |\n";
1436 | 	cout<<"               |      3.删除学生成绩      |\n";
1437 |     cout<<"               |      4.更改指定成绩      |\n";
1438 |     cout<<"               |      5.查询指定成绩      |\n";
1439 |     cout<<"               |      6.排序全班数学      |\n";
1440 |     cout<<"               |      7.排序全班英语      |\n";
1441 |     cout<<"               |      8.排序全班物理      |\n";
1442 |     cout<<"               |      9.排序全班总分      |\n";
1443 |     cout<<"               |      0.退出MIS系统       |\n";
1444 | 	cout<<"                --------------------------\n";
1445 | }
1446 |  // 菜单命令执行 ;
1447 | void Menu_Order() 
1448 | { 
1449 | 	if(order == 1) {
1450 | 		head = create(head,warmFlag);
1451 | 	}
1452 | 	else if(order == 2){
1453 | 		head = insert(head);
1454 | 	}
1455 | 	else if(order == 3){		
1456 | 		head = delete_node(head);
1457 | 	}
1458 | 	else if(order == 4){
1459 | 		replace(head); 
1460 | 	}
1461 | 	else if(order == 5){
1462 | 		search(head);
1463 | 	}
1464 | 	else if(order == 6){
1465 | 		bubbleSort_scoreMath(head);
1466 | 	}
1467 | 	else if(order == 7){
1468 | 		bubbleSort_scoreEnglish(head);	    
1469 | 	}
1470 | 	else if(order == 8){
1471 | 	    bubbleSort_scorePhysics(head);
1472 | 	}
1473 | 	else if(order == 9){
1474 | 	    bubbleSort_scoreAll(head);
1475 | 	}
1476 | 	else if(order == 0){
1477 | 		{ 
1478 | 		    system("cls");
1479 | 		    char judge;//confirm order
1480 | 		    cout<<"确认要退出吗? Y/N: ";
1481 | 			cin>>judge;
1482 | 			if(judge == 'Y' || judge == 'y')
1483 | 			{
1484 | 	        	cout<<"退出成功！欢迎您下次使用。\n" ;
1485 | 	        	exit(0);
1486 | 	        	system("pause");	
1487 | 			}
1488 | 	    	else 
1489 | 			{
1490 | 				cout<<"取消退出！系统将返回主界面。\n" ;
1491 | 	        	system("pause");
1492 | 			    Menu();	
1493 | 			}
1494 | 		} 
1495 | 	}
1496 | }
1497 | //main function
1498 | int main()
1499 | {
1500 | 	while(1)
1501 | 	{
1502 | 	 	Menu();
1503 | 		cout<<"请在链表下方输入操作指令!\n\n"; 
1504 | 		print(head);
1505 | 		cin>>order;
1506 | 		while((order < 0)||(order > 9))
1507 | 		{	
1508 | 			Menu();	
1509 | 			cout<<"指令有误，请重新输入！"<<endl; 
1510 | 			cout<<"请重新输入操作指令：\n'"; 
1511 | 			cin>>order;
1512 | 			print(head);
1513 | 		}
1514 | 		Menu_Order();
1515 | 	}
1516 | 	return 0;
1517 | }  
1518 | 
1519 | 


--------------------------------------------------------------------------------