[已解决]魔术师发牌问题

冰逸琉璃

就是术师利用一副牌中的13张黑牌，预先将他们排好后叠放在一起，牌面朝下，魔术师将最上面的那张牌数为1，把他翻过来正好是黑桃A, 将黑桃A放到桌面上，第二次数1,2将第一张牌放在这些牌的下面，将第二张牌翻过来，正好是黑桃2， 也将它放在桌子上这样依次进行将13张牌全部翻出，准确无误。我是这样写的，感觉没有错误，但是运行出来不对，看了一天也没看出那错了，请教下大佬们
#include <stdio.h>
#include <stdlib.h>

#define MAX 13

typedef struct node
{
        int num;
        struct node* next;
}node;

node* initialization();//创建循环链表
void sort(node* p);//排序牌顺序

node* initialization()//创建链表
{
        node* head = NULL;
        node* s;//节点
        node* r = NULL;//指向最后一个节点

        for (int i = 0; i < MAX; i++)
        {
                s = (node*)malloc(sizeof(node));
                if (s == NULL)
                {
                        exit(1);
                }
                s->num = 0;
                if (head == NULL)
                {
                        head = s;
                        s->next = head;

                        r = head;
                }
                else
                {
                        r->next = s;
                        s->next = head;

                        r = s;
                }
        }
        return head;
}

void sort(node* p)//排序牌顺序
{
        node* head = p;
        int number = 2;
        int j;

        head->num = 1;

        while (1)
        {
                for (j = 0; j < number; j++)
                {
                        head = head->next;

                        if (head->num != 0)
                        {
                                head = head->next;
                                j--;
                        }
                }
                head->num = number++;

                if (number == MAX + 1)
                {
                        break;
                }
        }
}

int main(void)
{
        node* p;

        p = initialization();
        sort(p);

        for (int i = 0; i < MAX; i++)
        {
                printf("%d ", p->num);
                p = p->next;
        }

        return 0;
}

最佳答案

月排行榜 / 总排行榜

人造人

2021-6-7 21:09:00

类似这样的代码，没有意义，什么事情也不做

1. #include <stdio.h>
   
2. 
   
3. int main(void) {
   
4.     1;
   
5.     2;
   
6.     3;
   
7.     100;
   
8.     ;
   
9.     ;
   
10.     int i = 100;
    
11.     i + 1;
    
12.     i;
    
13.     printf("%d\n", i);
    
14.     printf("hello world!\n");
    
15.     return 0;
    
16. }
    

复制代码

跳转到最佳答案楼层

人造人

类似这样的代码，没有意义，什么事情也不做

1. #include <stdio.h>
   
2. 
   
3. int main(void) {
   
4.     1;
   
5.     2;
   
6.     3;
   
7.     100;
   
8.     ;
   
9.     ;
   
10.     int i = 100;
    
11.     i + 1;
    
12.     i;
    
13.     printf("%d\n", i);
    
14.     printf("hello world!\n");
    
15.     return 0;
    
16. }
    

复制代码

不能懒

代码在哪里

万千只cnm

截图太糊了   
复制过来呀

冰逸琉璃

万千只cnm 发表于 2021-6-7 21:28
截图太糊了   
复制过来呀

嗷嗷

人造人

你这个程序使用的是什么样的算法？
这个程序再我看来，使用递归的思想是不错的
首先把已经摆好的牌从上到下编号
要想摆好第1张，先要把第2张摆好，第2张要求先摆第3张
也就是先摆第13张然后是第12张。。。然后是第2张，然后是第1张
应该是倒着来的

完全就是取牌时候的反向操作

1. #include <iostream>
   
2. #include <list>
   
3. 
   
4. std::ostream &operator<<(std::ostream &os, const std::list<size_t> &rhs) {
   
5.     for(const auto &i: rhs) os << i << " ";
   
6.     return os;
   
7. }
   
8. 
   
9. int main() {
   
10.     std::list<size_t> list;
    
11.     for(size_t i = 13; i > 0; --i) {
    
12.         list.push_front(i);
    
13.         for(size_t j = 1; j < i; ++j) {
    
14.             size_t temp = list.back();
    
15.             list.pop_back();
    
16.             list.push_front(temp);
    
17.         }
    
18.     }
    
19.     std::cout << list << std::endl;
    
20.     return 0;
    
21. }
    

复制代码

冰逸琉璃

人造人 发表于 2021-6-8 10:40
你这个程序使用的是什么样的算法？
这个程序再我看来，使用递归的思想是不错的
首先把已经摆好的牌从上到 ...

我这么想的，首先在位置1上放第一张牌，把number初始化为2(用来计下一次要走的步数)，进入for循环 (j = 0; j < number ; j++) 后也就是走两步，if判断到这个位置已经放过牌的话j-1，然后再往前走一步，走完后让number加1，然后在这个位置上放牌        。可能我表达的不是太清楚

人造人

冰逸琉璃 发表于 2021-6-8 16:21
我这么想的，首先在位置1上放第一张牌，把number初始化为2(用来计下一次要走的步数)，进入for循环 (j = 0 ...

看不懂你的想法，我认为你的方法无法实现这个题目要求
要想摆好第1张，先要把第2张摆好，第2张要求先摆第3张
也就是先摆第13张然后是第12张。。。然后是第2张，然后是第1张
我认为应该是倒着来的
我不知道怎样才能正着摆好所有的牌
你第1张牌应该摆在哪里？不知道吧？应该把第2张牌先摆好才能摆第1张牌吧？

冰逸琉璃

人造人 发表于 2021-6-8 17:58
看不懂你的想法，我认为你的方法无法实现这个题目要求
要想摆好第1张，先要把第2张摆好，第2张要求先摆 ...

改了这个地方以后好像就没问题了，之前应该是把Nhead->next写成Nhead=Nhead->next。
我现在就是还不理解这个Nhead->next是什么意思，和Nhead=Nhead->next有什么区别

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #define MAX 13
   
5. 
   
6. typedef struct node
   
7. {
   
8.         int num;
   
9.         struct node* next;
   
10. }node;
    
11. 
    
12. node* initialization();
    
13. void sort(node* head);
    
14. 
    
15. node* initialization()
    
16. {
    
17.         node* head = NULL;
    
18.         node* s;
    
19.         node* r = NULL;
    
20. 
    
21.         for (int i = 0; i < MAX; i++)
    
22.         {
    
23.                 if (head == NULL)
    
24.                 {
    
25.                         head = (node*)malloc(sizeof(node));
    
26.                         if (head == NULL)
    
27.                         {
    
28.                                 exit(1);
    
29.                         }
    
30.                         head->num = 0;
    
31. 
    
32.                         head->next = head;
    
33. 
    
34.                         r = head;
    
35.                 }
    
36.                 else
    
37.                 {
    
38.                         s = (node*)malloc(sizeof(node));
    
39.                         if (s == NULL)
    
40.                         {
    
41.                                 exit(1);
    
42.                         }
    
43.                         s->num = 0;
    
44. 
    
45.                         r->next = s;
    
46.                         s->next = head;
    
47. 
    
48.                         r = s;
    
49.                 }
    
50.         }
    
51.         return head;
    
52. }
    
53. 
    
54. void sort(node* head)
    
55. {
    
56.         node* Nhead = head;
    
57.         int number = 2;
    
58.         int j;
    
59. 
    
60.         Nhead->num = 1;
    
61. 
    
62.         while (1)
    
63.         {
    
64.                 for (j = 0; j < number; j++)
    
65.                 {
    
66.                         Nhead = Nhead->next;
    
67. 
    
68.                         if (Nhead->num != 0)
    
69.                         {
    
70.                                 Nhead->next;//改了这里
    
71.                                 j--;
    
72.                         }
    
73.                 }
    
74. 
    
75.                 if (Nhead->num == 0)
    
76.                 {
    
77.                         Nhead->num = number++;
    
78. 
    
79.                         if (number == MAX + 1)
    
80.                         {
    
81.                                 break;
    
82.                         }
    
83.                 }
    
84.         }
    
85. }
    
86. 
    
87. int main(void)
    
88. {
    
89.         node* head = NULL;
    
90. 
    
91.         head = initialization();
    
92.         sort(head);
    
93. 
    
94.         for (int i = 0; i < MAX; i++)
    
95.         {
    
96.                 printf("%d ", head->num);
    
97.                 head = head->next;
    
98.         }
    
99. 
    
100.         return 0;
     
101. }

复制代码

冰逸琉璃

人造人 发表于 2021-6-8 17:58
看不懂你的想法，我认为你的方法无法实现这个题目要求
要想摆好第1张，先要把第2张摆好，第2张要求先摆 ...

依旧是从第一张开始排的

人造人

冰逸琉璃 发表于 2021-6-8 19:57
依旧是从第一张开始排的

Nhead->next;//改了这里
这条语句没有意义，这条语句什么也不做，去掉也完全没问题

冰逸琉璃

人造人 发表于 2021-6-8 20:03
类似这样的代码，没有意义，什么事情也不做

哈哈哈，懂了 ，万分感谢，突然感觉好丢人，就这么点事还来问