排序（冒泡排序）

最新推荐文章于 2024-09-11 18:01:31 发布
最新推荐文章于 2024-09-11 18:01:31 发布
阅读量118 收藏
点赞数
文章标签： python 数据结构与算法 php
原文链接：https://my.oschina.net/u/868129/blog/90356
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

基本概念

　　冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

　　用 二重循环实现，外循环变量设为i，内循环变量设为j。假如有10个数需要进行排序，则外循环重复9次，内循环依次重复9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i,j的值依次为1,2,...10-i。

性能分析

　　 若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n(n-1）/2次比较和记录移动。因此 冒泡 排序总的 时间复杂度 为O(n*n)。

改进

　     冒泡排 序法存在的不足及改进方法：
　　第一，在排序过程中，执行完最后的排序后，虽然数据已全部排序完备，但程序无法判断是否完成排序，为了解决这一不足，可设置一个标志位flag，将其初始值设置为非0，表示被排序的表是一个无序的表，每一次排序开始前设置flag值为0，在进行数据交换时，修改flag为非0。在新一轮排序开始时，检查此标志，若此标志为0，表示上一次没有做过交换数据，则结束排序；否则进行排序；
　　第二，当排序的数据比较多时排序的时间会明显延长。改进方法： 快速排序 ：具体做法：任意选取某一记录（通常取第一个记录），比较其关键字与所有记录的关键字，并将关键字比它小的记录全部放在它的前面，将比它大的记录均存放在它的后面，这样，经过一次排序之后，可将所有记录以该记录所在的分界点分为两部分，然后分别对这两部分进行快速排序，直至排序完
　　局部冒泡排序算法对冒泡排序的改进：
　　在冒泡排序中，一趟扫描有可能无数据交换，也有可能有一次或多次数据交换，在传统的冒泡排序算法及近年来的一些改进的算法中，只记录一趟扫描有无数据交换的信息，对数据交换发生的位置信息则不予处理。为了充分利用这一信息，可以在一趟全局扫描中，对每一反序数据对进行局部冒泡排序处理，称之为局部冒泡排序。局部冒泡排序与冒泡排序算法具有相同的 时间复杂度 ，并且在正序和逆序的情况下，所需的关键字的比较次数和移动次数完全相同。由于局部冒泡排序和冒泡排序的数据移动次数总是相同的，而局部冒泡排序所需关键字的比较次数常少于冒泡排序，这意味着局部冒泡排序很可能在平均比较次数上对冒泡排序有所改进，当比较次数较少的优点不足以抵消其程序复杂度所带来的额外开销，而当数据量较大时，局部冒泡排序的时间性能则明显优于冒泡排序。
  

算法示例  　　

C语言

　　void bubble_sort(int *a, int n)
　　{
　　int *p1 = a;
　　int *p2 = a;
　　int k;
　　int j;
　　for (int i = 0; i < n; i++)
　　{
　　p2 = p1;
　　p2++;
　　for (j = n - i - 1; j > 0; j--)
　　{
　　if (*p2 < *p1) // 升序
　　{
　　k = *p1;
　　*p1 = *p2;
　　*p2 = k;
　　}
　　p2++;
　　}
　　p1++;
　　}
　　}
　　程序1：
　　void bubble_sort(int array[],int n)
　　{
　　int i,j,flag,temp;
　　for(i = 0; i < n-1; i++)
　　{
　　flag = 1;
　　for(j = 0; j < n-i-1; j++)
　　{
　　if(array[j] > array[j+1])
　　{
　　temp= array[j];
　　array[j] = array[j+1];
　　array[j+1] = temp;
　　flag = 0;
　　}
　　}
　　if（1 == flag)
　　{
　　printf("%d ",i); //首先打印出，在第几层循环时顺序已排好
　　break; //跳出循环
　　}
　　}
　　return;
　　}
　　程序2：（可进行2个数以上大小比较，程序参考作者： 赵杰）
　　#include<stdio.h>
　　main()
　　{
　　long a,x,k,i[100],s;
　　char ch;
　　for(a=0;;a++)
　　{
　　printf("输入一个数，输完一个数按回车，最后一个数末尾要加n:");
　　scanf("%ld%c",&i[a],&ch);
　　if(a==99）
　　{
　　printf("注意！输入的数超过100个");
　　break;
　　}
　　else if(ch=='n')
　　break;
　　}
　　do{
　　x=0;
　　for(k=0;k<a;k++)
　　{
　　if(i[k]>i[k+1])
　　{
　　s=i[k+1];i[k+1]=i[k];
　　i[k]=s;x++;
　　}
　　}
　　}while(x!=0);
　　printf("从小到大排列为：");
　　for(k=0;k<a;k++)
　　printf("%ld<",i[k]);
　　printf("%ld",i[a]);
　　return 0;
　　}

C++

　　#include <iostream>
　　#define LEN 9
　　using namespace std;
　　int main()
　　{
　　int nArray[LEN];
　　for(int i=0;i<LEN;i++)
　　{
　　nArray[i]=LEN-i; //赋初值
　　}
　　cout<<"原始数据为："<<endl;
　　for(int j=0;j<LEN;j++)
　　{
　　cout<<nArray[j]<<" ";
　　}
　　cout<<endl;
　　for(int m=LEN-1;m>0;m--)
　　{
　　int temp;
　　for(int n=0;n<m;n++)
　　{
　　if(nArray[n]>nArray[n+1])
　　{
　　temp=nArray[n];
　　nArray[n]=nArray[n+1];
　　nArray[n+1]=temp;
　　}
　　}
　　}
　　cout<<"排序结果："<<endl;
　　for(i=0;i<LEN;i++)
　　{
　　cout<<nArray[i]<<" ";
　　}
　　return 0;
　　}

PHP

　　代码1：
　　<?php
　　// 冒泡排序（一维 数组）
　　function bubble_sort($array)
　　{
　　$count = count($array);
　　if ($count <= 0) return false;
　　for($i=0; $i<$count; $i++)
　　{
　　for($j=$count-1; $j>$i; $j--)
　　{
　　if ($array[$j] < $array[$j-1])
　　{
　　$tmp = $array[$j];
　　$array[$j] = $array[$j-1];
　　$array[$j-1] = $tmp;
　　}
　　}
　　}
　　return $array;
　　}
　　//使用实例
　　$_array = array('5','8','5','6','9','3','2','4');
　　$_array = bubble_sort($_array);
　　print ($_array);
　　>
　　代码2：
　　<?php
　　//冒泡排序
　　function maopaosort($arr)
　　{
　　for ($i=0;$i<count($arr)-1;$i++ ) {
　　for ($j=0;$j<count($arr)-1-$i;$j++ ) {
　　if($arr[$j]>$arr[$j+1])
　　{
　　//交换赋值，不使用中间 变量
　　$arr[$j]=$arr[$j+1]+$arr[$j];
　　$arr[$j+1]=$arr[$j]-$arr[$j+1];
　　$arr[$j]=$arr[$j]-$arr[$j+1];
　　}
　　}
　　}
　　return $arr;
　　} // end func
　　//实例
　　$arr=array（7,3,6,1,5,2,11,4,44,33,22,88,44）;
　　print_r(maopaosort($arr));
　　//结果输出Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 [7] => 11 [8] => 22 [9] => 33 [10] => 44 [11] => 44 [12] => 88 )
　　>

Ruby

　　def bubble(arr)
　　(arr.length-1）.downto（1） do |j|
　　a1 = arr.dup
　　j.times do |i|
　　if arr > arr[i+1]
　　arr,arr[i+1] = arr[i+1],arr
　　end
　　end
　　break if a1 == arr
　　end
　　arr
　　end

Java

　　public class Bubblesort {
　　static void bubblesort(int[] a) {
　　int temp;
　　for (int i = 0; i < a.length-1; i++) {//-1是因为最后一个没必要再跟它本身比较
　　for (int j = a.length - 1; j > i ; j--) {
　　if (a[i] < a[j]) {
　　temp = a[j];
　　a[j] = a[i];
　　a[i] = temp;
　　}
　　}
　　}
　　}
　　}

Visual Basic

　　Private Sub Form_Load()
　　Dim a,c As Variant
　　Dim i As Integer,j As Integer,temp As Integer,bSwap As Boolean
　　a = Array（17,45,12,80,50）
　　For j = 0 To UBound(a) - 1
　　bSwap = False
　　For i = 0 To UBound(a) - 1
　　If (a(i) > a(i + 1）) Then '若是递减，改为a(i)<a(i+1）
　　temp = a(i)
　　a(i) = a(i + 1）
　　a(i + 1） = temp
　　bSwap = True
　　End If
　　Next
　　If bSwap = False Then
　　Exit For
　　End If
　　Next
　　For Each c In a
　　Debug.Print c;
　　Next
　　End Sub

Pascal

　　program bubble_sort;
　　var
　　a:array[1..N] of 1..MAX;
　　temp,i,j:integer;
　　begin
　　randomize;
　　for i:=1 to N do a:=1+random(MAX);
　　writeln('Array before sorted:');
　　for i:=1 to N do write(a,' ');
　　writeln;
　　for i:=N-1 downto 1 do
　　for j:=1 to i do
　　if a[j]<a[j+1] then
　　begin
　　temp:=a[j];
　　a[j]:=a[j+1];
　　a[j+1]:=temp;
　　end;
　　writeln('Array sorted:');
　　for i:=1 to N do write(a,' ');
　　writeln;
　　writeln('End sorted.');
　　readln;
　　end.

C#

　　static void Main(string[] args)
　　{
　　int[] array = { 23,45,16,7,42 };
　　int length = array.Length - 1;
　　bool isExchanged = false;
　　for (int i = 0; i < length; i++)
　　{
　　isExchanged = false;
　　for (int j = length; j > i; j--)
　　{
　　if (array[j] > array[j - 1])
　　{
　　int temp = array[j];
　　array[j] = array[j - 1];
　　array[j - 1] = temp;
　　isExchanged = true;
　　}
　　}
　　if (!isExchanged)//一遍比较过后如果没有进行交换则退出循环
　　break;
　　}
　　foreach (int i in array)
　　{
　　Console.WriteLine(i);
　　}
　　Console.Read();
　　}

Python

　　#BubbleSort used python3.1 or python 2.x
　　def bubble(str):
　　tmplist = list(str)
　　count = len(tmplist)
　　for i in range(0,count-1）[::-1]:
　　for j in range(0,i）:
　　if tmplist[j] > tmplist[j+1]:
　　tmplist[j],tmplist[j+1] = tmplist[j+1],tmplist[j]
　　return tmplist
　　#useage:
　　str = "zbac"
　　print(bubble(str)) # ['a','b','c','z']
　　number=[16,134,15,1]
　　print(bubble(number)) # [1,15,16,134]

JS

　　function(array){
　　var length = array.length, temp;
　　for(var i = 0; i < length - 2; i++){
　　for (var j = length -1; j >=1;j--) {
　　if (array[j] < array[j - 1]){
　　temp = array[j];
　　array[j] = array[j - 1];
　　array[j - 1] = temp;
　　}
　　}
　　}
　　return array;
　　}

Action Script

　　var arr:Array=new Array（88,0,4,22,89,0,8,15）;
　　var temp:int=0;
　　for(var i:int=0;i<arr.length;i++){
　　for(var j:int=0;j<arr.length-i;j++){
　　if(arr[j]>arr[j+1]){
　　temp=arr[j];
　　arr[j]=arr[j+1];
　　arr[j+1]=temp;
　　}
　　}
　　}
　　for(var t:int=0;t<arr.length;t++){
　　trace(arr[t]);
　　}

伪代码

　　BUBBLESORT(A)
　　for i <- 1 to length[A]
　　do for j <- length[A] downto i + 1
　　do if A[j]<A[j - 1]
　　then exchange A[j] <-> A[j-1]
　　 PL/SQL代码　
　　declare
　　type varr_type is varray（10） of integer;
　　varr varr_type:=varr_type（65,32,44,78,20,13,28,99,0,1）;
　　i integer;
　　j integer;
　　t integer;
　　begin
　　for i in reverse 1..10 loop --保证最大的那个值在最终的位置上
　　for j in 1..i-1 loop
　　if varr(j)>varr(j+1） then
　　t:=varr(j);
　　varr(j):=varr(j+1）;
　　varr(j+1）:=t;
　　end if;
　　end loop;
　　end loop;
　　for i in 1..10 loop
　　dbms_output.put_line(varr(i));
　　end loop;
　　end;

REAL Basic

　　Private Sub Form_Load()
　　Dim a,c As Variant
　　Dim i As Integer,j As Integer,temp As Integer
　　a = Array（17,45,12,80,50）
　　For j = 0 To UBound(a) - 1　
　　For i = 0 To UBound(a) - 1　
　　If (a(j) > a(i)) Then　
　　temp = a(j)　
　　a(j) = a(i）　
　　a(i) = temp　
　　End If　
　　Next　
　　Next　
　　For i=0 to UBound(a)
　　msgbox str(a(i））　
　　Next　
　　End Sub

变种算法

　 　一个叫做鸡尾酒排序（也称双向冒泡排序 ）的算法，和冒泡排序的“编程复杂度”一样，但对随机序列排序性能稍高于普通冒泡排序，但是因为是双向冒泡，每次循环都双向检查，极端环境下会出现额外的比较，导致算法性能的退化，比如“4、5、7、1、2、3”这个序列就会出现退化

转载于:https://my.oschina.net/u/868129/blog/90356

weixin_34144450
关注
c语言数组实现冒泡排序
Lesli636的博客
11-08 2900
数组实现冒泡排序什么是冒泡拍排序用数组实现总结 什么是冒泡拍排序 首先，需要了解一下什么是冒泡排序，定义：冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。 举个列子比如某序列{9，8，7，6，5，4，3，2，1} 从上面不难看出，冒泡排序需要每个元素依次跟后面的元素进行比
【数据结构之排序】—— 冒泡排序
生活很苦，但学习还得继续
01-22 1049
目录基本概念分类冒泡排序 基本概念 定义：整理文件中的记录，使得它按照给定的关键字递增（或递减）的次序排列 内部排序 整个待排序数据都在内存中处理，不设计数据的内、外存交换 存储方式 顺序结构 链式结构 辅助表形式 评价标准 执行算法需要的时间 算法所需要的附加空间 分类 冒泡排序 ...
冒泡排序
好读书，每有会意，便欣然忘食。
03-21 795
交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。     　　　　　　　　　应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。     冒泡排序：   首先我们自己来设计一下“冒泡排序”，这种排序很现实的例子就是：   我抓一把沙仍进水里，那么沙子会立马沉入水底， 沙子上的灰尘会因为惯性暂时沉入水底，但是又会
【前端面试题】冒泡排序&选择排序
恒星的博客
07-12 384
冒泡排序、选择排序，作为前端面试题出场率还是挺高的。趁着工作不是很忙，就写了写。还顺带了解到了插入排序，也顺带写了下。 // 冒泡排序 两两比较，大的放后面 // [1, 3, 2, 5, 1] // 1: 3 => [1, 3, 2, 5, 1] => 3: 2 => [1, 2, 3, 5, 1] => 3: 5 => [1, 2, 3, 5, 1] => 5: 1 => [1, 2, 3, 1, 5] // 1: 2 =&.
C语言——冒泡排序
热门推荐
记录学习点滴
03-13 43万+
冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 代码如下 #include<stdio.h> void BBsort(int arr[], int size) { int j,i,tem; for (i = 0; i ..
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
简述冒泡排序与快速排序
一恍过去
05-01 2万+
简述冒泡排序与快速排序
C语言冒泡排序
小S的博客
04-29 8万+
冒泡排序？不难，这篇就够了！ for(int i=0;i
冒泡排序与插入排序
2302_76593339的博客
03-25 2025
一、冒泡排序1. 定义：：冒泡排序是一种非常容易理解的排序算法，在排序中按照要求从小到大排序或者从大到小排序，不断比较数组中相邻两个元素的值，较小或者较大的元素前移2.动图演示过程3.代码演示过程二、插入排序1.定义：一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法2.动图演示过程3.代码实现过程三、两个排序的区别。
冒泡排序-冒泡排序冒泡排序-冒泡排序
最新发布
09-14
冒泡排序 冒泡排序 冒泡排序 冒泡排序 冒泡排序
冒泡排序冒泡排序冒泡排序
11-01
冒泡排序，是一种基础且直观的排序算法，其工作原理类似于水底下的气泡逐渐上浮。冒泡排序的核心在于通过反复遍历数列，依次比较相邻元素的大小，如果发现顺序错误则交换它们的位置。这个过程就像水中的气泡一样，较...
各种排序 冒泡排序.zip
01-30
冒泡排序是一种基础且经典的排序算法，它的基本思想是通过不断地交换相邻的逆序元素来逐步将序列调整为有序状态。这个过程就像水底下的气泡一样，小的元素逐渐“浮”到序列的顶端。在本压缩包“各种排序 冒泡排序....
蒙特卡罗方法——布丰投针实验近似计算圆周率python代码实现
2301_79376014的博客
09-09 497
蒙特卡罗——布丰实验
pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定
weixin_53707653的博客
09-09 841
是一个强大且易用的工具，可以帮助开发者轻松管理 Python 项目的依赖关系，确保代码的可重复性和稳定性。是一组命令行工具，旨在简化 Python 依赖关系的管理，确保项目环境的稳定性和可重复性。可以确保每次构建环境时都使用相同的依赖项版本，从而避免由于依赖项版本不一致导致的错误，提高代码可重复性和稳定性。自动化了依赖关系管理过程，节省了开发者的时间和精力，可以将更多时间投入到实际的开发工作中。文件中的信息，更新虚拟环境，安装、升级或卸载所需的软件包，确保虚拟环境与。命令可以从你的项目配置文件中生成。
Python实现多线程、多进程及协程
qq_42568323的博客
09-09 1089
本文详细介绍了 Python 中多线程、多进程和协程的并发模型及其实现方式，并通过具体场景演示了如何使用面向对象思想实现这些模型。在实际应用中，应根据任务的类型和需求选择合适的并发模型，从而优化程序的性能和资源利用率。本文将详细介绍 Python 中的多线程、多进程和协程的概念及其实现方式，并通过具体场景展示如何在 Python 中使用面向对象的思想实现这些并发模型。接下来，我们通过一个计算密集型任务的示例来演示多进程的实现：计算一系列大数字的阶乘。主程序中创建并启动了多个计算进程，并使用。
[Python]生成器和yield关键字
weixin_57336987的博客
09-07 455
概述:​ 它指的是 generator, 类似于以前学过的: 列表推导式, 集合推导式, 字典推导式…作用:​ 降低资源消耗, 快速(批量)生成数据.实现方式:​ 1.推导式写法.​ 2.yield写法.yield i # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.问题: 如何从生成器对象中获取数据?​ 答案:​ 1.for循环遍历​ 2.next()函数, 逐个获取.
Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警
weixin_50556117的博客
09-11 1043
【代码】Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警。
程序的格式框架与缩进
qq_57335683的博客
09-08 379
在上一课时中，我们介绍了 Python 的基本概念，并成功运行了第一个 Python 程序。本课时将深入探讨 Python 程序的基本结构、缩进的重要性，以及如何正确使用注释。通过本课时的学习，你将更好地理解 Python 代码的组织方式，并能够避免一些常见的编程错误。通过本课时的学习，你了解了 Python 程序的基本结构，认识到缩进在 Python 中的重要性，并学会了如何避免常见的缩进错误。缩进不仅是 Python 代码风格的一部分，而且是语法的一部分。这意味着如果缩进不正确，程序将无法正常运行。
java数组排序冒泡排序
03-16
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数组，比较相邻的两个元素，并按照大小顺序交换它们，直到整个数组排序完成。下面是Java中实现冒泡排序的代码示例： ```java public class BubbleSort { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值