排序1-冒泡，选择和插入

最新推荐文章于 2020-12-01 14:14:47 发布
最新推荐文章于 2020-12-01 14:14:47 发布
阅读量638 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwhlxl/article/details/46663199
版权

冒泡排序（Bubble sort）

最简单，效率最低的冒泡排序

冒泡排序是一种交换排序，基本思想是：两两比较相邻记录的的关键字，如果反序则交换，直到没有反序的记录为止。
这里写图片描述

时间复杂度分析

最好的情况是，数组是有序的，只需要n - 1次的比较，时间复杂度是 O(n)
最坏的情况是，数组是逆序的，需要比较 ∑ni=2(i−1)=1+2+3+...+(n−1)=n(n−1)2 , 所以时间复杂度为 O(n2)

代码实现

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}

测试程序

#include <iostream>
#include <cstring>
#include <ctime>
using namespace std;


#define ArraySize 100000


void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x   = *y;
    *y   = temp;
}

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}
void Print_array(int arr[], int len)
{
    for(int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

}

int main(int argc, char const *argv[])
{
    /* code */
    int Array[ArraySize];
    int Array1[ArraySize];
    int Array2[ArraySize];

    time_t begin , end;

    srand(time(NULL));



    for(int i = 0; i < ArraySize; i ++)
    {
        Array[i] = rand()%ArraySize;
        //cout << Array[i] << " ";
    }

    memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
    memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));

//  Print_array(Array, ArraySize);

    begin = clock();
    Bubble_sort(Array, ArraySize);
    end = clock();
    cout << "Bubble_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << endl;

    begin = clock();
    Bubble_sort1(Array1, ArraySize);
    end = clock();
    cout << "Bubble_sort1 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << endl;

    begin = clock();
    Bubble_sort2(Array2, ArraySize);
    end = clock();
    cout << "Bubble_sort2 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << endl;

    //Print_array(Array, ArraySize);
    return 0;
}

看下运行结果就知道有多慢了，这里我随机初始化了十万大小的数组：

Bubble_sort runtime:   24.2s
Bubble_sort1 runtime:   15.481s
Bubble_sort2 runtime:   15.146s

选择排序（Slection Sort）

基本思想

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。https://zh.wikipedia.org/wiki/%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F
这里写图片描述

代码实现

void Slect_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        int min_index = i ;
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[min_index] > arr[j])
                min_index = j;
        }

        if(i != min_index)
            swap(arr[i],arr[min_index]);
    }
}

测试代码

#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;


#define ArraySize 100000


void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x   = *y;
    *y   = temp;
}

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}

void Slect_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        int min_index = i ;
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[min_index] > arr[j])
                min_index = j;
        }

        if(i != min_index)
            swap(arr[i],arr[min_index]);
    }
}


void Print_array(int arr[], int len)
{
    for(int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

}

int main(int argc, char const *argv[])
{
    /* code */
    int Array[ArraySize];
    int Array1[ArraySize];
    int Array2[ArraySize];

    time_t begin , end;

    srand(time(NULL));



    for(int i = 0; i < ArraySize; i ++)
    {
        Array[i] = rand()%ArraySize;
        //cout << Array[i] << " ";
    }

    memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
    memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));

//  Print_array(Array, ArraySize);

    begin = clock();
    Bubble_sort2(Array, ArraySize);
    end = clock();
    cout << "Bubble_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Slect_sort(Array1, ArraySize);
    end = clock();
    cout << "Slect_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    //Print_array(Array2, ArraySize);
    return 0;
}

运行结果如下，比冒泡稍微快了点。

Bubble_sort runtime:   15.274s
Slect_sort runtime:   11.058s

时间复杂度分析

比较次数 O(n2) ，比较次数与关键字的初始状态无关，总的比较次数 N=(n−1)+(n−2)+...+1=n×(n−1)/2 。交换次数 O(n) ，最好情况是，已经有序，交换0次；最坏情况是，逆序，交换n-1次。交换次数比冒泡排序较少。所以总的时间复杂度依然为 O(n2)

插入排序（Insert Sort）

基本思想

插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。https://zh.wikipedia.org/wiki/%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F
这里写图片描述 这里写图片描述

代码实现

void Insert_sort(int arr[], int len)
{

    for(int i= 1; i < len; i ++)
    {   
        int key = arr[i];
        int j = i;
        while(j && arr[j - 1] > key)
        {
            arr[j] = arr[j - 1];
            j --;
        }

        arr[j] = key;
    }
}

测试代码

#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;


#define ArraySize 100000


void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x   = *y;
    *y   = temp;
}

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}

void Slect_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        int min_index = i ;
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[min_index] > arr[j])
                min_index = j;
        }

        if(i != min_index)
            swap(arr[i],arr[min_index]);
    }
}

void Insert_sort(int arr[], int len)
{

    for(int i= 1; i < len; i ++)
    {   
        int key = arr[i];
        int j = i;
        while(j && arr[j - 1] > key)
        {
            arr[j] = arr[j - 1];
            j --;
        }

        arr[j] = key;
    }
}
void Print_array(int arr[], int len)
{
    for(int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

}

int main(int argc, char const *argv[])
{
    /* code */
    int Array[ArraySize];
    int Array1[ArraySize];
    int Array2[ArraySize];

    time_t begin , end;

    srand(time(NULL));



    for(int i = 0; i < ArraySize; i ++)
    {
        Array[i] = rand()%ArraySize;
        //cout << Array[i] << " ";
    }

    memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
    memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));

//  Print_array(Array, ArraySize);

    begin = clock();
    Bubble_sort2(Array, ArraySize);
    end = clock();
    cout << "Bubble_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Slect_sort(Array1, ArraySize);
    end = clock();
    cout << "Slect_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Insert_sort(Array2, ArraySize);
    end = clock();
    cout << "Insert_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    //Print_array(Array2, ArraySize);
    return 0;
}

运行结果如下，比冒泡和选择都快。

Bubble_sort runtime:   15.336s
Slect_sort runtime:   11.044s
Insert_sort runtime:   6.453s

时间复杂度分析

最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需 (n−1) 次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有 n(n−1)/2 次。插入排序的赋值操作是比较操作的次数减去 (n−1) 次。平均来说插入排序算法复杂度为 O(n2) 。

zengwh513
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
冒泡排序---选择，插入和快速排序
01-04
冒泡排序---选择，插入和快速排序 简单实用,非常棒的一个java工具类.
Python 冒泡，选择，插入排序使用实例
09-22
本文将详细介绍三种常见的排序算法：冒泡排序、选择排序和插入排序。这三种排序算法都是基础的、易于理解的算法，对于初学者来说非常有帮助。 1. **冒泡排序**（Bubble Sort）： 冒泡排序是一种简单的排序算法，其...
排序算法（1）：冒泡排序和插入排序
weixin_30342209的博客
02-02 131
1.1 冒泡排序 冒泡排序需要多次遍历列表。它比较相邻的项并交换那些无序的项。每次遍历列表将下一个最大的值放在其正确的位置。实质上，每个项“冒泡”到它所属的位置。 用python写交换操作时，与大多数编程语言略有不同（需要临时储存位置），python可以执行同时赋值，语句 a，b = b，a 两个赋值语句同时完成。 下图展现了冒泡排序的第一次遍历： 用py...
排序（冒泡，选择和插入）
crraxx的博客
11-19 672
冒泡排序 基本原理 冒泡排序：相邻的两个元素进行比较。 从小到大排：如果a[j]>a[j+1],交换a[j]和a[j+1]顺序;从大到小排：如a[j]<a[j+1],交换a[j]和a[j+1]顺序。 比较次数：外循环比较次数为a.length-1次，内循环比较次数a.length-i-1次。 实例: （这里以升序为例） public static void main(String[] args) { int [] a= {8,9,3,2,1}; for (int
选择排序、冒泡排序、插入排序（Java代码）
软软的铲屎官的博客
12-01 197
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 选择排序、冒泡排序、插入排序（Java代码）工具类：1、选择排序冒泡排序插入排序 工具类： import java.util.Arrays; /** * * @title: ArrayUtils * @Date: 2020.11.26 15:10 */ public class ArrayUtils { /** * @Description 随机生成数组 * @Date 2020.11.26 15:
冒泡排序，插入排序，选择排序代码实现
Ybranium的博客
08-22 239
冒泡排序` public class BubbleSort { public static void main(String[] args) { /* * 冒泡排序： */ int [] arr={3,4,9,6,7}; int n; for(int i=0;i<arr.length-1;i++){ for(int j=0;j<arr.length-1-...
四种简单的排序算法（插入、冒泡、选择排序、快速排序法）+汉诺塔算法
L511157586的博客
03-18 334
简单理解： 假设数组array长度为8，序号从0开始。 1、插入排序： （1）排序要进行7次。 for（int i=1;i<array.Length;i++）{ for(int j=i;j>0;j--) if(array[j-1]>array[j]) Swap(ref array[j-1],ref array[j])交换位置保证array前i...
冒泡排序&选择排序&插入排序
12-21
冒泡排序、选择排序和插入排序是三种基本的排序算法，它们都是针对数组或列表进行操作，目的是将无序的数据序列调整为升序或降序的有序序列。 **冒泡排序**： 冒泡排序的核心思想是通过重复遍历待排序的数列，比较...
算法设计与分析-1排序算法性能分析-冒泡/选择/插入/合并/快速排序-pre ppt
06-18
例如，对于1亿规模的数据，合并排序和快速排序将是更合适的选择，而选择排序、冒泡排序和插入排序则更适合小规模或部分有序的数据。在选择算法时，不仅要考虑时间复杂度，还需要考虑空间复杂度、稳定性、代码实现的...
排序算法介绍——冒泡排序+插入排序+选择排序
12-21
本文将重点介绍三种基础的排序算法：冒泡排序、插入排序和选择排序。 首先，我们来看冒泡排序。冒泡排序是一种简单的排序算法，其基本思想是通过重复遍历数组，比较相邻的两个元素并根据需要交换它们的位置，使得每...
冒泡排序和插入排序
FeiChangWuRao的博客
02-05 254
看书《数据结构与算法分析》看到插入排序时，发现怎么跟冒泡排序这么像，看得我一脸懵逼。看时间复杂度都是O（n2），但是插入排序要比冒泡排序有效率的多，看书上的定义十分痛苦，也区分不了之间有什么区别。 其实两者之间的区别还是很大，冒泡排序的目的是每次排序都能把对应的一个元素送对应的位置，就像冒泡一样，第一次排序把最大的那个送到第一位，第二个把第二大的元素送到第二位置，以此类推。 插入排序时，第一次
java插入排序和冒泡排序
mingxin95的博客
09-22 491
最近正在找工作，由于是找实习，被问到了很多的基础题，尤其是排序这一块，现在把自己熟悉的两中排序写出来，以供以后复习， 冒泡排序 冒泡排序算法运行起来非常慢，但在概念上来说它又是最简单的，因此冒泡排序算法在刚开始研究排序技术时是一个非常好的算法。以下是冒泡排序要遵循的规则： 比较两个数据； 如果前面的数据比后面的数据大，则数据之间进行交换操作； 向后移动一个位置，比较下面两个数据； 但碰到第一个排好顺
冒泡排序、选择排序和插入
weixin_33889665的博客
07-19 73
冒泡排序、选择排序和插入排序代码如下： package cn.luxh.app.test; public class SimpleSortUtil { /** * 冒泡排序 * 从小到大排序 * 思路： * 1）第一趟排序进行了len-1次比较，数组中的最大值元素排到了最末端，位置已固定，该元素不再参与下趟比较 ...
冒泡算法和简易桶排序算法实现
千年祸害万年牢
12-02 430
读书后的笔记和自己的实现，备忘 直接上代码 package com.joker.suanfa; /**  *  * @author Administrator  *         本质，将N个数排序，需要n-1趟，每一趟每两个元素进行比较，每一次比较，将小的数进行往后排，则最后一位为最小的数，下一趟则不需要再比较 如  *         0,5,8，需走两趟，第一趟0 5 比较
基础排序(冒泡排序，选择排序和插入排序)
echohuangshihuxue的博客
01-11 192
一些常见的排序方法，记录在此。(好记性不如烂笔头) 一:冒泡排序法:    1.思路:第一次两两遍历所有的元素，找到最大的元素放置到最右边，第二次遍历(n-1)个。这样下来整个就是从小到大排列了。 public void bubbleSort(int[]source){ for(int i=source.length-1;i&gt;0;i--){ for(int j=0;j&l...
直接插入排序的比较次数、移动次数和赋值次数 最小/最大/平均值
weixin_30325971的博客
06-23 7032
直接插入排序的比较次数、移动次数和赋值次数 最小/最大/平均值 基于该程序： 比较次数：指的是while循环的移动次数 移动次数：指的是数据在向量(一维数组)中的移动次数，包括R[0]<-R[i]，R[j+1]<-R[0]和while循环中的R[j+1]<-R[j] 赋值次数：包括所有的赋值语句 关于比较次数与赋值次数的关系： 对于whil...
【数据结构与算法】简单排序（冒泡排序、选择排序、插入排序）完整思路，并用代码封装排序函数
热门推荐
零一的博客
09-24 2万+
之前的文章，我已经把前端需要了解的数据结构都给说了一边，并且我们也都对其进行了封装。现在我们要开始对排序算法部分进行讲解，排序算法顾名思义，就是对一堆杂乱无章的数据按照一定的规则将它们有序地排列在一起。 在讲解排序算法时，大致分成两大类，如下图 本文
python中对列表元素大小排序（冒泡排序法，选择排序法和插入排序法）—排序算法
zeruns
02-04 8636
前言 排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。本文主要讲述python中经常用的三种排序算法，选择排序法，冒泡排序法和插入排序法及其区别。通过对列表里的元素大小排序进行阐述。 原文地址：https://blog.zeruns.tech/index.php/archives/297/ 一、选择排序法 选择...
排序子系请选择1--冒泡排序 2--简单选择 3--堆排序 4--直接插入 5--希尔排序 6--快速排序 0--输入数据c语言
最新发布
06-03
1. 冒泡排序：通过比较相邻元素的大小，将较大的元素向后移动，从而实现排序。 2. 简单选择排序：每次在未排序的元素中选择一个最小的元素，放到已排序的元素序列的末尾。 3. 堆排序：将元素构建成一个堆（大根堆或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值