[已解决]程序死循环，找不出原因

孤不冷cing

1.   7 int main()
   
2.   8 {
   
3.   9         int a[3][18]={0};// 用于存放54个不重复的、[1,54]内的整数，并把他们分成三组
   
4. 10         int (*p)[3][18]=&a;// 用于修改数组a中的值
   
5. 11         int i,j,m,n;
   
6. 12         int t;
   
7. 13         int s=100;
   
8. 14         int count=-1;// 后面用来与i比较，作为判断条件。因为是与i比较，所以初始化为-1。
   
9. 15         
   
10. 16         for(i=0; i<3; i++)// 为每一个a中的元素赋值
    
11. 17         {
    
12. 18                 srand(s++);
    
13. 19                 for(j=0; j<18; j++)
    
14. 20                 {
    
15. 21                         t = rand()%54+1;// 用中间变量t存储获得的随机数
    
16. 22                         for(m=i; m>=0; m--)// 靠n的值来判断随机数是否与之前获得的所有>    随机数都不相同
    
17. 23                         {
    
18. 24                                 for(n=17; n>=0; n--)
    
19. 25                                 {
    
20. 26                                         if(t==a[m][n])
    
21. 27                                                 break;
    
22. 28                                 }
    
23. 29                                 if(n==-1)// 说明这一层里没有重复
    
24. 30                                         count++;// 说明处理完了一层数组
    
25. 31                         }
    
26. 32                         if(n==-1 && count==i)
    
27. 33                         // 这个地方的判断有问题，单纯这一个条件，检测一维数组是否全部不相同没问题，但检测多维数组不行，因为m>0时，每次循环完，n必然为-1
    
28. 34                         // 这里的count表示n==-1条件满足了count+1次
    
29. 35                         {
    
30. 36                                 (*p)[i][j]=t;
    
31. 37                         }
    
32. 38                                 
    
33. 39                         else
    
34. 40                         {
    
35. 41                                 srand(s++);
    
36. 42                                 j--;
    
37. 43                         }
    
38. 44                 }
    
39. 45         }
    
40. 46
    
41. 47         for(i=0; i<3; i++)// 打印a中所有元素
    
42. 48         {
    
43. 49                 for(j=0; j<18; j++)
    
44. 50                 {
    
45. 51                         printf("%d\n", a[i][j]);
    
46. 52                 }
    
47. 53         }
    
48. 54
    
49. 55         return 0;
    
50. 56 }
    

复制代码

1.   8 int main()
   
2.   9 {
   
3. 10         int a[54]={0};// 用于存放54个不重复的、[1,54]内的整数
   
4. 11         int (*p)[54]=&a;// 用于修改数组a中的值
   
5. 12         int i,j;
   
6. 13         int t;
   
7. 14         int s=100;
   
8. 15         //int count=-1;// 后面用来与i比较，作为判断条件。因为是与i比较，所以初始化为-1    。
   
9. 16
   
10. 17         for(i=0; i<54; i++)// 为每一个a中的元素赋值
    
11. 18         {
    
12. 19                 srand(s++);// 刷新seed，为了防止程序执行太快，把刷新放在循环外
    
13. 20                 t = rand()%54+1;// 用中间变量t存储获得的随机数
    
14. 21                 for(j=i; j>=0; j--)// 靠j的值来判断随机数是否与之前获得的所有随机数都>    不相同
    
15. 22                 {
    
16. 23                         if(t==a[j])
    
17. 24                                 break;
    
18. 25                 }
    
19. 26                 if(j==-1)
    
20. 27                 {
    
21. 28                         (*p)[i]=t;
    
22. 29                         //printf("%d\n", t);
    
23. 30                 }
    
24. 31                 else
    
25. 32                 {
    
26. 33                         srand(s++);
    
27. 34                         i--;
    
28. 35                 }
    
29. 36         }
    
30. 37
    
31. 38         for(i=0; i<54; i++)// 打印a中所有元素
    
32. 39         {
    
33. 40                 printf("%d ", a[i]);
    
34. 41         }
    
35. 42         putchar('\n');
    
36. 43
    
37. 44         // 以下代码用于排序数组，以便检查是否满足无重复并且数量正好的要求
    
38. 45         int b,c,d;
    
39. 46         for(b=54;b>=0;b--)
    
40. 47         {
    
41. 48                 for(c=0;c<b;c++)
    
42. 49                 {
    
43. 50                         if(a[c]>a[c+1])
    
44. 51                         {
    
45. 52                                 d=a[c];
    
46. 53                                 a[c]=a[c+1];
    
47. 54                                 a[c+1]=d;
    
48. 55                         }
    
49. 56                 }
    
50. 57         }
    
51. 58
    
52. 59         for(i=0; i<54; i++)// 打印a中所有元素
    
53. 60         {
    
54. 61                 printf("%d ", a[i]);
    
55. 62         }
    
56. 63         putchar('\n');
    
57. 64
    
58. 65         return 0;
    
59. 66 }
    

复制代码

为什么第一个程序一直在循环啊，我找不出来死循环的原因
第二个就可以成功，啪一下就出结果了

最佳答案

月排行榜 / 总排行榜

jhq999

2022-4-19 12:59:37

在内存里都是一维数组，多维数组声明只不过是给编译器看的，你也可以理解成一根绳子长54（p[54])，折成3段，每段长18(a[3][18]),其实就是同一根绳子
反过来
int p[54];
int (*a)[18]=(int(*)[18])p;

跳转到最佳答案楼层

jhq999

在内存里都是一维数组，多维数组声明只不过是给编译器看的，你也可以理解成一根绳子长54（p[54])，折成3段，每段长18(a[3][18]),其实就是同一根绳子
反过来
int p[54];
int (*a)[18]=(int(*)[18])p;

风车呼呼呼

想问一下，2*1的矩阵为什么能存放54个整数？三组是怎么分出来的，按行分也只有两行而已

1. int a[2][1]={0};// 用于存放54个不重复的、[1,54]内的整数，并把他们分成三组

复制代码

孤不冷cing

风车呼呼呼 发表于 2022-4-19 13:12
想问一下，2*1的矩阵为什么能存放54个整数？三组是怎么分出来的，按行分也只有两行而已

啊，本来是3*18的，我后面怀疑是不是因为程序运行时间太久了，所以把3*18改成了2*1，然后运行程序还是没反应

jhq999

42                                 j--;//这里所有条件没变，j减一无限循环

孤不冷cing

jhq999 发表于 2022-4-19 20:50
42                                 j--;//这里所有条件没变，j减一无限循环

什么意思，这个j--不是随机数不满足条件才会执行吗。
它上面的srand不是会刷新seed吗，总该有随机数满足条件，这个j--不执行的时候吧。

jhq999

孤不冷cing 发表于 2022-4-19 20:55
什么意思，这个j--不是随机数不满足条件才会执行吗。
它上面的srand不是会刷新seed吗，总该有随机数满足 ...

题外话随机种子一次就够了，想每次运行不同用srand(time(0));
我就看到这一个在for循环的循环体里改变循环数的，出毛病应该是它，至于为啥可能随机数重复

孤不冷cing

jhq999 发表于 2022-4-19 21:29
题外话随机种子一次就够了，
我就看到这一个在for循环的循环体里改变循环数的，出毛病应该是它，至于为 ...

随机种子不更新的话，每次出来的rand()不都是一样的吗，我看网上的讲解是这样说的。
可是我第一个和第二个的逻辑一样的呀，第二个没问题，第一个不应该会死循环呀。

孤不冷cing

我好像知道为什么死循环了，因为我没有重置count。
第一次进行完之后，后面都不会满足i==count，所以一直在j--。

jhq999

斗地主洗牌？不是斗地主，没有扣3张牌

1. #include <stdlib.h>
   
2. #include <time.h>
   
3. int main() {
   
4.         int a[3][18]={0};
   
5.         int *p=(int*)a,i=0,j=0,tmp=0;
   
6.         for (i = 0; i < 54; i++)
   
7.         {
   
8.                 p[i]=i+1;
   
9.         }
   
10.         srand(time(0));
    
11.         for (i = 0; i <54; i++)
    
12.         {
    
13.                 j=rand()%(54-i)+i;
    
14.                 tmp=p[i];
    
15.                 p[i]=p[j];
    
16.                 p[j]=tmp;
    
17.         }
    
18.         for(i=0; i<3; i++)// 打印a中所有元素
    
19.         {
    
20.                 for(j=0; j<18; j++)
    
21.                 {
    
22.                         printf("%d\n", a[i][j]);
    
23.                 }
    
24.         }
    
25.         return 0;
    
26. }

复制代码

孤不冷cing

jhq999 发表于 2022-4-19 21:46
斗地主洗牌？不是斗地主，没有扣3张牌

我发现我那个为什么死循环了，我没重置count。
你这个是把a强制转换成指针了赋给p，然后以一维数组形式给a赋值是吗。
int *p=(int *)a这里我有点陌生，是怎么个道理啊，让类型一致是吗。我只知道int *p=a会说把整数赋给整型指针这样的警告，没试过你这样的写法。
能解释一下吗

孤不冷cing

jhq999 发表于 2022-4-19 12:59
在内存里都是一维数组，多维数组声明只不过是给编译器看的，你也可以理解成一根绳子长54（p[54])，折成3段 ...

多维数组在内存里是一维数组我知道，我不是问这个
我不明白的点是：像(int *)这样的强制类型转换，什么时候能用，用了有什么效果，可能会出什么错误

jhq999

孤不冷cing 发表于 2022-4-19 23:43
多维数组在内存里是一维数组我知道，我不是问这个
我不明白的点是：像(int *)这样的强制类型转换，什么 ...

需要时候就用呗，就像我的那个，如果是用2维数组，多麻烦，计算好数组长度别越界。