魔术师发牌问题C++

Sofia_q

问题：
魔术师手中有A、2、3……J、Q、K十三张黑桃扑克牌。在表演魔术前，魔术师已经将他们按照一定的顺序叠放好（有花色的一面朝下）。魔术表演过程为：一开始，魔术师数1，然后把最上面的那张牌翻过来，是黑桃A；然后将其放到桌面上；第二次,魔术师数1、2；将第一张牌放到这些牌的最下面，将第二张牌翻转过来，正好是黑桃2；第三次，魔术师数1、2、3；将第1、2张牌依次放到这些牌的最下面，将第三张牌翻过来正好是黑桃3；……直到将所有的牌都翻出来为止。问原来牌的顺序是如何的。

思路：需要先创建一个循环链表，包含13个元素，每个元素初始值设置为0；然后用当魔术师手中持牌的点数依次填充循环链表，改变其初始值；最后遍历循环链表，输出魔术师手中持牌的顺序。

1. #include <iostream>
   
2. using namespace std;
   
3. #define N 13
   
4. class Node{
   
5. public:
   
6.         Node *next;
   
7.         int data;         
   
8. };
   
9. 
   
10. class CircleList{
    
11. private:
    
12.         Node *first;
    
13.         int length;
    
14. 
    
15. public:
    
16. //定义如何创建一个循环链表，注意返回头节点
    
17.         Node *creatList(int n){
    
18.                 first=new Node;
    
19.                 Node *s,*r;
    
20.                 r=first;
    
21.                 for(int i=0;i<n;i++){
    
22.                         s=new Node;
    
23.                         s->data=0;
    
24.                         r->next=s;
    
25.                         r=s;
    
26.                 }
    
27.                 r->next=first;
    
28.                 return first;
    
29.                
    
30.         }
    
31.        
    
32.         //清除链表
    
33.         void clearList(){
    
34.                 Node *p=first;
    
35.                 while(p->next!=first){
    
36.                         Node *temp=p->next;
    
37.                         delete p;
    
38.                         p=temp;
    
39.                 }
    
40.         }
    
41.        
    
42.         //遍历。注意由于头节点没有赋值，是系统随机赋值的，
    
43.         //并不是我们想要的结果，所以遍历时会将first节点跳过。
    
44.         //若first节点单独赋值，并希望打印出来，则P节点和循环结束条件有所不同
    
45.         void traverse(){
    
46.                 Node *p=first->next;
    
47.                 while (p!=first){  
    
48.                         cout<<p->data<<"\t";
    
49.                         p=p->next;
    
50.                 }
    
51.         }
    
52. 
    
53. };
    
54. 
    
55. //魔术师的牌排列顺序实现。传入一个循环链表的头节点，给循环链表的节点重新赋值，得到牌的顺序
    
56. void magic(Node *pokerHead){
    
57.     //对于头节点要不要使用，是否要单独赋值的细节处理不同
    
58.     //则遍历的细节也不同
    
59.         //Node *poker=pokerHead;  //使用头节点的方式
    
60.         Node *poker=pokerHead->next;    //不使用头节点的方式
    
61.         poker->data=1;
    
62.         int countNum=2;
    
63.         while(1){
    
64.                 for(int i=0;i<countNum;i++){
    
65.                         poker=poker->next;
    
66.                         if(poker->data!=0){
    
67.                                 i--;
    
68.                         }
    
69. 
    
70.                 }
    
71.                 if(poker->data==0){
    
72.                         poker->data=countNum;
    
73.                         countNum++;
    
74.                         if(countNum>N) break;
    
75.                 }
    
76.         }
    
77. }
    
78. void display(Node *pokerHead){
    
79.     /*
    
80.     //使用头节点的遍历方式
    
81.         Node *p=pokerHead;
    
82.         while(p->next!=pokerHead){  
    
83.         cout<<p->data<<"\t";
    
84.                 p=p->next;
    
85.         }
    
86.         cout<<p->data;
    
87.         */
    
88.        
    
89.         //不使用头节点的遍历方式
    
90.         Node *p=pokerHead->next;
    
91.         while(p!=pokerHead){
    
92.                 cout<<p->data<<"\t";
    
93.                 p=p->next;
    
94.         }
    
95. }
    
96. 
    
97. int main(){
    
98.        
    
99.         CircleList circle1;
    
100.         Node *p=circle1.creatList(N);
     
101.         circle1.traverse();
     
102.         cout<<"-----"<<endl;
     
103.         magic(p);
     
104.         display(p);
     
105.         return 0;
     
106. }

复制代码