选择排序问题

Question

下面是我自己写的一个排序的程序，我认为是选择排序，大家帮我看看哦！！若不是，请说出是何种类型？并给出正确的选择排序算法！！！谢谢！public class PaiXu {
  
  public static void SelectDate(int[] arr){
  int temp=0;
  for(int i=0;i<arr.length;i++){
  for(int j=i+1;j<arr.length;j++){
  if(arr[i]>arr[j]){
  temp=arr[i];
  arr[i]=arr[j];
  arr[j]=temp;
  }
  }
  }
  for(int k: arr){
  System.out.println(k);
  }
  } public static void  main(String[] args){
 PaiXu px=new  PaiXu();
 px.SelectDate(new int[]{8,3,2,6,1,5});
 }

}

Answer 1

//选择排序
//原理：每次都找到当次最大的数，按大小顺序依次放入数组相应位置
//比如：第一次先找到最大的数并记下其位置，如果其不在数组第一位，
//则将其与第一位交换，使最大数置于第一位
//第二次再循环查找第二大的数并记下其位置，如果其不在数组第二位，
//则将其与第二位交换，使最大数置于第二位
//依次类推.........................................
//第i次再循环查找第i大的数并记下其位置，如果其不在数组第 i位，
//则将其与第 i位交换，使最大数置于第 i位
public class SelectSort {
 public static void main(String[] args) {
  int[] a = {25,15,42,16,12,36};
  int max = 0;
  int tmp = 0;
  for(int i=0;i<a.length;i++){
   max = i;//
   /**查找第 i大的数，直到记下第 i大数的位置***/
   for(int j=i+1;j<a.length;j++){
    if(a[max]<a[j]) 
     max = j;//记下较大数位置，再次比较，直到最大
   }
   /***如果第 i大数的位置不在 i,则交换****/
   if(i!=max){
    tmp = a[i];
    a[i] = a[max];
    a[max] = tmp;
   }
  }
  for(int i=0;i<a.length;i++)
   System.out.print(a[i]+" ");
 }
}

Answer 2

  没错是选择排序，选择排序的思想是：用第一个和选择后面所有的进行排序。
   比如： 4,3,2,1     a[0]跟a[1]比，a[0]跟a[2]比，a[0]跟a[3]比
   1楼:你误人子弟了，很多搞JAVA的都没接触过C都会把选择排序说成是 冒泡。
       因为在这些人的思想中认为:大的冒上去了就是冒泡排序，那么快速了？不也是从大到小或者从小到大？
    冒泡排序的思想是： 两个数之间交换，比如   4。3。2。1  a[0]跟a[1]比，  a[1]跟a[2]比， a[2]跟a[3]比

Answer 3

先了解一下什么事选择排序和冒泡排序：
冒泡算法描述： 
在解释冒泡排序算法之前，先来介绍把10个数（放在数组A中）中最大的那个数放在最后位置上的一种算法。算法描述如下： 
（1）从数组A[1]到A[10]，把相临的两个数两两进行比较。即A[1]和A[2]比较，比较完后A[2]再与A[3]比较，……最后是A[9]和A[10]比较。 
(2)在每次进行比较的过程中，如果前一个数比后一个数大，则对调两个数，也就是说把较大的数调到后面，较小的调到前面。比如在第一次的比较中，如果A[1]比A[2]大则A[1]和A[2]的值就互换。下图用6个数据来说明以上的算法。 
假设6个数据是：A[]=5 7 4 3 8 6 
A[1] A[2] A[3] A[4] A[5] A[6] 
5 7 4 3 8 6 第一次，A[1]=5和A[2]=7比较，7>5，不进行对调。 
5 7 4 3 8 6 第二次，A[2]=7和A[3]=4比较，4<7，进行对调， 
那么第二次比较完后的数据是5 4 7 3 8 6 
5 4 7 3 8 6 第三次，A[3]=7和A[4]=3比较，3<7，进行对调， 
那么第三次比较完后的数据是5 4 3 7 8 6 
5 4 3 7 8 6 第四次，A[4]=7和A[5]=8比较，8>7,不进行对调。 
5 4 3 7 8 6 第五次，A[6]=6和A[5]=8比较，6<8，进行对调， 
那么第五次也就是最后一次的结果是 
5 4 3 7 6 8 
选择排序算法描述： 
在介绍选择排序法之前先介绍一种把最小的数放在第一个位置上的算法，当然也可以用前面所讲的冒泡排序法，现在我们改用一种新的算法：其指导思想是先并不急于调换位置，先从A[1]开始逐个检查，看哪个数最小就记下该数所在的位置P，等一躺扫描完毕，再把A[P]和A[1]对调，这时A[1]到A[10]中最小的数据就换到了最前面的位置。算法的步骤如下： 
1）、先假设A[1]中的数最小，记下此时的位置P=1； 
2）、依次把A[P]和A[I]（I从2变化到10）进行比较，每次比较时，若A[I]的数比A[P]中的数小，则把I的值赋给P，使P总是指向当前所扫描过的最小数的位置，也就是说A[P]总是等于所有扫描过的数最小的那个数。在依次一一比较后，P就指向10个数中最小的数所在位置，即A[P]就是10个数中最小的那个数； 
3）把A[P]和A[1]的数对调，那么最小的数就在A[1]中去了，也就是在最前面了。 
如果现在重复此算法，但每重复一次，进行比较的数列范围就向后移动一个位置。即第二遍比较时范围就从第2个数一直到第N个数，在此范围内找最小的数的位置P，然后把A[P]与A[2]对调，这样从第2个数开始到第N个数中最小数就在A[2]中了，第三遍就从第3个数到第N个数中去找最小的数，再把A[P]与A[3]对调……此过程重复N-1次后，就把A数组中N个数按从小到大的顺序排好了。这种排序的方法就是选择排序法 

Answer 4

楼主写的是选择排序  下面是本人所写的三种排序 自己比较下就知道了 
 // 选择排序
public static int[] xuanZe(int[] ary){
for(int i = 0; i<ary.length-1;i++){
for(int j=i+1; j<ary.length-1; j++){
if(ary[i]>ary[j]){
int temp = ary[i];
ary[i] = ary[j];
ary[j]= temp;
}
}
}
return ary;
}
//冒泡排序
public static int[] maoPao(int[] ary2){
for(int i = 0; i<ary2.length-1;i++){
for(int j = 0; j<ary2.length-i-1; j++){
if(ary2[j]>ary2[j+1]){
int temp = ary2[j];
ary2[j] = ary2[j+1];
ary2[j+1] = temp;
}
}
}
return ary2;
}
//插入排序
public static int[] chaRu(int[] ary){
for(int i = 0; i<ary.length; i++){
int temp = ary[i];
int j;
for(j = i-1; j>=0; j--){
if(ary[j]>ary[i]){
ary[j+1] = ary[j];
}
else
break;
}
ary[j+1] = temp;
}
return ary;
}

Answer 5

这个的确是选择排序，冒泡的话，第二个循环应该是
for(int j = 0; j<ary2.length-i-1; j++)

Answer 6

楼主写的是选择排序，
冒泡排序：将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

Answer 7

我觉得你这个不是选择因为 选择的主要思想是，将数组分成两块，前面的一块是排好的，后面的是未排的从未排的元素中选出一个最大的（或者最小的）和未排的第一个交换位置，同时排好的元素个数增加一个，未排的元素个数减少一个
      public static void select(int [] arr){
int length = arr.length;
for(int i = 0; i < length; i++){
/**
 * 外层循环，认为未排序的部分的起始部分是下标从0开始。
 * 排好的部分是下标是0之前的部分
 */
int index = i;
for(int j = i + 1; j < length; j++){
/**
 * 内存循环，在未排的部分中找到最大的那个
 * 把它的下标记在index变量中
 */
if(arr[index] > arr[j]){
index = j;
}
}
/**
 * index中记录的是未排序的部分的最大数字的下标
 * 如果index等于i，加个判断，减少交换次数
 */
if(index != i){
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
/**
 * 外层循环执行i++之后，认为未排序的部分是下标从1开始
 * 排好的部分是下标是1之前的部分
 */
}
/**
 * 打印语句
 */
for(int k: arr){
System.out.println(k);
}
}