排序算法之选择排序(2)

最新推荐文章于 2022-07-09 17:09:17 发布
最新推荐文章于 2022-07-09 17:09:17 发布
阅读量175 收藏
点赞数
分类专栏： 算法之旅 文章标签： 算法 数据结构 排序算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46701838/article/details/113058094
版权

1.1排序思路

在这里插入图片描述

1.2具体实现

  • 选择排序的次数=数组大小-1 次
  • 每1轮排序，又是一个循环，循环的规则：
  1. 先假设当前这个数是最小数
  2. 然后和后面的每个数比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标
  3. 当遍历到数组的最后时，就得到本轮最小数和下标
  4. 交换

1.第一轮排序

public class SelectSort {
    public static void main(String[] args) {
        int arr[] = {3, 1, 5, 4};
        selectSort(arr);
    }

    //选择排序
    public static void selectSort(int[] array) {
        //原始数组 3,1,5,4
        //第一轮排序1,3,5,4
        //1.先假定最小数为第一个数
        int minIndex = 0;
        int min = array[0];
        //2.遍历寻找最小的指
        for (int j = 0 + 1; j < array.length; j++) {
            if (min > array[j]) {
                min = array[j];//重置min min=1
                minIndex = j;//重置minIndex  minIndex=1
            }
        }
        if (minIndex != 0) {
            //3.将最小值，放在arr[0],即交换
            array[minIndex] = array[0];//将第一个值放到最小值的地方[3,3,5,4]
            array[0] = min;//将最小值放到第一个[1,3,5,4]
            System.out.println("第一轮排序：" + Arrays.toString(array));
        }     
    }
}


第一轮排序：[1, 5, 3, 4]

2.第二轮排序：

public class SelectSort {
    public static void main(String[] args) {
        int arr[] = {3, 1, 5, 4};
        selectSort(arr);
    }

    //选择排序
    public static void selectSort(int[] array) {
        //原始数组 3,1,5,4
        //第一轮排序1,3,5,4
        //1.先假定最小数为第一个数
        int minIndex = 0;
        int min = array[0];
        //2.遍历寻找最小的指
        for (int j = 0 + 1; j < array.length; j++) {
            if (min > array[j]) {
                min = array[j];//重置min min=1
                minIndex = j;//重置minIndex  minIndex=1
            }
        }
        if (minIndex != 0) {
            //3.将最小值，放在arr[0],即交换
            array[minIndex] = array[0];//将第一个值放到最小值的地方[3,3,5,4]
            array[0] = min;//将最小值放到第一个[1,3,5,4]
            System.out.println("第一轮排序：" + Arrays.toString(array));
        }
        //原始数组 3,1,5,4
        //第一轮排序1,3,5,4
        //第二轮排序1，3，4，5
        //1.先假定最小数为第一个数
        minIndex = 1;
        min = array[1];
        //2.遍历寻找最小的指
        for (int j = 1 + 1; j < array.length; j++) {
            if (min > array[j]) {
                min = array[j];//重置min min=3
                minIndex = j;//重置minIndex  minIndex=2
            }
        }
        if (minIndex != 1) {
            //3.将最小值，放在arr[1],即交换
            array[minIndex] = array[1];//将第二个值放到最小值的地方[1,3,5,4]
            array[1] = min;//将最小值放到第一个[1,3,5,4]
            System.out.println("第二轮排序：" + Arrays.toString(array));
        }
    }
}

第一轮排序：[1, 5, 3, 4]

3.第三轮排序：

public class SelectSort {
    public static void main(String[] args) {
        int arr[] = {3, 1, 5, 4};
        selectSort(arr);
    }

    //选择排序
    public static void selectSort(int[] array) {
        //原始数组 3,1,5,4
        //第一轮排序1,3,5,4
        //1.先假定最小数为第一个数
        int minIndex = 0;
        int min = array[0];
        //2.遍历寻找最小的指
        for (int j = 0 + 1; j < array.length; j++) {
            if (min > array[j]) {
                min = array[j];//重置min min=1
                minIndex = j;//重置minIndex  minIndex=1
            }
        }
        if (minIndex != 0) {
            //3.将最小值，放在arr[0],即交换
            array[minIndex] = array[0];//将第一个值放到最小值的地方[3,3,5,4]
            array[0] = min;//将最小值放到第一个[1,3,5,4]
            System.out.println("第一轮排序：" + Arrays.toString(array));
        }
        //原始数组 3,1,5,4
        //第一轮排序1,3,5,4
        //第二轮排序1，3，4，5
        //1.先假定最小数为第一个数
        minIndex = 1;
        min = array[1];
        //2.遍历寻找最小的指
        for (int j = 1 + 1; j < array.length; j++) {
            if (min > array[j]) {
                min = array[j];//重置min min=3
                minIndex = j;//重置minIndex  minIndex=2
            }
        }
        if (minIndex != 1) {
            //3.将最小值，放在arr[1],即交换
            array[minIndex] = array[1];//将第二个值放到最小值的地方[1,3,5,4]
            array[1] = min;//将最小值放到第一个[1,3,5,4]
            System.out.println("第二轮排序：" + Arrays.toString(array));
        }
        //原始数组 3,1,5,4
        //第一轮排序1,3,5,4
        //第二轮排序1,3,5,4
        //第三轮排序1，3，4，5
        //1.先假定最小数为第一个数
        minIndex = 2;
        min = array[2];
        //2.遍历寻找最小的指
        for (int j = 1 + 1 + 1; j < array.length; j++) {
            if (min > array[j]) {
                min = array[j];//重置min min=4
                minIndex = j;//重置minIndex  minIndex=3
            }
        }
        if (minIndex != 2) {
            //3.将最小值，放在arr[2],即交换
            array[minIndex] = array[2];//将第二个值放到最小值的地方[1,3,5,5]
            array[2] = min;//将最小值放到第一个[1,3,4,5]
            System.out.println("第三轮排序：" + Arrays.toString(array));
        }
    }
}

第一轮排序：[1, 3, 5, 4]
第三轮排序：[1, 3, 4, 5]

4.代码优化(降序排序)

public class SelectSort1 {
    public static void main(String[] args) {
        int arr[] = {3, 1, 5, 4};
        System.out.println("排序前:"+Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序后:"+Arrays.toString(arr));
    }

    //选择排序
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            //1.先假定最小数为第一个数
            int minIndex = i;
            int min = array[i];
            //2.遍历寻找最小的指
            for (int j = i + 1; j < array.length; j++) {
                if (min > array[j]) {
                    min = array[j];//重置min
                    minIndex = j;//重置minIndex
                }
            }
            if (minIndex != i) {
                //3.将最小值，放在arr[i],即交换
                array[minIndex] = array[i];
                array[i] = min;
            }
        }

    }
}

排序前:[3, 1, 5, 4]
排序后:[1, 3, 4, 5]

5.升序

public class SelectSort1 {
    public static void main(String[] args) {
        int arr[] = {3, 1, 5, 4};
        System.out.println("排序前:"+Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序后:"+Arrays.toString(arr));
    }

    //选择排序
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            //1.先假定最小数为第一个数
            int minIndex = i;
            int min = array[i];
            //2.遍历寻找最小的指
            for (int j = i + 1; j < array.length; j++) {
                if (min < array[j]) {
                    min = array[j];//重置min
                    minIndex = j;//重置minIndex
                }
            }
            if (minIndex != i) {
                //3.将最小值，放在arr[i],即交换
                array[minIndex] = array[i];
                array[i] = min;
            }
        }

    }
}

排序前:[3, 1, 5, 4]
排序后:[5, 4, 3, 1]

1.3.时间复杂度

O(n2 )

1.4测试选择排序算法速度

public class SelectSort1 {
    public static void main(String[] args) {
        //int arr[] = {3, 1, 5, 4};
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i]=(int)(Math.random()*800000);
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = simpleDateFormat1.format(date1);
        System.out.println("排序前的时间是："+format1);
       //System.out.println("排序前:"+Arrays.toString(arr));
        selectSort(arr);
        //System.out.println("排序后:"+Arrays.toString(arr));
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format2 = simpleDateFormat2.format(date2);
        System.out.println("排序后的时间是："+format2);
        
    }

    //选择排序
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            //1.先假定最小数为第一个数
            int minIndex = i;
            int min = array[i];
            //2.遍历寻找最小的指
            for (int j = i + 1; j < array.length; j++) {
                if (min < array[j]) {
                    min = array[j];//重置min
                    minIndex = j;//重置minIndex
                }
            }
            if (minIndex != i) {
                //3.将最小值，放在arr[i],即交换
                array[minIndex] = array[i];
                array[i] = min;
            }
        }

    }
}

排序前的时间是：2021-01-08 21:38:19
排序后的时间是：2021-01-08 21:38:22
Coder-liu
关注
专栏目录
选择排序
DonHear
01-30 540
本章是对选择排序的分析和实现过程 《Java数据结构与算法》中的例子 棒球队员按身高从矮到高站队 生活中与程序规则的对比可以参考冒泡排序一章 冒泡排序 不同的是选择排序相对与冒泡排序，会省去很多元素交换时带来的开销 棒球队员开始站队之前，规定存在一个记牌器用于记录最矮队员现阶段的站位 开始两两人员进行比较，以0号队员为记牌器起点号码，当后面出现比其矮的队员，则在记牌器上替换下号码，但并不做位置交换 继续比较时则按照记牌器中现阶段存在的号码为基点，继续比较，以此类推 队列从头到尾比较完一趟时，记牌器上.
常见排序算法之选择排序——直接选择排序、堆排序
保护小周ღ的博客
06-05 2064
哈喽大家好，我是保护小周ღ，本期为大家带来的是常见排序算法中的选择排序，主要有直接选择排序以及——堆排序（有点难理解），包您一看就会，快来试试吧~ ​
排序算法2-选择排序
混子的博客
10-20 144
代码实现 /** * 选择排序 * 最好最坏时间复杂度：n^2 */ public class SelectSort { public static void main(String[] args) { int[] arr = {300, 900, -19, -10, -20}; //默认最小值 int min = 0; //记录最小值下标 int minIndex = 0; for (int i
Sicily-选择排序比较次数
banfengzhuo7614的博客
01-19 684
选择排序的比较次数为n(n-1)/2，但是这里还是通过老老实实的比较来进行次数累加，为的就是更明白选择排序的原理。 选择排序的原理：在未排序的数中选出最小的数同未排序数的首位比较，如果比它小，互换位置。 #include<cstdio> #include<iostream> using namespace std; int main() {...
java实现几种常用排序:选择排序
weixin_33850890的博客
01-09 143
一.选择排序介绍 选择排序，顾名思义就是用逐个选择的方式来进行排序，逐个选择出数组中的最大（或最小）的元素，直到选择至最后一个元素。此时数组完成了排序。 二.选择排序原理分析 三.选择排序代码实现 /** * @Author {LearnAndGet} * @Time 2019年1月8日 * @Discription:选择排序 */ package com.sort; import ...
Java中的选择排序算法
专业的开发者“讨论”
04-23 160
选择排序是一种排序算法，特别是就地比较排序，用&#20110...
算法设计与分析-1排序算法性能分析-冒泡/选择/插入/合并/快速排序-pre ppt
06-18
本篇文章将详细讨论几种常见的排序算法：选择排序、冒泡排序、插入排序、合并排序以及快速排序，分析它们的算法原理、时间效率，并通过经验分析验证理论分析的准确性。 **1. 选择排序(Selection Sort)** 选择排序...
JavaScript实现经典排序算法之选择排序
11-30
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n²)的时间复杂度…..所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。 1）算法原理  先在未排序序列中找到最小（大）元素，...
C语言基本排序算法之插入排序与直接选择排序实现方法
08-29
C语言基本排序算法之插入排序与直接选择排序实现方法 C语言基本排序算法之插入排序与直接选择排序实现方法是计算机科学中最基本的排序算法之一。排序算法是指将一组无序的数据按照一定的规则排列成有序的序列的过程...
C语言练习之排序算法：选择排序
最新发布
01-16
在初学C语言时，比较重要的知识点就是排序算法，这里提供了一种选择排序算法的实现路径，供广大学习者参考。
排序算法--选择排序
weixin_42738354的博客
01-26 757
一.选择排序的思路 选定第一个索引位置，然后和后面的元素依次比较 如果后面的元素，小于第一个元素的值，则交换位置 经过一轮比较后，可以确定第一位置是最小的 可以看出选择排序，第一轮会选出最小值，第二轮会选出第二小的值，直到最后 二.选择排序的代码 ArrayList.prototype.selectsort = function(){ var length = this.array.length //1.外层循环：从0位置开始取数据 for(var j = 0; j < length - 1
排序算法之选择排序
mr_listening的博客
05-15 457
我们经常能遇到这样的问题，让你对一串数据进行排序，比如对一个数组，对顺序表等等进行排序。排序的方法有很多，你可以任意选择，只要能达到人家所要求的效果。一说到排序，对我来说最熟悉的就是冒泡排序，对于冒泡排序只要你掌握好了两个循环的条件其实很简单，今天我们谈谈另外一种排序算法：选择排序。        首先我们来说说选择排序的原理，我们还是要用两层for循环，外循环代表循环的次数，内循环是每次循
排序算法-选择排序
何毅
09-08 326
选择排序比较简单排序，思路简单直观，每一次循环都会从无序数组中找到最小值都重新排序； 思路： 1. 从数组从选出最小元素，和第一位置数据交换 2. 接着从N-1数据中找到最小值，与第二元素交换 3. 循环，交换数据，知道数据完成排序Demo: 完整源码地址/** * @Title: 排序基本算法 * @Package ${package_name} * @D
选择排序（Selection sort）
m0_51041464的博客
07-09 134
将未排序的第一个数字和剩余每个数字进行对比，如果与预期顺序（升序）不符，则换位第一轮完成后，最小的数字到了第一位，所以第二轮只需要从第二位开始比较，第三轮从第三位…以此类推。每一轮都较上轮执行次数-1（递减）。当仅剩一个数字时，这个数字便是最大的数字循环轮次 = 数组长度 - 1每轮执行次数 = 数组长度 - 当前轮次 实现步骤.........
排序：选择排序（算法）
Promise Sun special column
07-06 1657
简介 原理过程图 时间复杂度 性能分析 稳定性 重要特点 选择排序与冒泡排序哪个效率更高
【算法四】排序算法之选择排序
花铛
06-29 1172
选择排序（Selection Sort）：是一种简单的排序算法，也是一种不稳定的排序算法。其实现原理是：在待排序序列中不断进行比较，一轮遍历选出一个最值，将其按顺序存放在已排序序列中；重复此步骤，直到待排序序列中的数据都排序完毕。 假设待排序序列为 5、3、6、1、0，如果采用选择排序对其进行升序排序，则整个排序过程如下所示： 选择排序改进了冒泡排序，将交换的次数由 减少到 ，但是比较的次数仍然是 。通常认为选择排序在执行效率上是高于冒泡排序的。上面的例子一共有 5 个数字，第一轮遍历进行了 4 次比较，
选择排序算法详解
SSS4362的博客
06-10 594
此篇文章用java语言详细讲解了选择排序算法, 主要可分从前往后排序和从后往前排序这两种思路。 从前往后排序包含第一个位置的数当成最大值(降序)、第一个位置的数当成最小值(升序)这两种情况都是固定第一个位置(在未排序数组中)为当前最大值或最小值,然后往后缩小范围 从后往前排序包含最后一个位置的数当成最小值(降序),最后一个位置的数当成最大值(升序)这两种每次排序都是固定第最后一位置(位置参照物为未排序数组)为当前最大值或最小值,然后往后缩小范围......
选择排序算法
denghe4720的博客
07-16 109
假设你的计算机存储了很多音乐，对于每首音乐，你都记录了其播放次数。 那么你需要将这个音乐列表按播放次数从多到少进行排序。假设这个列表的长度是 n 首先遍历这个列表，找出播放次数最多的歌曲，将其放到一个新列表的第一位，操作遍历 次数为 n 然后再次编译剩下的列表，找出播放次数最多的歌曲，把它放到排序列表的第二位，操作遍历 次数 为 n-1 以此类推操作遍历次数为 n-2;...2;...
排序算法详解：插入排序与选择排序
这两种排序算法各有特点：插入排序在最好情况下的时间复杂度为O(n)（已排序或几乎排序的情况），最坏情况下为O(n^2)，而选择排序无论什么情况，时间复杂度都是O(n^2)。在实际应用中，如果数据规模较小或者接近有序，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值