对一个给定元素的数组进行排序。

Question

思路是这样的，先从所有元素中选出最小的数，然后从剩下的元素中选出最小的数，接下去就这样依次排序。直接用for循环实现，不用冒泡排序和Arraysort,要怎么写循环？

Answer 1

写出来了 发现还是冒泡  悲剧
int[] nums=new int[]{99,1,22,13,5,7,8,9,11,16};
for(int idx=0,len=nums.length,pos,min;idx<len;idx++){
pos=idx;
min=nums[pos];
for(int i=idx+1;i<len;i++){
if(nums[i]<min){
pos=i;
min=nums[pos];
}
}
nums[pos]=nums[idx];
nums[idx]=min;
System.out.println(min);
}

Answer 2

  public int min(int[]a,int i){//返回最小值的下标 
  int temp=a[i];
  int begin=i;
  for (int j = i+1; j < a.length; j++) {
if(temp>a[j]){
temp=a[j];
begin=j;
}
}
  return begin;
  }
  
  public void find(int[]a){//排序的方法
  int temp;
  for (int i = 0; i < a.length; i++) {
  int j=min(a, i);
if(i!=j){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
  
  }

Answer 3

for循环用哪个都一样了，效率差不多，直接用冒泡不就行了？

Answer 4

插入排序，运气好可能O(N)的时间 public static void sort(int[] a) {
     for(int i = 1; i < a.length;i++) {
     int tmp = a[i];
     for(int j = i;j>0;j--) {
     if(tmp<a[j-1]) {
     a[j] = a[j-1];
     a[j-1] = tmp;
     }
     }
     }
    }

Answer 5

如果我定义一个Min，先从所有元素中选出最小的数，赋值给Min，然后从剩下的元素中取数和Min比较，接下去就这样依次排序，for循环要怎么实现？

Answer 6

M*N
如果有办法用Map，
就是M+N了。
给个思路，我没去想哈

Answer 7

插入漏了点，补充一下，加多个选择排序 public static void sort(int[] a) {//插入
     for(int i = 1; i < a.length;i++) {
     int tmp = a[i];
     for(int j = i;j>0;j--) {
     if(tmp<a[j-1]) {
     a[j] = a[j-1];
     a[j-1] = tmp;
     }
     else {
     break;
     }
     }
     }
    }
    
    public static void sort2(int[] a) {//选择
     for(int i = 0; i < a.length;i++) {
     int t = i;
     for(int j = i+1;j<a.length;j++) {
     if(a[t]>a[j]) {
     t = j;
     }
     }
     if(t!=i) {
     int tmp = a[i];
     a[i] = a[t];
     a[t] = tmp;
     }
     }
    }

Answer 8

public class Test
{
public static void main(String[] args) 
{
int nums[] = {6,9,2,5,4,1,0};
int i,min = Integer.MAX_VALUE;
for(i = 0; i < nums.length; i ++ )
{
if(min > nums[i])
{
min = nums[i];
} 定义一个Min，先从所有元素中选出最小的数，赋值给Min，然后从剩下的元素中取数和Min比较，接下去就这样依次排序，for循环要怎么实现？

Answer 9

"先从所有元素中选出最小的数，赋值给Min，然后从剩下的元素中取数和Min比较，接下去就这样依次排序"，这思路，适合用递归，当然用for循环也可，但递归更简洁明了。

Answer 10

直接用冒泡了 冒泡里面也是用for的啊！

Answer 11

public class Test
{
public static void main(String[] args)  
{
int nums[] = {6,9,2,5,4,1,0};//需要查找的整数数组nums
int min;
for(i = 0; i < nums.length; i ++ )
{
  min=i;
 for(j=i+1;j<nums.length;j++){if(nums[min] > nums[j])
{
min = j;//找到数组中最小的那个数字的下标
} 
}
if(min!=i)//如果下标不等于i,则需要交换位置，这样就将最小的数字放在最前面了
{
 int tmp=nums[i];  
nums[i]=num[min];
nums[min]=tmp;
}}

Answer 12

public class Test
{
public static void main(String[] args)  
{
   int nums[] = {6,9,2,5,4,1,0};//需要查找的整数数组nums
   int min;
   for(i = 0; i < nums.length; i ++ )
   {
      min=i;
      for(j=i+1;j<nums.length;j++){
      if(nums[min] > nums[j])
      {
          min = j;//找到数组中最小的那个数字的下标
       } 
   }
   if(min!=i)//如果下标不等于i,则需要交换位置，这样就将最小的数字放在最前面了
   {
      int tmp=nums[i];  
      nums[i]=num[min];
      nums[min]=tmp;
   }
}

Answer 13

我到是觉得楼主的思路要求更符合的是:选择排序，冒泡只能是i与i+1进行比较，而选择排序i可以与n任意数比较，而且选择排序的"交换位置操作"在内循环的外面，而冒泡的"交换位置操作"在内循环里面，那么选择排序的“交换位置操作”就比冒泡排序少，算法效果感觉快些

Answer 14

public class T 
{
public static void main(String[] args) 
{
int[] nums = { 9, 13, 5, 7, 24, 28, 20, 41 };
int min = Integer.MIN_VALUE;


for (int x  = 0; x < nums.length; x++)
{
int mv = Integer.MAX_VALUE;
for (int i = 0; i < nums.length; i++)
{
//System.out.println("Min: " + min + ", Mv: " + mv + ", Nums[" + i + "]: " + nums[i]);


if (nums[i] <= min) continue;
if (mv > nums[i]) mv = nums[i];


System.out.println("Min: " + min + ", Mv: " + mv + ", Nums[" + i + "]: " + nums[i]);

//System.out.println("\r\n\r\n");
}
min = mv;
//System.out.println(mv);
}
}
}这是我后面写的