冒泡排序与选择排序

示例数组:

$array = [62, 88, 58, 47, 62, 35, 73, 51, 99, 37, 93];

一、冒泡排序

将数组分为有序和无序两部分,无序序列中的相邻元素进行比较,如果前面的元素值大于后边的元素值,两者交换,第一轮排序后,最大值(99)会放入有序序列的最前边(10的位置),即有序序列中的元素为[99],如下所示:

Array ( [0] => 62 [1] => 58 [2] => 47 [3] => 62 [4] => 35 [5] => 73 [6] => 51 [7] => 88 [8] => 37 [9] => 93 [10] => 99 )

第二轮排序,同理,无序序列中从第一个元素开始,相邻元素相比较,如果前者大于后者,交换数据,在9的位置结束(10为有序序列的位置),第二轮排序结束后,第二轮的最大元素插入有序序列的最前边(93在9的位置),即有序序列的元素为[93,99],结果如下所示:

Array ( [0] => 58 [1] => 47 [2] => 62 [3] => 35 [4] => 62 [5] => 51 [6] => 73 [7] => 37 [8] => 88 [9] => 93 [10] => 99 )

以此类推,经过10轮完成排序,如下:

第1次排序结束
Array ( [0] => 62 [1] => 58 [2] => 47 [3] => 62 [4] => 35 [5] => 73 [6] => 51 [7] => 88 [8] => 37 [9] => 93 [10] => 99 )

第2次排序结束
Array ( [0] => 58 [1] => 47 [2] => 62 [3] => 35 [4] => 62 [5] => 51 [6] => 73 [7] => 37 [8] => 88 [9] => 93 [10] => 99 )

第3次排序结束
Array ( [0] => 47 [1] => 58 [2] => 35 [3] => 62 [4] => 51 [5] => 62 [6] => 37 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

第4次排序结束
Array ( [0] => 47 [1] => 35 [2] => 58 [3] => 51 [4] => 62 [5] => 37 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

第5次排序结束
Array ( [0] => 35 [1] => 47 [2] => 51 [3] => 58 [4] => 37 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

第6次排序结束
Array ( [0] => 35 [1] => 47 [2] => 51 [3] => 37 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

第7次排序结束
Array ( [0] => 35 [1] => 47 [2] => 37 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

第8次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

第9次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

第10次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

二、选择排序

将数组分为有序与无序两部分,有序序列在前边,无序序列在后边,每一轮排序将无序序列中的第一个元素与剩余元素进行比较,找到最小元素后放到有序序列的最后。

第一轮排序,有序序列默认为空,找出数组中的最小元素(35),放入有序序列中(有序序列元素只有35一个元素),结果如下:

Array ( [0] => 35 [1] => 88 [2] => 62 [3] => 58 [4] => 62 [5] => 47 [6] => 73 [7] => 51 [8] => 99 [9] => 37 [10] => 93 )

以此类推,10轮排序后结束,如下:

第1次排序结束
Array ( [0] => 35 [1] => 88 [2] => 62 [3] => 58 [4] => 62 [5] => 47 [6] => 73 [7] => 51 [8] => 99 [9] => 37 [10] => 93 )

第2次排序结束
Array ( [0] => 35 [1] => 37 [2] => 88 [3] => 62 [4] => 62 [5] => 58 [6] => 73 [7] => 51 [8] => 99 [9] => 47 [10] => 93 )

第3次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 88 [4] => 62 [5] => 62 [6] => 73 [7] => 58 [8] => 99 [9] => 51 [10] => 93 )

第4次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 88 [5] => 62 [6] => 73 [7] => 62 [8] => 99 [9] => 58 [10] => 93 )

第5次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 88 [6] => 73 [7] => 62 [8] => 99 [9] => 62 [10] => 93 )

第6次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 88 [7] => 73 [8] => 99 [9] => 62 [10] => 93 )

第7次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 88 [8] => 99 [9] => 73 [10] => 93 )

第8次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 99 [9] => 88 [10] => 93 )

第9次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 99 [10] => 93 )

第10次排序结束
Array ( [0] => 35 [1] => 37 [2] => 47 [3] => 51 [4] => 58 [5] => 62 [6] => 62 [7] => 73 [8] => 88 [9] => 93 [10] => 99 )

两者共同点:

将数组分为有序序列与无序序列,将每轮筛选出来的元素插入有序序列,黄的部分为有序序列

不同点:

冒泡排序——相邻元素比较,找出最大值,放入有序序列的最前边;

选择排序——用无序序列中的第一个元素与剩余无序序列元素进行比较,找出最小元素,插入有序序列的最后边

时间: 2024-12-19 19:54:28

冒泡排序与选择排序的相关文章

java面向对象的冒泡排序,选择排序和插入排序的比较

这三种排序有俩个过程: 1.比较俩个数据. 2.交换俩个数据或复制其中一项. 这三种排序的时间级别 冒泡排序:比较 (N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2 交换  0——N2/2 = N2/4 总时间 3/4*N2 选择排序:比较 (N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2 交换  0——3*(N-1)=3*(N-1)/2=3/2*N 总时间 N2/2+3/2*N 插入排序:第一轮最多比较一次,第二轮最多比较俩次,最后一轮比较N-1

ObjC语法练习 冒泡排序、选择排序、矩阵相乘

用OC实现的冒泡排序.选择排序.矩阵相乘,纯粹是用来练习语法. 冒泡排序,程序如下: void bubbleSort() { //初始化数组 NSMutableArray *array1 = [[NSMutableArray alloc] initWithCapacity:8]; [array1 addObject:@"5"]; [array1 addObject:@"10"]; [array1 addObject:@"8"]; [array1

#排序算法#【1】概述、冒泡排序、选择排序

排序算法分类: 内部排序(在排序过程中不需要访问外存就可以完成排序) 外部排序 内部排序分类: 交换排序 冒泡排序 快速排序 选择排序 直接选择排序 堆排序 插入排序 直接插入排序 希尔排序 合并排序 外部排序: 常见的是多路归并算法,即将原文件分为多个能够一次装入内存一部分,分别把每一部分调入内存完成排序,然后对已经排序的子文件进行归并排序 冒泡排序法: 冒泡排序法是一种相邻数据交换的排序方法. 冒泡排序法的基本思想是:对待排序记录关键字从后往前(逆序)进行多遍扫描,当发现相邻两个关键字的次序

JavaScript算法(冒泡排序、选择排序与插入排序)

冒泡排序.选择排序与插入排序复杂度都是指数级别的,放在一起说吧. 介绍一些学习这三个排序方法的比较好的资料.冒泡排序看<学习JavaScript数据结构与算法>介绍的冒泡排序,选择排序看<计算机科学概论(第三版)>里介绍的选择排序,插入排序看<计算机科学概论(第11版)>里介绍的插入排序, 通过这三份资料弄明白实现原理之后,最后看<学习JavaScript数据结构与算法>一书里的JS实现代码. 嗯,这本书里都有现成代码,就不在这儿写了,关键是弄清楚原理,然后

插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——C++实现

首先是算法实现文件Sort.h,代码如下: /* * 实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 * 以及快速排序.归并排序.堆排序和LST基数排序 * @author gkh178 */ #include <iostream> template<class T> void swap_value(T &a, T &b) { T temp = a; a = b; b = temp; } //插入排序:时间复杂度o(n^2) template<

黑马程序员——冒泡排序和选择排序——熟悉又陌生的排序方法

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 昨天做基础测试题,遇到了个排序问题,写完后脑子里突然跳出了“冒泡排序法”这个名词.“冒泡排序法”和“选择排序法”是每个程序初学者都会学到的两个排序方法,但是好多人对这两个排序方法是既熟悉又陌生,熟悉是因为凡是遇到排序一般都会想到这两个方法,陌生是因为细细一想对这两个方法的原理和区别又不是很清楚.不较真还好,初学者一较真就很容易被这两个方法搞晕了,我当时也被这两个方法搞晕了,就又认认真真一步一步

冒泡排序、选择排序

下面是两种最基本的排序:冒泡排序.选择排序.复杂度均为O(n^2). 冒泡排序: bool BubbleSort(int arr[],int len) { if(arr == NULL || len <= 0) { return false; } int i,j,temp; int flag = 1; for(i = 0; i < len -1 && flag; i++)//注意:i < len-1 而不是len { flag = 0;//flag标志可以提前结束循环 f

冒泡排序,选择排序,快速排序

package com.hello; public class HelloJava { /** * 冒泡排序(通过一次一次的循环,根据相近两个值进行比较,将大的值往下移) * @author MR ZHANG * @param arr * @return */ public static void getBubbleSort(int[] arr){ for(int i = 1;i< arr.length-1;i++){ for(int j=0; j< arr.length-i;j++){ if

冒泡排序和选择排序

冒泡排序和选择排序是排序算法中比较简单和容易实现的算法.冒泡排序的思想为:每一次排序过程,通过相邻元素的交换,将当前没有排好序中的最大(小)移到数组的最右(左)端.而选择排序的思想也很直观:每一次排序过程,我们获取当前没有排好序中的最大(小)的元素和数组最右(左)端的元素交换,循环这个过程即可实现对整个数组排序. 选择排序的平均时间复杂度比冒泡排序的稍低:同样数据的情况下,2种算法的循环次数是一样的,但选择排序只有0到1次交换,而冒泡排序只有0到n次交换.   1.冒泡法:这是最原始,也是众所周

冒泡排序和选择排序区别

/*冒泡排序:每一次循环数值较小的的就能像气泡一样慢慢浮现出来  * 两层循环,第一层循环控制循环的次数, 第二层拿数组中的第二个数进行和第一层循环中的数进行比较, * */        int[] nums = { 29, 13, 23, 10, 72, 41, 21, 77 };        int temp = 0;        for (int i = 0; i < nums.length - 1; i++) {            for (int j = i + 1; j <