Java - 选择排序算法

【问题标题】：Java - Selection Sort AlgorithmJava - 选择排序算法
【发布时间】：2018-12-26 16:26:58
【问题描述】：

我有一些关于选择排序的问题。我有点困惑。

 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 
        }
    }

输出是：

4
3
2
1
4
3
2
4
3
4

怎么了？

【问题讨论】：

    标签： java sorting selection


    【解决方案1】：

    选择排序是关于在循环的每个步骤中找到最小值。您没有找到最小值（可能通过 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
    }

    这应该会给你输出：

    1
2
3
4
5

    【讨论】：

    • 您在每个最小值上进行交换 - 这不是冒泡排序，而不是选择排序吗？
    • 很公平，经过进一步检查，它不是冒泡排序，因为是的，它总是交换邻居。这也不是完全的插入排序。毫无疑问，这是一种独特的选择排序方法，并且有足够的不同，对我来说，它应该得到某种标题，例如“选择排序的变体”。
    • @glowcoder 在我看来，这是选择排序。选择排序总是假设第一个是最小值，然后从其余元素中找到最小值，如果找到 min.idxoriginal(first).idx，则交换。我所做的是，每次发现新的分钟时，都进行交换。节省变量“min”的空间。但做了更多的交换。我编辑了代码，现在它应该与教科书完全相同。 （没有测试，应该工作）冒泡排序不是这样的，即使它也交换。它交换了两个邻居。
    【解决方案2】：

    正确：

    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 
    }
}

}

    关于最小值部分：它只是指当前最小值的索引。您继续向下移动数组，直到遇到新的最小值，并将 min 设置为该索引。所以 5 是最小数字 [min =0] 直到你看到 4 [所以现在 min =1] 但是你将 3 与存储在 4 [当 min = 1 时] 的任何内容进行比较，然后意识到你应该设置 min = 2。 ...等等等等。

    【讨论】：

    • -1 仅仅给某人一个代码来解决他们的家庭作业，甚至没有任何解释是没有用的。即使你是正确的，你也没有帮助他们理解，他们的问题也不是首先修复他们的代码......这只是为了理解一些关于算法的东西。
    • 我稍后添加了 cmets...如果你等了 2 分钟
    • 我也不同意知道答案没有用，但这只是个人意见。见过没有答案的模拟考试吗？
    • 我看到了您的更改（这可能需要一些工作，但它们没关系），但除非注册编辑，否则我无法删除我的反对票。 :(
    【解决方案3】：

    您的问题似乎在您的评论中

    min = i;//Selection sort algorithm says that find the minimum in the
        // array, but first element is not minimum.What's point here?

    关键是你可以假设你检查的第一个是最低的，这样你就有一个起点。毕竟，它可能不是最低的，但在您在本次迭代中检查过的那些中，它是迄今为止最低的！

    【讨论】：

      【解决方案4】：

      你应该首先找到最小值，而不是假设第一个元素是最小值

      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;
}

      【讨论】：

        【解决方案5】：

        您应该首先假设第一个元素是最小的，然后遍历数组，如果找到较小的元素，请记住该位置并假设它是最小的。当您到达数组的末尾时，您应该知道最小值的位置。将该值与第一个位置的值切换。现在最小值是第一个。从下一个位置开始，假设它是最小值，遍历数组的其余部分......（我想你明白了。

        例子：

        3,1,2

        假设 3 (pos 1) 是最小的。与位置 2 比较，1 

        1,3,2

        现在，由于位置 1 已经完成，从位置 2 开始。假设 3（位置 2）是最小值。与位置 3 (2) 进行比较。 2 

        1,2,3

        完成

        【讨论】：

          【解决方案6】：

          问题是在你的内部循环中你应该更新你的索引，使用你在内部循环中进行交换的策略我做了一个工作选择排序：

          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;
  }

}

          我添加到github。

          【讨论】：

            【解决方案7】： 
            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));
}
}

            【讨论】：

            • 虽然这段代码 sn-p 可以解决问题，但including an explanation 确实有助于提高帖子的质量。请记住，您正在为将来的读者回答问题，而这些人可能不知道您的代码建议的原因。也请尽量不要用解释性的 cmets 挤满你的代码，这会降低代码和解释的可读性！
            【解决方案8】：

            如前所述，您不会在内部循环中更新“min”变量。内部循环的目标是找到最小元素的索引。您还应该将“交换”移动到外循环。下面是选择排序伪代码：

            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

            查看下面我博客的链接，了解选择排序算法的完整说明。在 Java、C++、Python 和 JavaScript 中都有实现。

            http://brianredd.com/algorithm/selection-sort

            【讨论】：

            • 请注意，如果您想宣传自己的产品/博客，您必须在回答中披露您的隶属关系，否则您的回答可能会被标记为垃圾邮件。请阅读How to not be a spammer
            • 我现在已经编辑了一些披露（在我费心检查你最近是否活跃之前）。但请注意@CalvT 所说的。
            【解决方案9】：

            假设最低元素，需要扫描所有元素，然后将其交换到第一个位置。

            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]+" ");
        }
    }

            【讨论】：

              【解决方案10】： 
              /* Implementation of selection sort */

import java.util.Arrays;
import java.util.Scanner;


public class SelectionSort {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.println("Enter the number of elements of the array");
        int n = in.nextInt();
        int []a = new int[n];
        System.out.println("Enter the integer array of elements");
        for (int i=0; i<n ; i++)
        {
            a[i] = in.nextInt();
        }
        System.out.println("Before Sorting: "+Arrays.toString(a));
        a = sort(a);
        System.out.println("After Sorting: "+Arrays.toString(a));
    }

    private static int[] sort(int[] a) {
        // TODO Auto-generated method stub

        for(int i=0; i<a.length-1;i++)
        {
            int index=i;
            for(int j=i+1; j<a.length;j++)

                if(a[j]<a[index])
                {
                    index=j;
                }
                int small = a[index];
                a[index] = a[i];
                a[i]=small;

        }
        return a;
    }
}

              【讨论】：

                【解决方案11】： 
                    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;
      }

                这是选择排序的正确方法 您做错的事情是您在内部循环中进行交换，但实际上交换需要在确定最小元素的第一轮完整内部循环之后完成。

                【讨论】：

                • 虽然这可能会解决问题，但它并没有解释原因。
                【解决方案12】：

                公共类选择排序{

                公共静态 int arr[]; public static int y;

                public static void main(String args[]){

                System.out.println("输入要排序的元素个数");

                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]);

                }

                }

                【讨论】：

                • 虽然此代码可能会回答问题，但提供有关它如何和/或为什么解决问题的额外上下文将提高​​答案的长期价值。您还应该尝试正确格式化代码。
                【解决方案13】：

                选择排序是一种以ANSI顺序或DENSI顺序形成数组元​​素的算法。最佳情况、平均情况和最坏情况时间复杂度为 (n2)。选择排序并不适合对数组进行排序...选择排序实现如下：

                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]+"  ");
            }
  }

                【讨论】：

                  【解决方案14】：

                  传递未排序的数组得到排序的数组

                   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;
        }

                  【讨论】：

                    【解决方案15】：

                    选择排序算法通过从未排序的部分重复找到最小元素（考虑升序）并将其放在开头来对数组进行排序。该算法在给定数组中维护两个子数组。

                    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

                    Java 代码是：

                    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; 
        } 
    }

                    并清楚数组是通过引用传递的！

                    【讨论】：

                      【解决方案16】：

                      只需传递数组和数组大小

                      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;
}

                      【讨论】：

                        【解决方案17】：

                        选择排序是一种排序算法，其中最小的元素从未排序的数组中挑选出来并移动到数组的开头。 在您的情况下，首先从第二个 for 循环中找到最小值索引并在该循环之外交换。

                        private static void selectionSort(int[] arr) {

                                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;
            }
        }
    }

                        【讨论】：

                        • 请补充一些解释。
                        • 感谢您的评论。我添加了解释
                        • 我实际上的意思不是对这个词的解释，它可以在谷歌中找到，但是你的代码，如果它是原创的:)。
                        猜你喜欢
                        • 1970-01-01
                        • 2021-02-06
                        • 1970-01-01
                        • 1970-01-01
                        • 2016-11-01
                        • 2019-04-24
                        • 1970-01-01
                        • 1970-01-01
                        • 2021-03-20
                        相关资源
                        最近更新 更多
                        热门标签
                        Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode