冒泡排序-优化后的

时间复杂度

若文件的初始状态是正序的,一趟扫描即可完成排序。所需的关键字比较次数  和记录移动次数  均达到最小值:  ,  。所以,冒泡排序最好的时间复杂度为  。  

若初始文件是反序的,需要进行  趟排序。每趟排序要进行  次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下,比较和移动次数均达到最大值:

  

冒泡排序的最坏时间复杂度为 。

综上,因此冒泡排序总的平均时间复杂度为 。

算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

 1 /**
 2  * 冒泡排序 JAVA
 3  * 优化后的冒泡排序
 4  * 增加一个isSort本轮是否进行了排序的判断,如果没有进行排序则说明排序已经结束直接退出
 5  * @author Administrator
 6  * @time 20160731
 7  */
 8 public abstract class BubblingSort {
 9     ////////////////开始冒泡排序
10     public static int[] Sort(int[] array )
11     {
12         boolean isSort=false;//判断是否进行过排序,默认为没有进行排序,如果没有进行排序则直接结束
13         for (int i = 0; i < array.length-1; i++) {
14             isSort=false;//每轮排序前先将排序标识置位false
15             for (int j = 0; j < array.length-i-1; j++) {
16                 if(array[j]>array[j+1])
17                 {
18                     int temp =array[j+1];
19                     array[j+1]=array[j];
20                     array[j]=temp;
21                     isSort=true;//如果为true则本轮进行了交换,继续下一轮
22                 }
23             }
24             if(!isSort)break;//如果本轮没有进行过循环,结果为false直接跳出,不进行下一轮的检索
25         }
26         return array;    //return array
27     }
28     ///////////结束冒泡排序
29 }

自己在里面加了个判断是否已经排序结束,如果排序已经完成,则立即结束排序,不进行继续循环检测!

我在另一个类里面调用的方法:

 1 public class arithmetic_TestClass {
 2     public static void main(String[] args) {
 3         //测试数组 int 型
 4         int array[]={4,9,5,3,7,6,8,3,2,1};
 5
 6         //冒泡排序 优化过的冒泡排序
 7         array=BubblingSort.Sort(array);
 8
 9         for (int i : array) {
10             System.out.print(i+"  ");
11         }
12
13     }
14 }

执行的结果如下:

1  2  3  3  4  5  6  7  8  9

成功实现!

时间: 2024-10-12 21:06:31

冒泡排序-优化后的的相关文章

冒泡排序优化JAVA

本文对传统的冒泡排序进行了一些优化,减少了循环次数. 时间复杂度 若文件的初始状态是正序的,一趟扫描即可完成排序.所需的关键字比较次数 C 和记录移动次数 M 均达到最小值: C(min)=n-1 , M(min)=0 .所以,冒泡排序最好的时间复杂度为 O(n); 若初始文件是反序的,需要进行  趟排序.每趟排序要进行  次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置.在这种情况下,比较和移动次数均达到最大值: 冒泡排序的最坏时间复杂度为O(n^2) . 综上

面试 | 冒泡排序优化

一般冒泡排序: void bubble_sort(vector<int>& nums) { int i, j; int len = nums.size(); for (i = 0; i < len - 1; i++) for (j = 0; j < len - 1 - i; j++) if (arr[j] > arr[j + 1]) swap(arr[j], arr[j + 1]); } 优化后冒泡排序: 加入一个布尔变量,作用是标识该轮有没有进行数据的交换,若在某一

Javascript优化后的加减乘除(解决js浮点数计算bug)

说明 众所周知,js在计算浮点数时候,结果可能会不准确.比如:(在chrome中的运算结果) 2.2 + 2.1 = 4.300000000000001 2.2 - 1.9 = 0.30000000000000027 2.2 * 2.2 = 4.840000000000001 2.1 / 0.3 = 7.000000000000001 网上流传的代码(有bug) 网上流传的优化后的代码如下(有问题的代码,请勿使用) function add(a, b) { var c, d, e; try {

冒泡排序优化

直接上代码: #define swap(a,b) {a ^= b; b ^= a; a ^= b;} void sort(int *arr, int num){ for(int i = 0; i < num - 1; ++i){ bool isOk = true;   // 是否排序完成 for(int j = 0; j < num - 1 - i; ++j){ if(arr[j] > arr[j + 1]){ isOk = false; swap(arr[j], arr[j + 1])

使用matlab用优化后的梯度下降法求解达最小值时参数

matlab可以用 -Conjugate gradient -BFGS -L-BFGS 等优化后的梯度方法来求解优化问题.当feature过多时,最小二乘计算复杂度过高(O(n**3)),此时 这一些列优化版梯度下降算法就成为了解优化问题的更优选择. 它们的优点为: 不需要像对原始梯度下降那样手动选择学习速率α 一般比梯度下降收敛速度要快 相应的缺点为:比梯度下降要复杂得多 好在,我们可以直接用matlab内置函数进行计算. 例子如下: 我们需要输入cost function J 及其偏导数:

51系列小型操作系统精髓 简单实现11 C语言版优化后说明(有图)

/* CRTOS 实时可剥夺型内核 1.任务不用预加载,不用预定义.任务调用时加载,可删除(退出死循环即可) 2.单位轮转查询时间由晶振和定时器初始化决定.在这里为10ms 3.定时时间为[ time*单位轮转查询时间 ] ,其中time为 rtos_wait(time)中time. 4.可运行多个任务[自定义] 5.任务从rtos_wait()处切换,在定时时间到后从定时中断中切换回来,任务执行后,回到中断,再从中断回到主程序. */ #include "STC12C5A.H" #d

Tomcat 7优化前及优化后的性能对比

Tomcat 7在我们日常开发.测试.生产环境都会使用到,但对于大部分开发人员来说,对其性能还是没有多大了解.本文就对它做一次性能测试,对比优化前后的性能区别. 一.运行环境 CPU: Intel(R) Pentium(R) [email protected]  : 内存:4G,装的是32位win7,只认出3G,没有花时间去整ramdisk之类的东西: 操作系统:win7 32位: JDK:1.7.0_55 Tomcat:7.0.53 大家不要笑,公司电脑,就给配这样的,慢的要死,悲剧! 下面所

51系列小型操作系统精髓 简单实现10 C语言版优化后发布(有图)

4个任务 /* 使用keil4 可运行8个任务 任务从rtos_wait()处切换,在定时时间到后从定时中断中切换回来. */ #include "STC12C5A.H" #define TIMER_RELOAD() {TL0=0x00;TH0=0xC4;}//使能T/C 初始10ms #define MAX_TASKS 8 //任务槽最大个数. unsigned char idata task_stack[MAX_TASKS][2];//任务堆栈. PC指针为16位,需2个字节tas

冒泡排序优化以及插入排序(本文凝视较少适合有一定基础的观看)

#include<stdio.h> #define cnt 6 //定义排序个数 //冒泡排序优化 void Bubble_Sort(int A[],int N) { for(int P = N - 1; P >= 0;P--) { int flag = 0; //定义一个flag推断之后的序列是否有序 for(int i = 0;i < P;i++) //一趟冒泡 { if(A[i] > A[i+1]) //一次一次的冒泡 { int temp = A[i+1]; A[i+