有个小程序,大家看一下

Question

题目:编写一个程序,用选择法对数组a[]={20,10,50,40,30,70,60,80,90,100}进行由大到小排序第一个问题:什么叫选择法?第二个问题:怎么能够让一串数按大小排列?我想了半天,开始是想用个for循环实现
                      for(int i=0;i<a.length;i++)
                   {
                         if(a[i]>a[i+1]
                         {
                              int temp=a[i];
                              a[i]=a[i+1];
                              a[i+1]=temp;
                         }
                    }
          正好又这么小段代码,顺便问个基础问题,for语句后必须要加方法体吗?也就是必须要又{}?
          这里是不是有语法错误?是能编译通过,但是运行的时候总是出错,提示的错误莫名其妙,我也看不太懂,不知道怎么回事?
          后来我又想了一下,其实如果能编译过去,也实现不了从大到小排列的目的,只能是前后两两比较;我是个新手,多谢大家给与帮助!!!!

Answer 1

INT [] A[]=20,10,50,40,30,70,60,80,90,100}；
FOR（INT I=0；I<A.LENGTH;I++）
{
   INT MARK=I;
FOR (INT J=I+1;J<A.LENGTH;J++)
{
IF(A[MARK]<A[J])
{
MARK=J;
}
}
IF(MARK != J)
{
A[MARK]=A[MARK]+A[J];
A[J]=A[MARK]-A[J];
A[MARK]=A[MARK]-A[J];
}}

Answer 2

选择排序法：选择排序比较大小的一种方法。比如，a[0]中应该存放最大的，则用a[0]和后面得所有数组元素做比较，找出其中最大的数据，记下下标，最后再用a[0]和下标元素交换，得到a[0]中则是存放的最大数。依次向下，直到a.length-2个！
for(int i=0;i<a.length-1;i++){
int xiabiao=i;
for(int j=i+1;j<a.length;j++){
     if (a[xiabiao]<a[j])   xiabiao=j;
}
if(xiabiao!=i){a[i]+=a[xiabiao];a[xiabiao]=a[i]-a[xiabiao];a[i]-=a[xiabiao];}
}
for 不一定要加{}；可以没有方法体的；
上面的代码if中少了“）”

Answer 3

选择：
public class sort {
int a[]={20,10,50,40,30,70,60,80,90,100};
public static void main(String[] args) {
new sort().print();
}
public void print() {
for(int i=0;i<9;i++) {
int big = i;
for(int j=i+1;j<10;j++) {
if(a[big]<a[j]) {
big = j;
}
}
int temp = a[i];
        a[i] = a[big];
        a[big] = temp;
}
for(int i:a) {
    System.out.println(i);
}
}
}

Answer 4

if(xiabiao!=i){a[i]+=a[xiabiao];a[xiabiao]=a[i]-a[xiabiao];a[i]-=a[xiabiao];}
这是什么意思?
上面的看懂了,是找出最大的那个数,然后存到xiaobiao中;
然后我接着按这种方法再找第二第三大的数不是就行了吗?上面我问的那一行代码是什么意思啊?>
按我的题目,你a[i]+=a[xiaobiao] 加入我就那a[0]举例,那现在a[0]不是就等于20+100=120了吗?\
是这意思不?

Answer 5

public class SelectSorter {
    public static void main(String[] args) {
        int array[] = {20,10,50,40,30,70,60,80,90,100};        sort(array);        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print(array[i]);
            } else {
                System.out.print("," + array[i]);
            }
        }
    }    public static void sort(int[] arr) {
        int i, j, temp;
        for (i = 0; i < arr.length; i++) {
            for (j = i; j < arr.length - 1; j++) {
                if (arr[j+1] > arr[j]) break;
            }            if (j != i) {
                temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }
        }
    }
}
out:
10,20,30,40,50,60,70,80,90,100

Answer 6

楼主你这种思想算是不完全的冒泡法.之所以说不完全是因为程序执行完后只能找出最大的一个数放到数组的最后.
你说的选择法书上叫选择排序法<<算法分析与设计>>上有,原理就是找出数组中的最大或最小值,然后从数组的一头堆到另一头..:
int max = 0;
int tp = 0;
for(int i = 1;i <= a.length - 2;i++){//i的最大值是a.length-2
   for(int j = 1;j <= a.length - i - 1;j++)//j的最大值是a.length-2 最小值是1
      if(a[j] > a[max]) max = j;
   tp = a[j];
   a[j] = a[max]
   a[max] = tp;
   max = 0;
}for(;;)后面并不是非跟{}不可,
当for(;;){}方法体中只含有一个语句的时候,花括弧{}就可以省略;
语法错误嘛,沙发说了,if那行后面少了一个")".
我也是新手,若有说得不准确的地方还请多指教,互相学习.      

Answer 7

以前做过的一个数组排序的例子，如下：package sort;
/**
 * 数组的各种排序算法
 * @author 曾能混
 *
 */
public class Sort {
/**
 * 冒泡排序
 * @param src待排序数组
 */
public void doBubbleSort(int[] src) {
int len = src.length;
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
int temp;
if (src[i] > src[j]) {
temp = src[j];
src[j] = src[i];
src[i] = temp;
}
}
}
printResult(src);
} /**
 * 选择排序 
 * 1. 设数组内存放了n个待排数字，数组下标从0开始，到n-1结束。 
 * 2. i=0 
 * 3.从数组的第i个元素开始到第n-1个元素，寻找最小的元素。（具体过程为:先设arr[i]为最小，逐一比较，若遇到比之小的则交换）
 * 4.将上一步找到的最小元素和第i位元素交换。 
 * 5. 如果i=n-1算法结束，否则回到第3步
 * @param src待排序的数组
 */
public void doselectSort(int[] src) {
int len = src.length;
int temp;
for (int i = 0; i < len; i++) {
temp = src[i];
int j;
int samllestLocation = i;// 最小数的下标
for (j = i + 1; j < len; j++) {
if (src[j] < temp) {
temp = src[j];// 取出最小值
samllestLocation = j;// 取出最小值所在下标
}
}
src[samllestLocation] = src[i];
src[i] = temp;
}
printResult(src);
} /**
 * 插入排序(WHILE循环实现)
 *  1. 首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）。
 *  2.从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态。 
 *  3. 重复2号步骤，直至原数列为空。
 * @param src待排序数组           
 */
public void doInsertSort1(int[] src) {
int len = src.length;
for (int i = 1; i < len; i++) {
int temp = src[i];
int j = i;
while (src[j - 1] > temp) {
src[j] = src[j - 1];
j--;
if (j <= 0)
break;
}
src[j] = temp;
}
printResult(src);
} /**
 * 插入排序(FOR循环实现)
 * @param src待排序数组
 */
public void doInsertSort2(int[] src) {
int len = src.length;
for (int i = 1; i < len; i++) {
int j;
int temp = src[i];
for (j = i; j > 0; j--) {
if (src[j - 1] > temp) {
src[j] = src[j - 1];
} else
// 如果当前的数，不小前面的数，那就说明不小于前面所有的数，
// 因为前面已经是排好了序的，所以直接跳出当前一轮的比较
break;
}
src[j] = temp;
}
printResult(src);
}
/**
 * 打印数组元素的方法
 * @param a 待打印的数组
 */
public void printResult(int[] a){
for(int s: a){
System.out.print(s+",");
}
System.out.println();
}

public static void main(String[] args) {
int[] a = {8,5,1,2,10,76};
Sort s = new Sort();
// System.out.println("----------------冒泡排序------------------");
// s.doBubbleSort(a);
System.out.println("----------------选择排序------------------");
s.doselectSort(a);
// System.out.println("----------------插入排序1------------------");
// s.doInsertSort1(a);
// System.out.println("----------------插入排序2------------------");
// s.doInsertSort2(a);
}}