数字移动

2019年12月7日 248次阅读

题目如下：

 

在图中的九个点上,空出中间的点,其余的点上任意填入数字1到8;1的位置固定不动,然后移动其余的数字,使1到8顺时针从小到大排列.移动的规律是:只能将数字沿线移向空白的点.请编程显示数字移动过程。

《数字移动》

最近一直在做题，因为要参加一个考试了，所以每次做出来的题都写写博客，记录一下，或者也可以帮助到学习的同学。我再次感到自己菜到不得了，没看到高手的时候就以为自己是高手，见到高手的时候发现自己什么都不是，一直学习，不断学习，哪个行业都一样。所以学编程的同学们，加油了，一起学习。

 

我分析一下：

上面图的8个圈可以用数组表示就可以，用链表什么也可以，其实个人觉得数组就可以了，而且处理简单。嗯，首先用一个数组作为这8个圈，中间的圈用一个整形变量就可以。因为1的位置固定不动，先把1的位置找出来，然后2到8循环处理。for2-8，例如找2的时候，先判断2是否在1的后面，也就是数组的下一个数字是否是2，假如是2就continue处理下一个，假如不是，用中间变量保存数字2，然后之前的数字逐个向后移动，移动完将中间变量的2移动到对应的位置上。这里有个问题就是数组边界的问题，简单处理一下就可以了，超过7就从0开始。

 

 
 
    
  
  
  1. public class Test100 { 
    2. 
  
  
  2.  
    3. 
  
  
  3.     public static void main(String[] args) { 
    4. 
  
  
  4.         /** 
    5. 
  
  
  5.          * 假如arr为图中的环形的圈，数组是圈内数字 
    6. 
  
  
  6.          * 变量em为图中间的圈 
    7. 
  
  
  7.          */ 
    8. 
  
  
  8. //      int[] arr = {8, 2, 1, 5, 3, 6, 4, 7} ; 
    9. 
  
  
  9.         int[] arr = {5, 2, 3, 1, 8, 6, 4, 7} ; // 当前填充的数组 
    10. 
  
  
  10.         int em ; // em为中间的圈等于要下一个要处理的数字 
    11. 
  
  
  11.         int sum = 0 ; // 一共的移动次数 
    12. 
  
  
  12.          
    13. 
  
  
  13.         int index1 = 0 ; // 数字1的数组下标 
    14. 
  
  
  14.         for(int i = 0; i < 8; i++) { // 查找数字1的下标 
    15. 
  
  
  15.             if(arr[i] == 1) { 
    16. 
  
  
  16.                 index1 = i ; 
    17. 
  
  
  17.             } 
    18. 
  
  
  18.         } 
    19. 
  
  
  19.          
    20. 
  
  
  20. //      System.out.println("index1: " + index1) ; 
    21. 
  
  
  21.          
    22. 
  
  
  22.         int t = 0 ; // 下一个要处理的数的下标 
    23. 
  
  
  23.         int indexN = 0 ; // 下一个数的当前位置 
    24. 
  
  
  24.         for(int n = 2; n <= 8; n++) { // 从2到8一个个找， 
    25. 
  
  
  25.             t = index1+n-1 > 7 ? index1+n-1 - 8 : index1+n-1 ; // 找下一个的座标是哪里  
    26. 
  
  
  26.             if(arr[t] == n) // 假如下一个数是下一个座标的位置上，跳过不用处理 
    27. 
  
  
  27.                 continue ; 
    28. 
  
  
  28.             for(int j = 0; j < 8; j++) { 
    29. 
  
  
  29.                 if(arr[j] == n) { 
    30. 
  
  
  30.                     indexN = j ; 
    31. 
  
  
  31.                     break ; 
    32. 
  
  
  32.                 } 
    33. 
  
  
  33.             } 
    34. 
  
  
  34.              
    35. 
  
  
  35.             em = arr[indexN] ; // em为中间的圈等于要下一个要处理的数字 
    36. 
  
  
  36.             System.out.println("数字" + arr[indexN] + "从" + indexN + "移动到" + "em") ; 
    37. 
  
  
  37. //          System.out.println("下一个要处理的下标t :" + t + ", 下一个数的当前位置indexN :" + indexN + ", em :" + em) ; 
    38. 
  
  
  38.              
    39. 
  
  
  39.             if(t > indexN) { // 下一个要处理的位置是否大于下一个数当前在的位置 
    40. 
  
  
  40.                 for(int k = indexN; k > 0; k--) { 
    41. 
  
  
  41.                     arr[k] = arr[k-1] ; 
    42. 
  
  
  42.                     sum++ ; 
    43. 
  
  
  43.                     System.out.println("数字" + arr[k-1] + "从" + (k-1) + "移动到" + k) ; 
    44. 
  
  
  44.                 } 
    45. 
  
  
  45.                 arr[0] = arr[7] ; // 过0处理，两个for 
    46. 
  
  
  46.                 System.out.println("数字" + arr[7] + "从" + 7 + "移动到" + 0) ; 
    47. 
  
  
  47.                 sum++ ; 
    48. 
  
  
  48.                 for(int k = 7; k > t; k--) { 
    49. 
  
  
  49.                     arr[k] = arr[k-1] ; 
    50. 
  
  
  50.                     System.out.println("数字" + arr[k-1] + "从" + (k-1) + "移动到" + k) ; 
    51. 
  
  
  51.                     sum++ ; 
    52. 
  
  
  52.                 } 
    53. 
  
  
  53.             }else if(t < indexN) { 
    54. 
  
  
  54.                 for(int k = indexN; k > t; k--) { 
    55. 
  
  
  55.                     arr[k] = arr[k-1] ; 
    56. 
  
  
  56.                     System.out.println("数字" + arr[k-1] + "从" + (k-1) + "移动到" + k) ; 
    57. 
  
  
  57.                     sum++ ; 
    58. 
  
  
  58.                 } 
    59. 
  
  
  59.             } 
    60. 
  
  
  60.             arr[t] = em ; 
    61. 
  
  
  61.             System.out.println("数字" + em + "从" + "em" + "移动到" + t) ; 
    62. 
  
  
  62.             sum++ ; 
    63. 
  
  
  63.             for(int i : arr) { 
    64. 
  
  
  64.                 System.out.print(i + ", ") ; 
    65. 
  
  
  65.             } 
    66. 
  
  
  66.             System.out.println() ; 
    67. 
  
  
  67.         } 
    68. 
  
  
  68.          
    69. 
  
  
  69.         System.out.println("移动次数：" + sum) ; 
    70. 
  
  
  70.  
    71. 
  
  
  71.     } 
    72. 
  
  
  72.  
    73. 
  
  
  73. } 
    74. 
 
 
其实我个人觉得这个题就是数组的越界回0处理，没有什么特别的。只是实现起来会有些纠结，其他别太多算法要想的
总体来讲，还是比较简单的。

 

 

点赞