关于冒泡排序的改进

1、原始冒泡排序

/*冒泡排序后的顺序为从小到大*/

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

2、改进的冒泡排序

/*冒泡排序后的顺序为从小到大*/

void Bubble_Sort(int *arr,int len)
{
    int i,j,exchange;
    bool flag = true; //增设标志位,判断是否已经完成排序
    for(i=0; i<len-1 && flag; i++)
       {
            flag = false;
            for(j=0;j<len-i-1;j++)
               if(arr[j] > arr[j+1])
                 { //如果本趟比较没有数据发生交换,说明排序已经完成
                   //则flag一直为false,从而退出循环,不再进行下一趟的比较
                      exchange = arr[j];
                      arr[j] = arr[j+1];
                      arr[j+1] = exchange;
                      flag = true;
                 }
      }
}

3、测试

#include<stdio.h>
#include<stdlib.h>

/*将上面的函数放在这里*/

int main()
   {
        int num;
        printf("请输入排序的元素的个数:");
        scanf("%d",&num);

int i;
        int *arr = (int *)malloc(num*sizeof(int));
        printf("请依次输入这%d个元素(必须为整数):",num);
        for(i=0;i<num;i++)
           scanf("%d",arr+i);

printf("冒泡排序后的顺序:");
        Bubble_Sort(arr,num);
        for(i=0;i<num;i++)
           printf("%d ",arr[i]);
        printf("\n");

free(arr);
        arr = 0;
        return 0;
}

原文地址:https://www.cnblogs.com/wwhai/p/10269284.html

时间: 2024-10-11 16:59:46

关于冒泡排序的改进的相关文章

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

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

冒泡排序及改进

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

数据结构之排序算法(二)-冒泡排序及改进

冒泡排序算法需要遍历几次数组.每次遍历都要比较连续相邻的元素,如果某一对相邻元素是降序,则互换它们的值,否则,保持不变.由于较小的值像"气泡"一样逐渐浮想顶部,而较大的值沉向底部,所以叫冒泡排序. 冒泡排序的图解是: 总结一句话就是:连续比较相邻的元素,降序则呼唤.有n个数,共需要比较n-1趟,第i趟,需要比较n-i次. BubbleSort.java public class BubbleSort {//时间复杂度O(n^2) public static void display(i

冒泡排序的改进:鸡尾酒排序

鸡尾酒排序,也叫定向冒泡排序,是冒泡排序的一种改进.此算法与冒泡排序的不同处在于从低到高然后从高到低,而冒泡排序则仅从低到高去比较列里的每个元素. 它可以得到比冒泡排序稍微好一点的排序. void CocktailSort(int *a , int n){ int left = 0; int right = n - 1; while(left < right) { for(int i = left; i < right; i++) { if(a[i] > a[i+1]) swap(a,i

冒泡排序以及改进

关于排序术语: 内排序:排序数据放置在内存中,排序操作在内存中进行 外排序:排序数据放置在磁盘中,通过磁盘和内存进行的数据传输进行排序操作 时间复杂度:算法执行所消耗的时间 空间复杂度:运行完一个程序所需内存的大小 冒泡排序 1 function bubbleSort(arr) { 2 // 记录传入数组的长度 3 let len = arr.length 4 let temp = 0 5 // 外循环: 6 for (let i = 0; i < len; i++) { 7 // 内循环: 8

数据结构与算法——冒泡排序(改进后)

//改进的冒泡程序#include<stdio.h>void BubbleSort(int arr[], int length); int main( ){ int i; int arr[9] = {1,1,5,7,2,4,9,6,8}; int length=sizeof(arr)/sizeof(arr[0]); BubbleSort(arr,length); for(i=0;i<length;i++) { printf("%d ",arr[i]); } } voi

js冒泡排序算法改进

// 冒泡排序算法 function bubbleSort(arr) { console.log('排序算法第0次:' + arr.join(',')); var len = arr.length; var lastIndex = 0; // 最后标记的脚标 var sortBorder = len - 1; // 需交换最大的次数 for (var i = 0; i < len - 1; i++) { let isSort = true; for (var j = 0; j < sortBo

冒泡排序的改进-鸡尾酒排序

#include <iostream> using namespace std; void Cocktail(int *arr, int size){ int tail = size - 1; for(int i = 0; i < tail;){ for(int j = tail; j > i; j--){ if(arr[j] < arr[j-1]){ int temp = arr[j]; arr[j] = arr[j-1]; arr[j-1] = temp; } } ++i

[整理]改进的冒泡排序

冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名. /// <summary> /// 改进的冒泡排序 /// </summary> /// <param name="array">待排序的数组&l