Java选择排序算法
我有一些关于选择排序的问题。我有点困惑Java选择排序算法,java,sorting,selection,Java,Sorting,Selection,我有一些关于选择排序的问题。我有点困惑 int [] arr = {5,4,3,2,1}; // This is my array int min = 0; for(int i = 0;i<arr.length;i++) { //Assume first element is min min = i;//Selection sort algorithm says that find the minimum in the
int [] arr = {5,4,3,2,1}; // This is my array
int min = 0;
for(int i = 0;i<arr.length;i++)
{
//Assume first element is min
min = i;//Selection sort algorithm says that find the minimum in the
// array, but first element is not minimum.What's point here?
for(int j = i + 1;j<arr.length;j++)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
System.out.println(arr[i]);//I print the in ascending order
}
}
怎么了 选择排序是在循环的每个步骤中查找最小值。您没有找到最小值（可能是通过if语句），只是简单地在内部循环中交换值。所以你实际上没有做任何排序 根据您的实施情况进行更正：
final int[] arr = { 5, 4, 3, 2, 1 }; // This is my array
int min;
for (int i = 0; i < arr.length; i++) {
// Assume first element is min
min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (min != i) {
final int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
System.out.println(arr[i]);// I print the in ascending order
}
public class Test {
public static void main(String args[]){
int[] arr = {5,4,3,2,1}; // This is my array
int min = 0;
for(int i = 0;i<arr.length;i++)
{
//Assume first element is min
min = i;
for(int j = i + 1;j<arr.length;j++)
{
if(arr[j] < arr[min]) { min = j;}
}
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
System.out.println(arr[i]);//I print the in ascending order
}
}
}
公共类测试{
公共静态void main（字符串参数[]）{
int[]arr={5,4,3,2,1}；//这是我的数组
int min=0；
对于（inti=0；i，您的问题似乎出现在您的评论中
min = i;//Selection sort algorithm says that find the minimum in the
// array, but first element is not minimum.What's point here?
关键是你可以假设你正在检查的第一个元素是最低的，这样你就有了一个开始的位置。毕竟，它可能不是所有的最小值，但在你在这个迭代中检查的元素中，它是迄今为止最低的！你应该先假设第一个元素是最小的，然后在a上迭代如果你找到一个较小的元素，记住这个位置并假设它是最小的。当你到达数组的末尾时，你应该知道最小值的位置。用第一个位置的值切换该值。现在最小值是第一个。从下一个位置开始，假设它是最小值，迭代阵列的其余部分…（我想你明白了
例如：
3,1,2
arr[] = 64 25 12 22 11
// Find the minimum element in arr[0...4]
// and place it at beginning
11 25 12 22 64
// Find the minimum element in arr[1...4]
// and place it at beginning of arr[1...4]
11 12 25 22 64
// Find the minimum element in arr[2...4]
// and place it at beginning of arr[2...4]
11 12 22 25 64
// Find the minimum element in arr[3...4]
// and place it at beginning of arr[3...4]
11 12 22 25 64
假设3（位置1）最小。与位置2比较，1<3，因此假设位置2具有最小值。与位置3比较，3<1。因为我们处于末端开关，与第一个位置最小。（位置1和位置2）
现在，由于位置1已完成，从位置2开始。假设3（位置2）是最小值。与位置3（2）相比。2<3，因此假设位置3具有最小值。由于我们位于数组的末尾，我们切换位置2和3
1,2,3
完成您应该首先找到最小值，而不是假设第一个元素是最小值
int[] array = {5, 4, 3, 2, 1};
for ( int i = 0; i < array.length; i++ ) {
//find minimum, starting from index i
int minIndex = i;
int min = array[i];
for ( int j = i + 1; j < array.length; j++ ) {
if ( array[ j ] < min ) {
minIndex = j;
min = array[j];
}
}
// now move the smallest element to the front, and the element at index i to the index of the minimal element
int temp = array[ i ];
array[ i ] = min;
array[ minIndex ] = temp;
}
int[]数组={5,4,3,2,1}；
for（int i=0；i
/*选择排序的实现*/
导入java.util.array；
导入java.util.Scanner；
公共类选择排序{
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
扫描仪输入=新扫描仪（系统输入）；
System.out.println（“输入数组的元素数”）；
int n=in.nextInt（）；
int[]a=新的int[n]；
System.out.println（“输入元素的整数数组”）；
对于（int i=0；i错误在于，在内部循环中，您应该使用在内部循环中执行交换的策略来更新索引，我进行了一次有效的选择排序：
import java.util.Arrays;
public class SelectionSort {
public static void main(String[] args) {
int[] input = new int[] {5,2,4,6,1,3};
System.out.println( Arrays.toString(selectionSort(input)) );
}
public static int[] selectionSort(int[] input) {
int length = input.length;
int minimumValue = Integer.MAX_VALUE;
for (int i = 0; i < length; ++i) {
// find the minimumValue when j > i and swap it with input[i] location
for (int j =i; j < length; ++j) {
if (input[j] <= minimumValue ) {
minimumValue = input[j];
input[j] = input[i];
input[i] = minimumValue;
}
}
minimumValue = Integer.MAX_VALUE;
}
return input;
}
}
导入java.util.array；
公共类选择排序{
公共静态void main（字符串[]args）{
int[]输入=新的int[]{5,2,4,6,1,3}；
System.out.println（Arrays.toString（selectionSort（input））；
}
公共静态int[]选择排序（int[]输入）{
int length=input.length；
int minimumValue=Integer.MAX_值；
对于（int i=0；ii时的最小值，并将其与输入[i]位置交换
对于（int j=i；jSelection Sort
Inputs:
A: an array
n: the number of elements in A to sort
Procedure SELECTION-SORT (A, n)
1. For i = 0 to n – 1:
A. Set minIndex to i.
B. For j = i + 1 to n:
i. If A[j] < A[minIndex], then set minIndex to j. // Add this
C. Swap A[i] with A[minIndex]. // Move this to outside of the inner loop
选择排序
投入：
A:数组
n：要排序的元素中的元素数
程序选择-排序（A，n）
1.对于i=0到n–1：
A.将minIndex设置为i。
B.对于j=i+1到n：
i、 如果A[j]
查看下面的链接，查看选择排序算法的完整解释。在爪哇，C++，Python和JavaScript中有实现。
公共类选择排序{
公共静态void main（字符串[]args）{
int[]A={5,4,3,2,1}；
int l=A.长度；
对于（int i=0；i
假设一个最低的元素，这需要扫描所有元素，然后将其交换到第一个位置
private static void selectionSortMethod(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) { //no of iterations for array length
for (int j = i + 1; j < arr.length; j++) { //starting from next index to lowest element(assuming 1st index as lowest)
if (arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//print
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
private静态void selectionSortMethod（int[]arr）{
对于（int i=0；iarr[j]）{
int temp=arr[i]；
arr[i]=arr[j]；
arr[j]=温度；
}
}
}
//印刷品
对于（int i=0；iint[]arr={5,4,3,2,1}；
对于（int i=0；iimport java.util.Arrays;
public class SelectionSort {
public static void main(String[] args) {
int[] input = new int[] {5,2,4,6,1,3};
System.out.println( Arrays.toString(selectionSort(input)) );
}
public static int[] selectionSort(int[] input) {
int length = input.length;
int minimumValue = Integer.MAX_VALUE;
for (int i = 0; i < length; ++i) {
// find the minimumValue when j > i and swap it with input[i] location
for (int j =i; j < length; ++j) {
if (input[j] <= minimumValue ) {
minimumValue = input[j];
input[j] = input[i];
input[i] = minimumValue;
}
}
minimumValue = Integer.MAX_VALUE;
}
return input;
}
}
Selection Sort
Inputs:
A: an array
n: the number of elements in A to sort
Procedure SELECTION-SORT (A, n)
1. For i = 0 to n – 1:
A. Set minIndex to i.
B. For j = i + 1 to n:
i. If A[j] < A[minIndex], then set minIndex to j. // Add this
C. Swap A[i] with A[minIndex]. // Move this to outside of the inner loop
public class SelectionSort {
public static void main(String[] args) {
int[] A = {5,4,3,2,1};
int l = A.length;
for (int i = 0; i < l-1; ++i ){
int minPos = i;
// Find the location of the minimal element
for (int j = i + 1; j < l; ++j){
if ( A[j] < A[minPos]){
minPos = j;
}
}
if (minPos != i){
int temp = A[i];
A[i] = A[minPos];
A[minPos] = temp;
}
}
System.out.println(Arrays.toString(A));
}
}
private static void selectionSortMethod(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) { //no of iterations for array length
for (int j = i + 1; j < arr.length; j++) { //starting from next index to lowest element(assuming 1st index as lowest)
if (arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//print
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
int[] arr = {5,4,3,2,1};
for (int i = 0; i < arr.length - 1; i++)
{
int index = i;
for (int j = i + 1; j < arr.length; j++)
if (arr[j] < arr[index])
index = j;
int smallerNumber = arr[index];
arr[index] = arr[i];
arr[i] = smallerNumber;
}
int nofele= Integer.parseInt(args[0]);
System.out.println("Enter number of element entered for sorting is "+ "\n" +nofele);
arr = new int[nofele];
System.out.println("Entered array is");
for(int i=1,j=0;i<=nofele;i++,j++){
arr[j]=Integer.parseInt(args[i]);
System.out.println(arr[j]);
}
System.out.println("Sorted array for selection sort is ");
for(int k=0;k<nofele-1;k++) {
for(int l=nofele-k,b=1;l>=2;l--,b++){
if(arr[k]>arr[k+b]){
int temp=arr[k];
arr[k]=arr[k+b];
arr[k+b] = temp;
}
}
System.out.println(arr[k]);
}
System.out.println(arr[nofele-1]);
import java.util.Scanner;
class selection{
public static void main(String a[]){
Scanner sc=new Scanner(System.in);
System.out.print("size :");
int n=sc.nextInt();
int i,j,tmp,minVal;
int[] ar=new int[n];
for(i=0;i<n;i++){
ar[i]=sc.nextInt();
}
for(i=0;i<(n-1);i++){
minVal=ar[i];
for(j=(i+1);j<n;j++){
if(minVal>ar[j]){
minVal=ar[j];
tmp=ar[i];
ar[i]=minVal;
ar[j]=tmp;
}
}
}
for(i=0;i<n;i++){
System.out.print(ar[i]+" ");
}
}
public int[] selectionSort(int[] list) {
int i, j, minValue, minIndex, temp = 0;
for (i = 1; i < list.length; i++) {
minValue = list[i];
minIndex = i;
j = i - 1;
for (j = i; j < list.length; j++) {
if (list[j] < minValue) {
minValue = list[j];
minIndex = j;
}
}
if (list[i] > minValue) {
temp = list[i];
list[i] = list[minIndex];
list[minIndex] = temp;
}
}
return list;
}
arr[] = 64 25 12 22 11
// Find the minimum element in arr[0...4]
// and place it at beginning
11 25 12 22 64
// Find the minimum element in arr[1...4]
// and place it at beginning of arr[1...4]
11 12 25 22 64
// Find the minimum element in arr[2...4]
// and place it at beginning of arr[2...4]
11 12 22 25 64
// Find the minimum element in arr[3...4]
// and place it at beginning of arr[3...4]
11 12 22 25 64
void sort(int arr[])
{
int n = arr.length;
// One by one move boundary of unsorted subarray
for (int i = 0; i < n-1; i++)
{
// Find the minimum element in unsorted array
int min_idx = i;
for (int j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
// Swap the found minimum element with the first
// element
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
private void selectionSort() {
for (int i = 0; i < arraySize; i++) {
for (int j = i; j < arraySize; j++) {
if (array[i] > array[j])
swapValues(i,j);
}
}
}
private void swapValues(int posOne, int posTwo) {
int tValue = array[posOne];
array[posOne] = array[posTwo];
array[posTwo] = tValue;
}
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int min = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (min != i) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}