算法之旅——冒泡排序及选择排序

冒泡排序和选择排序是排序算法中比较简单的两种算法。

冒泡排序的思想是:比较相邻的元素。如果第一个比第二个大,就交换他们两个。对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,针对所有的元素重复以上的步骤,这样每次参与比较的元素就越来越少,直到没有任何一对数字需要比较。对N个数字进行冒泡排序,需要进行N-1趟比较,第i趟中需要进行N-i次比较。由于冒泡排序中每趟都重复比较了很多元素,导致此算法的时间效率不是很高,其平均时间复杂度为O(n*n).

这里给出一份冒泡排序的参考代码:

//description:冒泡排序
//author:hust_luojun
//data:2014_7_22

#include <iostream>
using namespace std;

int main()
{
    void bubble_sort(int arrary[],int length);
    int arrary[]={13,3,76,56,86,43,76,6,34,75};
    cout<<"the origin arrary is:"<<endl;
    int i;
    for(i=0;i<10;i++)
        cout<<arrary[i]<<"  ";

    bubble_sort(arrary,10);
    i=0;
    cout<<endl;
    cout<<"the sorted arrary is:"<<endl;
    for(int i=0;i<10;i++)
        cout<<arrary[i]<<"  ";
    return 0;
}

void bubble_sort(int arrary[],int length)
{
   int i;
   int j;
   int k;
   for(i=0;i<length-1;i++)
       for(j=0;j<length-1-i;j++)
       {
           if(arrary[j]>arrary[j+1])
              {
                  k=arrary[j];
                  arrary[j]=arrary[j+1];
                  arrary[j+1]=k;
              }
       }
}

选择排序是从第一个数开始,将这个数与它后面的每个数比较,若该数比后面的数都小,则不交换,它留在原位置:若该数比后面的数大,则找出它后面数中最小的那个数,使之与其交换,这样最小的数就跑到前面来了,以此类推,N个数需进行N-1趟比较。选择排序的时间复杂度也为O(n*n),效率也不高,在实际应用中,较少选择冒泡排序和选择排序,因为还有时间复杂度更好的排序算法,我们只需要了解这两种算法的思想即可。这里给出衣服呢选择排序的代码,共大家参考

//description:选择法排序
//author:hust_luojun
//data:2014_7_22

#include <iostream>
using namespace std;

int main()
{
    void selection_sort(int arrary[],int length);
    int arrary[]={13,3,76,56,86,43,76,6,34,75};
    cout<<"the origin arrary is:"<<endl;
    int i;
    for(i=0;i<10;i++)
        cout<<arrary[i]<<"  ";

    selection_sort(arrary,10);
    i=0;
    cout<<endl;
    cout<<"the sorted arrary is:"<<endl;
    for(int i=0;i<10;i++)
        cout<<arrary[i]<<"  ";
    return 0;
}

void selection_sort(int arrary[],int length)
{
    int i;
    int j;
    int k;
    int t;
    for(i=0;i<length-1;i++)
    {
        k=arrary[i];
        for(j=i+1;j<length;j++)
            if(arrary[j]<k)
                {
                  t=arrary[j];
                  arrary[j]=k;
                  k=t;
                }
        arrary[i]=k;
    }
}
时间: 2024-08-02 00:47:58

算法之旅——冒泡排序及选择排序的相关文章

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

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

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

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

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

插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和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<

冒泡排序和选择排序

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

冒泡排序,选择排序,插入排序

从今天开始希望自己的博客可以持续的更新起来,由于本人能力有限,所以有些内容可能会有疏漏或者不全面,希望大家可以指出来,让我们一起学习,一起进步. 今天的内容是最简单的三个排序算法,冒泡排序,选择排序,插入排序,它们的时间复杂度都是O(N^2). 冒泡排序:首先第一个数与第二个数比较,如果前面的大于后面的就交换两个数,然后第二个与第三个比较,直到比较到最后,此时最后一个数为数组最大值,然后循环次步骤,第二次比较到倒数第二位,这样经过两次循环最后两位就排好了,经过N次循环,数组就拍好了 选择排序:从

Java排序算法分析与实现:快排、冒泡排序、选择排序、插入排序、归并排序(二)

一.概述: 上篇博客介绍了常见简单算法:冒泡排序.选择排序和插入排序.本文介绍高级排序算法:快速排序和归并排序.在开始介绍算法之前,首先介绍高级算法所需要的基础知识:划分.递归,并顺带介绍二分查找算法. 二.划分: 划分是快速排序的前提,即把数据分为两组,大于特定值的数据在一组,小于特定值的数据在另一组.快速排序即是由划分和递归操作来完成的. (1)原理: 定义一个阈值,分别从最左面和最右面向中间遍历元素,左面找到一个大于阈值的数据便停止,右边找到一个小于阈值的数据便停止,如果此时左右两边都还没

冒泡排序和选择排序--Java

冒泡排序(Bubble sort)和选择排序(Selection sort) 初看冒泡排序和选择排序不禁会问它们有什么区别? 的确, 它们的基本思想是一样的. 都是通过一轮的循环找到所要排序数中的最值(最大值或最小值), 然后将最值置于顶端. 它们的区别主要体现在对其他数(非最值)的处理上. 冒泡排序: 通过相邻的两个数的比较, 根据需要决定是否将两个数互换位置, 然后将比较往前(或往后)推进. 例如, 要求从小到大排序. 通过将两个数比较, 将较大的数置换到右边. 如此不断循环将得到最值. 选

JS中的冒泡排序与选择排序

1.冒泡排序 作为最简单的排序算法之一,冒泡排序的思想是,从左到右依次比较两个存储数据的大小,如果第一个数大于第二个数,就交换两个数据,这样一轮比较之后,最大的数会放在后面,这样,每次循环比较,本轮中的最大值都会排到最后,直到循环结束,实现数组升序. 动图演示如下: 代码如下: 首先定义外层循环,如果有n个数据进行循环比较,最后一次循环排序,最后两个值的大小已经确定,所以最后一个数值不需要参与循环,即n-1次,这里就是(arr.length-1) -1次: 定义内层循环,当前位i和i+1进行比较