java中排序方法中的选择排序

Question

请给我个简洁的答案

Answer 1

public class Sort { public static void main(String[] args) {
int[] i = { 1, 5, 6, 12, 4, 9, 3, 23, 39, 403, 596, 87 };
System.out.println("结果：");
xuanZe(i);
System.out.println();
} // 选择排序算法
public static void xuanZe(int[] x) {
for (int i = 0; i < x.length; i++) {
int lowerIndex = i;
// 找出最小的一个索引
for (int j = i + 1; j < x.length; j++) {
if (x[j] < x[lowerIndex]) {
lowerIndex = j;
}
}
// 交换
int temp = x[i];
x[i] = x[lowerIndex];
x[lowerIndex] = temp;
}
for (int i : x) {
System.out.print(i + " ");
}
}}

Answer 2

  public static void selectionSort(int[] number){   
        for(int i=0;i<number.length-1;i++){   
            int m=i;   
                for(int j=i+1;j<number.length;j++)   
                    if(number[j]<number[m])           //选出最小数的下标   
                        m=j;   
                       
                if(i!=m)   
                    swap(number,i,m);   
        }   
               
    }  private static void swap(int[] number,int i,int j){   
        int t;   
        t=number[i];   
        number[i]=number[j];   
        number[j]=t;   
    } 

Answer 3

void select_sort(int a[], int n)
{
 // 将 a 中整数序列重新排列成自小至大有序的整数序列。
  for ( i = 0; i< n-1; ++i ) 
     {
   j = i; 
   for ( k = i+1; k < n; ++k )
    if (a[k] < a[j] ) j = k;
   if ( j != i ){w = a[j]; a[j] = a[i]; a[i] = w;}
     }
 }

Answer 4

其实在 java 中  可以直接调  java.util 包中Arrays 类里面的sort方法就可以实现其排序功能。。即调用 Arrays.sort() 就可以实现排序功能 但是我要提醒一点的是 这个方法 实现的是数组的排序。。希望自己的解答能帮到楼主。。

Answer 5

....4楼哥们给你的就是选择排序
给你个鄙人写的public class Sort { // 递增
public static void bubbleSort(int... arr) {
int temp;
for (int i = 0; i < arr.length - 1; i++) {
temp = 0;
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
arr[j] ^= arr[j - 1];
arr[j - 1] ^= arr[j];
arr[j] ^= arr[j - 1];
temp++;
}
}
if (temp == 0) {
break;
}
}
}
// 选择排序
public static void selectSort(int... arr) {
int temp;
for (int i = 0; i < arr.length - 1; i++) {
temp = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[temp]) {
temp = j;
}
}
if (temp == i)
continue;
arr[i] ^= arr[temp];
arr[temp] ^= arr[i];
arr[i] ^= arr[temp];
}
}
//快排
public static void quickSort(int[] arr) {
innerQuickSort(arr, 0, arr.length - 1);
} private static void innerQuickSort(int[] arr, int head, int end) {
if (head >= end) {
return;
}
int index = head;
for (int i = head; i < end; i++) {
if (arr[i] <= arr[end] && index != i) {
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
index++;
}
}
if (index != end) {
arr[index] ^= arr[end];
arr[end] ^= arr[index];
arr[index] ^= arr[end];
}
innerQuickSort(arr, head, index - 1);
innerQuickSort(arr, index + 1, end);
} public static void insertSort(int[] arr) {
int index, temp;
for (int i = 1; i < arr.length; i++) {
index = i;
temp = arr[i];
while (index-- > 0 && arr[index] > temp) {
arr[index + 1] = arr[index];
}
arr[index + 1] = temp;
}
} // 堆排序
public static void heapSort(int[] arr) {
for (int i = arr.length / 2; i >= 0; i--) {
maxHeap(arr, i, arr.length);
}
for (int i = arr.length - 1; i >= 1; i--) {
arr[0] ^= arr[i];
arr[i] ^= arr[0];
arr[0] ^= arr[i];
maxHeap(arr, 0, i);
}
} // 建最大堆
private static void maxHeap(int[] arr, int index, int end) {
int q;
while (index < end) {
q = 2 * index + 1;
if (q >= end)
break;
if ((q < end - 1 && (arr[q + 1] > arr[q])))
q = q + 1;
// 如果某一节点的值小于其子节点的最大值，将其交换
if (arr[q] > arr[index]) {
arr[q] ^= arr[index];
arr[index] ^= arr[q];
arr[q] ^= arr[index];
index = q;
} else {
break;
}
}
}// 递归归并排序
public static void mergeSortRecursion(int... arr) {
if (arr.length > 1) {
int len1 = arr.length / 2;
int len2 = arr.length - len1;
int[] arr1 = new int[len1];
int[] arr2 = new int[len2];
for (int i = 0; i < len1; i++) {
arr1[i] = arr[i];
}
for (int j = 0; j < len2; j++) {
arr2[j] = arr[len1 + j];
}
mergeSortRecursion(arr1);
mergeSortRecursion(arr2);
int index1 = 0;
int index2 = 0;
int index = 0;
while (index1 < len1 && index2 < len2) {
if (arr1[index1] < arr2[index2]) {
arr[index++] = arr1[index1++];
} else {
arr[index++] = arr2[index2++];
}
}
while (index1 < len1) {
arr[index++] = arr1[index1++];
}
while (index2 < len2) {
arr[index++] = arr2[index2++];
}
}
}

// 原地循环归并排序
public static void mergeSortCircle(int[] arr) {
int[] rep = new int[arr.length];
int[] temp;
int inc = 1;
int index = 0;
int first = 0;
int second = 0;
int times = 0;
while (inc < arr.length) {
index = 0;
for (int i = 0; i < arr.length; i += inc * 2) {
first = i;
second = i + inc;
while (first < i + inc && first < arr.length
&& second < i + inc * 2 && second < arr.length) {
if (arr[first] <= arr[second]) {
rep[index++] = arr[first++];
} else {
rep[index++] = arr[second++];
}
}
while (first < i + inc && first < arr.length) {
rep[index++] = arr[first++];
}
while (second < i + inc * 2 && second < arr.length) {
rep[index++] = arr[second++];
}
}
inc *= 2;
times++;
temp = arr;
arr = rep;
rep = temp;
}
if (times % 2 == 1) {
temp = arr;
arr = rep;
for (int i = 0; i < temp.length; i++) {
arr[i] = temp[i];
}
}
}
}

Answer 6

我给你的就是选择排序。public class Sort { public static void main(String[] args) {
int[] i = { 1, 5, 6, 12, 4, 9, 3, 23, 39, 403, 596, 87 };
System.out.println("冒泡排序的结果：");
maoPao(i);
System.out.println();
System.out.println("选择排序的结果：");
xuanZe(i);
System.out.println();
System.out.println("插入排序的结果：");
chaRu(i);
System.out.println();
System.out.println("希尔排序的结果：");
shell(i);
} // 冒泡排序算法
public static void maoPao(int[] x) {
for (int i = 0; i < x.length; i++) {
for (int j = i + 1; j < x.length; j++) {
if (x[i] > x[j]) {
int temp = x[i];
x[i] = x[j];
x[j] = temp;
}
}
}
for (int i : x) {
System.out.print(i + " ");
}
} // 选择排序算法
public static void xuanZe(int[] x) {
for (int i = 0; i < x.length; i++) {
int lowerIndex = i;
// 找出最小的一个索引
for (int j = i + 1; j < x.length; j++) {
if (x[j] < x[lowerIndex]) {
lowerIndex = j;
}
}
// 交换
int temp = x[i];
x[i] = x[lowerIndex];
x[lowerIndex] = temp;
}
for (int i : x) {
System.out.print(i + " ");
}
} // 插入排序算法
public static void chaRu(int[] x) {
for (int i = 1; i < x.length; i++) {// i从一开始，因为第一个数已经是排好序的啦
for (int j = i; j > 0; j--) {
if (x[j] < x[j - 1]) {
int temp = x[j];
x[j] = x[j - 1];
x[j - 1] = temp;
}
}
}
for (int i : x) {
System.out.print(i + " ");
}
} // 希尔排序算法
public static void shell(int[] x) {
// 分组
for (int increment = x.length / 2; increment > 0; increment /= 2) {
// 每个组内排序
for (int i = increment; i < x.length; i++) {
int temp = x[i];
int j = 0;
for (j = i; j >= increment; j -= increment) {
if (temp < x[j - increment]) {
x[j] = x[j - increment];
} else {
break;
}
}
x[j] = temp;
}
} for (int i : x) {
System.out.print(i + " ");
}
}
}