多种冒泡算法时间和效率比较

<span style="font-family: Arial, Helvetica, sans-serif;">鄙人：</span>
<span style="font-family: Arial, Helvetica, sans-serif;">package testWebApp;</span>
/**
 *
 * @author luozhonghua
 *
 */
public class testmysort {
	static final int N=200;

	public static void main(String[]args){

		long begin=System.currentTimeMillis();
		int []array=new int[N];// {123,115,100,193,194,167,151,183,190,136 } ;

		System.out.println("排序前：");
		for(int i=0;i<N;i++){
			 array[i]=(int)(100+Math.random()*(100+1));
			 System.out.print(array[i]+" ");
		}

		 System.out.print("\n");

	     sort("", array);
	     System.out.println("排序后：");
		 for(int i:array){
			 System.out.print(i+" ");
		 }

		 long end=System.currentTimeMillis();
		 System.out.print("\n");
		 System.out.println("耗时："+(end-begin));
	}

	static void sort(String desc,int [] array){
		int temp=0;
		int count=0;
	  if(desc.equals("desc")){
		for(int i=0;i<array.length;i++){

			for(int j=i;j<array.length;j++){

				if(array[i]<array[j]){

					 temp = array[i];  //小
					 array[i] = array[j]; //大
					 array[j] = temp;//小
					 count++;
//					 array[i] = array[i] + array[j];
//					 array[j] = array[i] - array[j];
//					 array[i] = array[i] - array[j];
                 }
				}
			}

		 System.out.println("比较次数："+count);

	  }else{

		  for(int i=0;i<array.length;i++){
				for(int j=i;j<array.length;j++){
					if(array[i]>array[j]){
						temp=array[i];
						array[i]=array[j];
						array[j]=temp;
						count++;
					}
				}
	  }
		  System.out.println("比较次数："+count);
	  }
	}
}

排序前：

156 101 178 118 193 195 194 109 157 143 167 183 185 122 173 105 132 130 172 191 169 160 149 168 117 200 122 119 110 114 117 118 120 198 145 194 158 197 110 197 169 111 180 186 152 185 152 132 110 149 123 196 168 137 139 166 133 142 160 127 183 188 169 190 184
178 117 102 141 101 135 123 186 102 156 175 162 183 128 139 189 141 183 127 195 164 128 191 110 138 142 183 135 110 180 132 134 196 131 152 144 114 174 114 193 174 144 190 138 184 197 200 141 195 131 147 149 132 100 133 199 134 137 144 154 125 110 166 116
112 158 180 143 152 181 105 199 119 110 170 168 113 165 153 188 125 137 181 183 155 146 147 180 168 154 191 180 184 162 116 151 118 139 102 179 141 115 130 192 163 114 187 116 135 139 173 186 156 161 131 152 134 185 100 189 130 176 122 191 192 127 156 183
170 160 193 167 158 119 139

比较次数：5508

排序后：

100 100 101 101 102 102 102 105 105 109 110 110 110 110 110 110 110 111 112 113 114 114 114 114 115 116 116 116 117 117 117 118 118 118 119 119 119 120 122 122 122 123 123 125 125 127 127 127 128 128 130 130 130 131 131 131 132 132 132 132 133 133 134 134 134
135 135 135 137 137 137 138 138 139 139 139 139 139 141 141 141 141 142 142 143 143 144 144 144 145 146 147 147 149 149 149 151 152 152 152 152 152 153 154 154 155 156 156 156 156 157 158 158 158 160 160 160 161 162 162 163 164 165 166 166 167 167 168 168
168 168 169 169 169 170 170 172 173 173 174 174 175 176 178 178 179 180 180 180 180 180 181 181 183 183 183 183 183 183 183 184 184 184 185 185 185 186 186 186 187 188 188 189 189 190 190 191 191 191 191 192 192 193 193 193 194 194 195 195 195 196 196 197
197 197 198 199 199 200 200

耗时：16

某书：

import java.util.Random;

public class P4_1 {
	static final int SIZE=200;

	public static void bubbleSort(int[] a) {
		 int temp;
		 int count=0;
		 for (int i = 1; i < a.length; i++) {
              //将相邻两个数进行比较，较大的数往后冒泡
        	  for (int j = 0; j < a.length - i; j++) {
        		  if (a[j] > a[j + 1]) {
                   //交换相邻两个数
        			  temp=a[j];
        			  a[j]=a[j+1];
        			  a[j+1]=temp;
        			  count++;
        		  }
        	  }
//        	  System.out.print("第"+i+"步排序结果:");			//输出每步排序的结果
//        	  for(int k=0;k<a.length;k++)
//        	  {
//        		  System.out.print(" "+a[k]); // 输出
//        	  }
//        	  System.out.print("\n");
		 }
		 System.out.println("比较次数："+count);
	 } 

	public static void main(String[] args) {
		long begin=System.currentTimeMillis();

		int[] shuzu=new int[SIZE];//{123,115,100,193,194,167,151,183,190,136 }
		int i;
		System.out.print("排序前的数组为：\n");				//输出排序前的数组
		for(i=0;i<SIZE;i++){
			shuzu[i]=(int)(100+Math.random()*(100+1));			//初始化数组
			System.out.print(shuzu[i]+" ");
		}

		System.out.print("\n");
		bubbleSort(shuzu);					//排序操作
		System.out.print("排序后的数组为：\n");
		for(i=0;i<SIZE;i++){
			System.out.print(shuzu[i]+" ");					//输出排序后的数组
		}
		System.out.print("\n");
		long end=System.currentTimeMillis();
		 System.out.println("耗时："+(end-begin));
	}

}

排序前的数组为：

193 118 137 130 152 194 109 194 188 156 139 112 137 159 172 199 196 100 166 154 171 104 197 107 197 193 107 163 129 141 186 121 156 139 116 154 158 150 134 199 133 149 102 160 135 142 108 179 159 162 138 200 185 183 183 146 131 163 120 182 136 143 141 148 181
187 109 146 166 141 116 147 184 146 128 130 140 178 120 162 143 156 182 142 157 190 187 118 154 130 154 172 161 169 149 132 130 162 171 162 172 119 192 188 163 136 148 130 151 157 171 178 120 117 153 115 193 163 101 127 130 113 167 179 136 158 120 117 191
123 103 190 199 157 108 173 104 198 136 184 109 102 118 185 137 185 137 158 181 120 127 185 135 141 128 153 132 110 145 195 164 117 197 127 187 190 109 200 140 162 124 134 178 147 164 139 186 100 141 150 144 162 119 115 110 169 193 114 200 116 112 136 103
131 184 178 114 193 126 175

比较次数：10367

排序后的数组为：

100 100 101 102 102 103 103 104 104 107 107 108 108 109 109 109 109 110 110 112 112 113 114 114 115 115 116 116 116 117 117 117 118 118 118 119 119 120 120 120 120 120 121 123 124 126 127 127 127 128 128 129 130 130 130 130 130 130 131 131 132 132 133 134 134
135 135 136 136 136 136 136 137 137 137 137 138 139 139 139 140 140 141 141 141 141 141 142 142 143 143 144 145 146 146 146 147 147 148 148 149 149 150 150 151 152 153 153 154 154 154 154 156 156 156 157 157 157 158 158 158 159 159 160 161 162 162 162 162
162 162 163 163 163 163 164 164 166 166 167 169 169 171 171 171 172 172 172 173 175 178 178 178 178 179 179 181 181 182 182 183 183 184 184 184 185 185 185 185 186 186 187 187 187 188 188 190 190 190 191 192 193 193 193 193 193 194 194 195 196 197 197 197
198 199 199 199 200 200 200

耗时：32

时间： 2024-08-12 13:15:49

多种冒泡算法时间和效率比较的相关文章

多种排序算法的比较

1.冒泡排序和选择排序 为什么把冒泡排序和选择排序放在一块儿呢?因为我发现他们两个有点像. 冒泡排序是不停的把最大的元素换到数组的最右端. 而选择排序是把最小的元素换到最左端. 看到这儿,你是不是觉得冒泡和选择好像没啥区别啊,把最大换成最小就成了一种新的算法?那我也来一个? 其实,无论换最大还是最小,都无关紧要,就算冒泡变成换最小的元素换到数组的最左端,那它也叫冒泡排序的. 冒泡排序的描述:它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进

Python之冒泡算法

有如下列表,要求从左到右顺序排序 li = [13,22,6,99,11] 实现方法: li = [13,22,6,99,11]print "##########原始数字顺序################"print liprint "#########开始第一次排序############3"for m in range(4):    num1 = li[m]    num2 = li[m+1]    if num1>num2:       tmp = l

python模块之re，os，sys。冒泡算法和反射。

python内置模块之(os,sys,hashlib,re) os模块 1 os.path.dirname() # 获取文件的上一层目录名,其实就是os.path.split(path)的第一个元素 2 os.path.abspath() # 获取文件的绝对路径,包括文件名 3 os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 4 os.chdir("dirname") 改变当前脚本工作目录:相当于shell下cd 5 os.curdir 返回当前目录:

【Java/Android性能优 6】Android 图片SD卡缓存 使用简单 支持预取 支持多种缓存算法 支持不同网络类型 支持序列化

本文转自:http://www.trinea.cn/android/android-imagesdcardcache/ 本文主要介绍一个支持图片自动预取.支持多种缓存算法.支持数据保存和恢复的图片Sd卡缓存的使用.功能及网友反馈的常见问题解答. 需要二级缓存或ListView和GridView图片加载请优先使用ImageCache. 与Android LruCache相比主要特性:(1). 使用简单  (2). 轻松获取及预取新图片  (3). 可选择多种缓存算法(FIFO.LIFO.LRU.M

php冒泡算法

1.冒泡算法 网上搜了很多,但是总是对于每次循环的边界值思路讲的比较笼统.不是很容易被新手记住,我自己平时也是硬记下来的.但是对于算法,硬记,时间长了还是容易忘记,所以自己写了一次,把每次思路尽量写下来,便于理解,理解了容易加深映像,不容易忘记了. 冒泡算法,核心就是 循环比对  每次比对相邻2个数组的大小,然后把最大的数组放到后面,这样所有比对循环一次,就会把数组中最大的数放到数组最后, 然后重复循环(重复上面的比对循环):此时循环的时候 最后一个值是不需要参加循环了,因为已经确定是最大的那个

01 | 复杂度分析（上）：如何分析、统计算法的执行效率和资源消耗？

我们都知道,数据结构和算法本身解决的是“快”和“省”的问题,即如何让代码运行得更快,如何让代码更省存储空间.所以,执行效率是算法一个非常重要的考量指标.那如何来衡量你编写的算法代码的执行效率呢?这里就要用到我们今天要讲的内容:时间.空间复杂度分析.其实,只要讲到数据结构与算法,就一定离不开时间.空间复杂度分析. 而且,我个人认为,复杂度分析是整个算法学习的精髓,只要掌握了它,数据结构和算法的内容基本上就掌握了一半.其实,只要讲到数据结构与算法,就一定离不开时间.空间复杂度分析. 复杂度分析实在太

复杂度分析（上）：如何分析、统计算法的执行效率和资源消耗

复杂度分析是什么? 复杂度分析就是分析执行一个给定算法需要消耗的计算资源数量(例如计算时间,存储器使用等)的过程. 为什么要学习复杂度分析? 没有复杂度分析怎么得到算法执行的时间和占用的内存大小 把代码运行一遍,通过统计.监控,就能得到算法执行的时间和占用的内存大小. 该方法的缺点在于: 1.测试结果非常依赖测试环境 拿同样一段代码,在 Intel Core i9 处理器上运行的速度肯定要比 Intel Core i3 快得多.同一段代码,在不同机器上运行,也可能会有截然相反的结果. 2.测试结

Java数据结构之算法时间度

1.度量一个程序(算法)执行时间的两种方法 1)事后统计的方法 这种方法可行, 但是有两个问题:一是要想对设计的算法的运行性能进行评测,需要实际运行该程序:二是所得时间的统计量依赖于计算机的硬件.软件等环境因素, 这种方式,要在同一台计算机的相同状态下运行,才能比较那个算法速度更快. 2)事前估算的方法 通过分析某个算法的时间复杂度来判断哪个算法更优. 2.时间频度 基本介绍:一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多.一个算法中的语句执行次数称为

1014 C语言文法定义与C程序的推导过程 程序：冒泡算法C程序（语法树）

1014 C语言文法定义与C程序的推导过程  程序:冒泡算法C程序(语法树)1 阅读并理解提供给大家的C语言文法文件. 2 参考该文件写出一个自己好理解版的现实版的完整版的C语言文法. 3 给出一段C程序,画出用上述文法产生这段C程序的完整语法树. 程序:冒泡算法C程序 点此文字查看原图(完整图片) 1 #include <stdio.h> 2 3 main() 4 { 5 int i,j,temp; 6 int a[10]; 7 8 for(i=0;i<10;i++) 9 scanf