为什么调用exchange方法就排不了顺序？

1. class ArraySort
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr={12,5,3,89,30,2,31};
   
6.                 selectSort(arr);
   
7.                 printArray(arr);
   
8.                
   
9.         }
   
10. 
    
11.         public static void selectSort(int[] arr)
    
12.         {
    
13.                 for(int x=0;x<arr.length-1;x++)
    
14.                 {
    
15.                         for(int y=x+1;y<arr.length;y++)
    
16.                         {
    
17.                                 if(arr[x]>arr[y])
    
18.                                 {
    
19.                                         exchange(arr[x],arr[y]);
    
20.                                 }
    
21. 
    
22.                         /*
    
23.                                 为什么上面写        int temp=arr[x];
    
24.                                                 arr[x]=arr[y];
    
25.                                                 arr[y]=temp;
    
26.                                 可以排序，而调用exchange就不会排序，而是按原来的顺序打印出来呢？
    
27.                        
    
28. 
    
29.                         */
    
30.                                
    
31.                         }
    
32.                 }
    
33.         }
    
34.        
    
35.         public static void printArray(int[] arr)
    
36.         {
    
37.                 System.out.print("[");
    
38.                 for(int x=0;x<arr.length;x++)
    
39.                 {
    
40.                         if(x!=arr.length-1)
    
41.                                 System.out.print(arr[x]+",");
    
42.                         else
    
43.                                 System.out.println(arr[x]+"]");
    
44.                 }
    
45.         }
    
46. 
    
47.         public static void exchange(int x,int y)
    
48.         {
    
49.                
    
50.                
    
51.                 {
    
52.                         int temp=x;
    
53.                         x=y;
    
54.                         y=temp;
    
55.                 }
    
56. 
    
57.         }
    
58.        
    
59. }
    
60. 
    
61. 
    
62. 
    
63. 
    
64. 
    
65. 
    
66. 
    
67. 
    
68. 
    
69. 
    
70. 
    
71. 
    
72. 
    
73. 
    
74. 
    
75. 
    
76. 
    
77. 
    
78. 
    
79. 
    
80. 
    
81. 
    
82. 
    
83. 
    
84. 
    
85. 
    
86. 
    
87. 
    
88. 
    
89. 
    
90. 
    
91. 
    
92. 
    
93. 
    
94. 
    
95. 
    
96. 
    
97. 
    
98. 
    
99. 
    
100. 
     
101. 
     
102. 
     
103. 
     
104. 
     
105. 
     
106. 
     
107. 
     
108. 
     
109. 
     
110. 
     
111. 
     
112. 
     
113. 
     
114. 
     
115. 
     
116. 
     

复制代码

你的exchange方法的形式参数是int型的，也就是基本类型，当传入实际参数的时候，传的原变量值的拷贝，而不是引用，所以，你在exchange方法中修改x,y的操作，不会改变原来变量的值！
public static void exchange(int[] arr, int x,int y)
        {
      
                {
                        int temp=arr[x];
                        arr[x]=arr[y];
                        arr[y]=temp;
                }

        }
改成这样就可以了
        

其实你要弄明白的就是你那个excheng();函数式没有返回值的，所以你传x,y进去是没有办法把调过来的数值返回来的，但你在方法里面直接实现就不会有这个问题。
public static void exchange(int arr[],int x,int y)
        {
                {
                        int temp=arr[x];
                        arr[x]=arr[y];
                        arr[y]=temp;
                }
        }  


这样的效果就不一样，数组一直在内存里，在这里传x,y值进来直接就把数组的两个值交换，数组就变了。
希望有技术分吧，纯手打不容易，大半夜的

数组反转问题


请看下这篇帖子二楼的回答，解释得非常清楚到位

是这么个道理~

你的方法错了，自然就无法正确输出结果。

谢谢大家！

1. package test.test;
   
2. 
   
3. class Sort
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 int[] arr={12,5,3,89,30,2,31};
   
8.                 printArray(arr); //排序前
   
9.                 selectSort(arr);
   
10.                 printArray(arr); //排序后
    
11.                
    
12.         }
    
13. 
    
14.         public static void selectSort(int[] arr)
    
15.         {
    
16.                 for(int x=0;x<arr.length-1;x++)
    
17.                 {
    
18.                         for(int y=x+1;y<arr.length;y++)
    
19.                         {
    
20.                                 if(arr[x]>arr[y])
    
21.                                 {
    
22.                                                 //因为要操作的是数组中的角标的位置。所以这里应该有三个参数，一个是数组，还有两个代表角标位
    
23.                                         exchange(arr, x, y);
    
24.                                 }
    
25. 
    
26.                         /*
    
27.                                 为什么上面写        int temp=arr[x];
    
28.                                                 arr[x]=arr[y];
    
29.                                                 arr[y]=temp;
    
30.                                 可以排序，而调用exchange就不会排序，而是按原来的顺序打印出来呢？
    
31.                         
    
32. 
    
33.                         */
    
34.                                 
    
35.                         }
    
36.                 }
    
37.         }
    
38.         
    
39.         public static void printArray(int[] arr)
    
40.         {
    
41.                 System.out.print("[");
    
42.                 for(int x=0;x<arr.length;x++)
    
43.                 {
    
44.                         if(x!=arr.length-1)
    
45.                                 System.out.print(arr[x]+",");
    
46.                         else
    
47.                                 System.out.println(arr[x]+"]");
    
48.                 }
    
49.         }
    
50. 
    
51.         public static void exchange(int[] arr, int x, int y)
    
52.         {
    
53.                
    
54.                
    
55.                 {
    
56.                         int temp=arr[x];
    
57.                         arr[x]=arr[y];
    
58.                         arr[y]=temp;
    
59.                 }
    
60. 
    
61.         }
    
62.         
    
63. }
    

复制代码

NewDemo 发表于 2014-4-18 00:08
数组反转问题

谢谢，终于有人夸了，一起努力哈