交换排序 —— 冒泡排序 + 改进

冒泡排序

冒泡排序是通过无序区相邻两个元素之间进行比较和位置交换,达到排序的目的。

插入排序是设定序列的 1 到 n-1 元素为无序区,初始有序区就只有 0 这个元素,然后将无序区中的元素和有序区中的元素逐个进行比较插入。从而是不断扩大有序区的范围。减少无序区的范围直至排序完成。

而冒泡排序则视整个序列均为无序区。即从 0 到 n-1 这些元素都位于无序区。直接对其中的元素进行比较,根据相邻元素大小比较的结果和想要的最终排序结果,对相邻元素的位置进行调整。

如:想要从小到大的排序结果,那么就对相邻元素进行比较, a b c

if a>b:

  交换 a b的位置,然后比较a c 大小

else:

  保持a b 位置不变,比较b c 的大小。

代码如下:

def bubbleSort( A, n):
    for i in range(n-1,0,-1):  # 整个序列均为无序区,初始参与排序的是 n 个元素
        for j in range(i):  # 遍历本趟内的相邻元素,移动到最右边。
            if A[j]>A[j+1]:
                A[j],A[j+1]=A[j+1],A[j]
    return A

B  = [41,14,22,45,43,76,29,27,38]
print(bubbleSort(B,len(B)))

冒泡排序-改进

如图,随着排序的进行,会发现,在最后三次的时候就已经排好序了,最后三次的排序有点多余。所以可以设置一个表示,如果某一趟没有进行交换,说明所有排序都已经完成了就退出循环,停止排序。

代码如下:

def bubbleSort( A, n):
    for i in range(n-1,0,-1):
        exchange = False  # 设置一个标志
        print(A)
        for j in range(i):  # 遍历本趟内的相邻元素,移动到最右边。
            if A[j]>A[j+1]:
                A[j],A[j+1]=A[j+1],A[j]
                exchange = True  #只要有本趟内元素位置有更改,那么就改变标记的状态。
        if exchange == False:  #如果exhange ==False 可以推断出,上层的for循环没有改变元素位置,那么意味着排序已经完成了。可以停止循环了。
            return A
B  = [4,1,5,2,6,3]
print(bubbleSort(B,len(B)))
时间: 2024-10-26 06:20:02

交换排序 —— 冒泡排序 + 改进的相关文章

算法基础之排序(1)--冒泡排序 改进

1 /********************************************************************************************************** 2 * Function : test 3 * Create Date : 2014/03/23 4 * Author : NTSK13 5 * Email : [email protected] 6 * Copyright : 欢迎大家和我一起交流学习,转载请保持源文件的完整性

八大排序算法之五--交换排序—冒泡排序(Bubble Sort)

基本思想: 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 算法实现:(HDU 1040 亲测 AC) #include<iostream> using namespace std; const int N =1005; void BubbleSort(int a[],int ); void print(int a[],int num); vo

交换排序—冒泡排序(Bubble Sort)

基本思想: 最简单的排序,也是最耗时间的排序 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 冒泡排序的示例: 算法的实现: void bubbleSort(int a[], int n){ for(int i =0 ; i< n-1; ++i) { for(int j = 0; j < n-i-1; ++j) { if(a[j] > a

交换排序—冒泡排序(Bubble Sort)算法原理以及Java实现

基本思想: 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 冒泡排序的示例: 算法实现 1 /** 2 * 3 * @author zhangtao 4 */ 5 public class BubbleSort 6 { 7 public static void main(String[] args) 8 { 9 int arr[]={3,1,5,

冒泡排序改进算法

先上一段传统的选择排序的代码: public class SortTest2 { public static void main(String[] args) { int[] a = new int[args.length]; for(int i=0; i<args.length; i++) { a[i] = Integer.parseInt(args[i]); } print(a); selectSort(a); print(a); } private static void selectio

交换排序---冒泡排序

1 //冒泡排序 2 /** 3 * 5,8,3,15,14,68,17 4 * 5 * @param arr 6 */ 7 public static void bubbleSort(int[] arr){ 8 //控制比较多少轮 9 for(int i=0;i<arr.length-1;i++){ 10 for(int j=0;j<arr.length-1-i;j++){ 11 if(arr[j]>arr[j+1]){ 12 int temp=arr[j]; 13 arr[j]=ar

交换排序---冒泡排序算法(Javascript版)

比较相邻的元素.如果第一个比第二个大,就交换他们两个.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数.针对所有的元素重复以上的步骤,除了最后一个.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. function sort(elements){ for(var i=0;i<elements.length-1;i++){ for(var j=0;j<elements.length-i-1;j++){ if(elements[

排序算法(一)——冒泡排序及改进

冒泡排序 冒泡排序的效率很低,但是算法实现起来很简单,因此很适合作为研究排序的入门算法. 基本思想 对当前还未排好序的范围内的全部数,自上而下对相邻的俩个数依次进行比较和调整,让较大的数下沉,较小的数往上冒.即:每当俩相邻的数比较后发现他们的排序与排序的要求相反时,就将他们交换.每次遍历都可确定一个最大值放到待排数组的末尾,下次遍历,对该最大值以及它之后的元素不再排序(已经排好). java实现 public class Sort{ private int [] array; public So

冒泡排序及改进

排序算法概述 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法.排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面. 稳定性:一个排序算法是稳定的,就是当有两个相等记录的关键字R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前. 如果算法是稳定的有什么好处呢?排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用.基数排序就是这