精华内容
下载资源
问答
  • 选择排序原理

    2019-09-20 19:37:51
    原理 首先找到数组中最小的元素,让它和数组中第一个元素进行交换。然后在剩下的数组中找到最小的元素让它与第二个元素进行交换。如此往复,直到将整个数组排序。 具体代码 1 public static void sort...

    原理

    首先找到数组中最小的元素,让它和数组中第一个元素进行交换。然后在剩下的数组中找到最小的元素让它与第二个元素进行交换。如此往复,直到将整个数组排序。

    具体代码

     1 public static void sort(Comparable[] a)
     2     {
     3         int i,j;
     4         for(i=0;i<a.length;i++)
     5         {
     6             int min = i;
     7             for(j=i;j<a.length;j++)
     8             {
     9                 if(less(a[j],a[min])) min=j;
    10             }
    11             exch(a,i,j);
    12         }
    13     }
    14     private static void exch(Comparable[] a,int i,int j)
    15     {
    16         Comparable t = a[i]; a[i]=a[j]; a[j] = t;
    17     }
    18     public static boolean less(Comparable v,Comparable w)
    19     {
    20         return v.compareTo(w)<0;
    21     }

     对于长度为N的数组,选择排序需要大约N2/2次比较和N次交换。

    0到N-1的任意i都会进行一次交换和N-1-i次比较,因此总共有N次交换和(N-1)+(N-2)+(N-3)+..+(1) = N(N-1)/2 ~ N2/2次比较。

    转载于:https://www.cnblogs.com/mymym/p/8595218.html

    展开全文
  • 选择排序原理: 选择排序从左往右依次比较;保护左边排序好的元素(比较后获取下标,之后再交换元素)。 1 5 12 36 55 78 98 0 1 2 3 4 5 6 int[] a1 = new int[]{1, 5, 12, 36, 55, 78, 98}; //冒泡...

    Java冒泡排序原理速记,选择排序原理速记

    冒泡排序原理分析:
    冒泡排序从左往右两两比较;保护右边的排序好的元素(比较直接交换元素)。
    选择排序原理:
    选择排序从左往右依次比较;保护左边排序好的元素(比较后获取下标,之后再交换元素)。

    1 5 12 36 55 78 98
    0 1 2 3 4 5 6
     int[] a1 = new int[]{1, 5, 12, 36, 55, 78, 98};
            //冒泡排序
            for (int j = 0; j <= a1.length - 1; j++) {
                for (int k = 0; k < a1.length - j - 1; k++) {
                    if (a1[k] < a1[k + 1]) {
                        int tre;
                        tre = a1[k];
                        a1[k] = a1[k + 1];
                        a1[k + 1] = tre;
                    }
                }
            }
            for (int u : a1) {
                System.out.println("冒泡排序降序:" + u);
            }
            System.out.println("------------------");
            for (int j = 0; j <= a1.length - 1; j++) {
                for (int k = 0; k < a1.length - j - 1; k++) {
                    if (a1[k] > a1[k + 1]) {
                        int tre;
                        tre = a1[k];
                        a1[k] = a1[k + 1];
                        a1[k + 1] = tre;
                    }
                }
            }
            for (int u1 : a1) {
                System.out.println("冒泡排序升序:" + u1);
            }
            System.out.println("---------------");
            //选择排序
            for (int j = 0; j <= a1.length - 1; j++) {
                int miax = 0;//可以等于j
                for (int k = j; k < a1.length - 1; k++) {
                    if (a1[k] > a1[miax]) {
                        miax = k;
                    }
                }
                int tre;
                tre = a1[miax];
                a1[miax] = a1[j];
                a1[j] = tre;
            }
            for (int u1 : a1) {
                System.out.println("选择排序降序:" + u1);
            }
            System.out.println("--------------------");
            for (int j = 0; j <= a1.length - 1; j++) {
                int min = 0;
                for (int k = j; k < a1.length - 1; k++) {
                    if (a1[k] < a1[min]) {
                        min = k;
                    }
                }
                int tre;
                tre = a1[min];
                a1[min] = a1[j];
                a1[j] = tre;
            }
            for (int u1 : a1) {
                System.out.println("选择排序升序:" + u1);
            }
        
    

    共同点:
    外层循环控制循环轮数,内层循环控制数组遍历,if语句作比较

    分享完毕

    展开全文
  • 直接选择排序原理

    千次阅读 2019-04-10 10:23:10
    1.选择排序原理 选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。 表现最稳定...

    1.选择排序原理

    选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。

    表现最稳定的排序算法之一,因为无论什么数据进去都是O(n2)的时间复杂度,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲,选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
    选择排序

    2.基本过程

    n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果:

    (1)在未排序序列中找到最小(大)元素,存放到排序序列的起始位置。

    (2)再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

    (3)以此类推,直到所有元素均排序完毕。

    3.python代码实现

    def select_sort(s):
        for i in range(len(s)-1): #只需要循环len(s)-1 次
            k=i  #定义变量K的原因是要存储最小元素的位置,方便最后进行交换
            for j in range(i+1,len(s)):
                if s[j]<s[k]:
                    k=j
            if k!= i:   #s[k]是确定的最小元素,检查是否需要交换
                s[k],s[i]=s[i],s[k]
        return s
    
    s=[3,2,5,1,8]
    select_sort(s)
    

    代码运行结果:
    在这里插入图片描述

    4.算法分析

    最佳情况:T(n) = O(n2) 最差情况:T(n) = O(n2) 平均情况:T(n) = O(n2)
    空间复杂度为O(1) ,不稳定。
    解释一下不稳定性为何:
    选择排序是给每个位置选择当前元素最小的,比如给第一个位置选择最小的,在剩余元素里面给第二个元素选择第二小的,依次类推,直到第n-1个元素,第n个 元素不用选择了,因为只剩下它一个最大的元素了。那么,在一趟选择,如果当前元素比一个元素小,而该小的元素又出现在一个和当前元素相等的元素后面,那么 交换后稳定性就被破坏了。比较拗口,举个例子,序列5 8 5 2 9, 我们知道第一遍选择第1个元素5会和2交换,那么原序列中2个5的相对前后顺序就被破坏了,所以选择排序不是一个稳定的排序算法。

    由此可见,直接选择排序的效率是很低的,如果想提高效率,则应该使用堆排序!堆排序是一种高效的选择排序算法,它的详细介绍请看下一节。

    展开全文
  • 选择排序原理及思路

    2020-07-05 20:35:54
    1.选择排序原理 话不多说,直接上图 图中的黄色部分为我们已经排好序的数组部分 图中的红色部分为未排好序数组中遍历过的最小值 图中的蓝色部分为未排序的数组部分 2.思路 遍历数组中未排序的部分,取出...

    1.选择排序原理

    选择排序其实就是选择出未排序部分的最小值,进行排序操作

    话不多说,直接上图

    图中的黄色部分为我们已经排好序的数组部分

    图中的红色部分为未排好序数组中遍历过的最小值

    图中的蓝色部分为未排序的数组部分

    2.思路

    遍历数组中未排序的部分,取出最小值,和未排序的第一个交换位置,然后重复此操作

    代码如下

    /**
         * 选择排序
         */
        public static int[] selectionSort(int[] arr){
    
            //临时变量,用于临时存放
            int temp;
            for(int k = 0; k < arr.length-1;k++) {
                //定义数组中最小值的下标,根据下标就能找到数组中的最小值,每一轮开始就重新定义最小值
                int minIndex = k;
                for (int i = k+1; i < arr.length; i++) {
                    //如果遇到比之前最小值小的,就重新赋值下标位置
                    if (arr[minIndex] > arr[i]) {
                        minIndex = i;
                    }
                }
                //如果最小值不是当前值,则进行交换
                if(k != minIndex) {
                    temp = arr[k];
                    arr[k] = arr[minIndex];
                    arr[minIndex] = temp;
                }
            }
            System.out.print(Arrays.toString(arr));
            return arr;
        }

     

    展开全文
  • 选择排序原理 #原理 选择排序原理是在一个数组中选择一个固定的数(最大或最小),每次都拿这个数与剩余的数比较,把最大(最小)的数值赋给固定的数,再按顺序组成新的数组,一直如此执行,直到拿到全部. 举例证明 举一...
  • 选择排序(Selection Sort )分为两种 简单选择排序(Simple Selection Sort) 和树形选择排序。  简单选择排序(Simple Selection Sort):  简单选择排序类似于冒泡排序(Bubble Sort) ,每次都会在剩下的元素...
  • 选择排序原理: 从第一个元素(当前元素)开始,依次与其后面的元素比较,找到最小的元素,与当前元素位置互换;直至当前元素为最小元素的时候,排序完成 选择排序原理动态图(摘自网络) Demo代码 //选择...
  • 算法--数组冒泡排序和选择排序原理分析以及优缺点
  • 选择排序原理讲解 2.代码块 public static void SelectSortMethod(int[] arr) { int temp = 0; for (int i = 0; i < arr.Length - 1; i++) { int minVal = arr[i]; //假设 i 下标就是最小的数 int
  • 选择排序原理和代码

    2021-03-13 21:47:32
    选择排序(Selection sort)的工作原理是:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素...
  • 冒泡排序:字如其名,就像冒泡一样,泡泡从水中向上升起的过程中是有小逐层变大。 实现原理:数组中前一位元素和后一位元素依次比较,如果前一位元素大于(或小于)后一位元素,就交换两元素的位置,这样就能保证...
  • 与冒泡排序和直接插入排序相比,选择排序的元素值交换次数要少很多,所以其排序速度也比前者要快一些。 相关导读: 详解冒泡排序原理和过程 https://blog.csdn.net/number1killer/article/details/79032636 直接...
  • 数组--选择排序原理

    2019-09-18 22:45:10
    选择排序是不稳定的排序方法。 2 选择排序图解 3 代码详解 public static void main(String[] args) { //定义一个数组 int[] arr = {17,24,4,56,20,18}; // 遍历排序前数组 printA...
  • 选择排序 计算机写代码的时候经常要用到数组排序什么的,冒泡法啊选择排序啊很常用,其实选择排序法更常用的,因为不浪费资源,更简洁…… 选择排序法比冒泡法更加实用,把数组从大到小排列,举个例子解释一下,数组...
  • 选择排序 1.简介: 选择排序是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后...
  • * 冒泡排序原理:数组中参与比较的元素交换位置不是都有意义,交换次数多 * 例如数组 int arr[] = {5,4,9,10,6}; * 使用循环语句,每次循环将数组下标为0的元素,和右边相邻的元素进行比较,如果比右边的元素大则...
  • 选择排序的算法相对简单,其基本原理与步骤是: 1. 首先,假设数组的第一个元素是最小值,将其值与下标记录; 2. 从第二个元素开始与最小值比较,若该元素小于最小值,则更新最小值与最小值下标;反之则继续下一个...
  • 一、原理 第一次从待排序的数据元素中选出最小(或者最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找...对数据[1, 4, 2, 6, 7, 3, 5, 10, 9]进行选择排序(由小到大)。 第一次排序:1与.
  • 选择排序 选择排序:从0索引开始,依次和后面元素比较,小的往前放,第一次完毕,最小值出现在了最小索引处。 package com.heima.array; public class Demo02_Array { /** * * A:案例演示 * 数组高级选择排序...
  • 原理 迭代数组,每次都取其中最小,与所在位置元素进行交换 例如 待排序数组为 [3,5,6,7,1,2] 第一轮循环i 为0 ,最小元素为1 将 1和3交换,继续迭代 i 为1 将5与2交换直到得到一个有序的数组。 代码实现 ...
  • 【c++】冒泡排序和选择排序原理及实现

    千次阅读 多人点赞 2018-05-03 18:06:59
    【c++】冒泡排序和选择排序 1.冒泡排序 冒泡排序是一种稳定排序算法,时间复杂度为O(n)。原理: 冒泡排序算法的运作如下:(从后往前)(1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。(2)对每...
  • 选择排序原理证明及Java实现

    千次阅读 2018-08-11 13:54:54
     选择排序是较为简单的排序算法之一,它的原理就是每次把剩余元素中最小的那个挑选出来放在这些剩余元素的首位置,举个栗子: 长度为5的一个数组:3,0,-5,1,8  第一次选择后: -5,0,3,1,8 第二次选择后...
  • 选择排序原理及实现

    2014-08-03 09:18:50
    选择排序实现是每趟将循环的
  • 选择排序 实现原理 选择排序是一种原址比较排序算法。大致思路是找到数据结构中的最小值并将其放置在第一位,接着找到第二小的值并将其放在第二位,以此类推。 实现代码 function selectionSort(arr) { if (arr....
  • 选择排序是一种简单直观的排序算法,其基本原理如下:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录的位置与第一个记录的位置交换;接着对不包括第一个记录以外的其他记录进行第二次比较,得到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,430
精华内容 2,572
关键字:

选择排序原理