java快速排序算法与冒泡排序算法比较

首先看下,冒泡排序算法与快速排序算法的效率:

如下的是main方法

 代码如下 复制代码
/**
  *
 * @Description:
 * @author:cuiyaonan2000@163.com
 * @date 2014年11月5日 下午1:02:10
  */
 public static void main(String[] args) {
  //快速排序算法测试
  int[] qArray = new int[100000];
  for (int i = 0; i < 100000; i++){
   qArray[i] = (int) (Math.random() * 100000);
  }
  long beforeQ = System.currentTimeMillis();
  quickSort(qArray, 0, qArray.length-1);
  System.out.println("快速排序运行时间:" + (System.currentTimeMillis() - beforeQ));
 
  //冒泡排序算法测试
  int[] bArray = new int[100000];
  for (int i = 0; i < 100000; i++){
   bArray[i] = (int) (Math.random() * 100000);
  }
  long beforeB = System.currentTimeMillis();
  bubble(bArray);
  System.out.println("冒泡排序运行时间:" + (System.currentTimeMillis() - beforeB));
 }

在一个有100000 个数字的数组中排序结果如下:

如下的是大家耳熟能详的冒泡算法:

 代码如下 复制代码
/**
  *
 * @Description:
 * @author:cuiyaonan2000@163.com
 * @date 2014年11月5日 下午1:00:32
  */
 public static void bubble(int[] data) {
  for (int i = 0; i < data.length - 1; i++) {
   for (int j = i + 1; j < data.length; j++)
    if (data[i] > data[j]) {
     int temp = data[j];
     data[j] = data[i];
     data[i] = temp;
    }
  }
 }

先说下关于快速排序算法的思路:
选取数组第一个数字,作为key.并设置变量i为0,j为数组长度.
从数组最后一位开始向前找,找什么呢?找比key小的数字(不能等于),并记录下坐标j.限制条件是,在向前找的过程中如果一直没找到比key小的数值,就在i<j的时候停止(如果没有找到j就做减一操作继续找).如果找到了就将数组[j]与数组[i]的值对换并结束.
从数组第一位开始向后找,找什么呢?找比key大的数字(不能等于),并记录下坐标i.限制条件是,在向前找的过程中如果一直没找到比key大的数值,就在i<j的时候停止(如果没有找到i就做加一操作继续找).如果找到了就将数组[j]与数组[i]的值对换并结束.
完成如上的操作,打印输出数组发现:数据变得相对有序了,就是在数组中key值坐标前面的都是小于key的,key值坐标后面的都是大于key值得,
所以大家明白了:将以key值为坐标的数组拆分成2个数组,分别去执行123步骤操作,最终就会产生一个有序数组

算法如下

 代码如下 复制代码
/**
  *
 * @Description:
 * @author:cuiyaonan2000@163.com
 * @date 2014年11月5日 下午1:02:45
  */
 public static void quickSort(int[] array,int begin,int end){
  int theKey = array[begin];   //设置关键值
  int i = begin;
  int j = end;
  while(true){
   while(i<j && array[j] >= theKey)   //从后面找到一个比关键之小的数字坐标
    j-- ;
   if(i<j){  //交换
    int temp = array[j];
    array[j] = array[i];
    array[i] = temp;
   }else{
    break;
   }
   while(i<j && array[i] <= theKey)   //从前面找到一个比关键之大的数字坐标
    i++;
   if(i<j){ //交换
    int temp = array[j];
    array[j] = array[i];
    array[i] = temp;
   }else{
    break;
   }
  }
 
  if(--i > begin ){//这个表示一直找到 被拆分的数组中只有一个值.否则递归调用
   quickSort(array,begin,i);
  }
  if(++j< end){ //这个表示一直找到 被拆分的数组中只有一个值.否则递归调用
   quickSort(array,j,end);
  }
 }

 

时间: 2024-09-27 19:35:44

java快速排序算法与冒泡排序算法比较的相关文章

Java实现的各种排序算法(插入排序、选择排序算法、冒泡排序算法)_java

一.插入排序算法实现java版本 public static int[] insert_sort(int[] a) { for (int i = 0; i < a.length; i++) { for(int j=i+1;j>0&&j<a.length;j--) { if(a[j]<a[j-1]) { int tmp = a[j]; //这样定义初始化逻辑上是可以的,j变量,每次tmp的值变化的 a[j] = a[j-1]; a[j-1] = tmp; } } }

我的Java开发学习之旅------&amp;gt;Java经典排序算法之冒泡排序

冒泡排序(Bubble Sort)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端. 一.算法原理 冒泡排序算法的运作如下: 1.比较相邻的元素.如果第一个比第二个大,就交换他们两个. 2.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 3.

内部排序算法:冒泡排序

基本思想 将被排序的记录数组R[0..n-1]垂直排列,每个记录R[i]看作是重量为R[i].key的气泡.根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其 向上"飘浮".如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止. 具体过程,如下所示: 初始状态:R[0..n-1]为无序区. 第一趟扫描:从无序区底部向上依次比较相邻的两个气泡的重量,若发现轻者在下.重者 在上,则交换二者的位置,即依次比较(R[n-1], R[n-2]).(R

经典算法(1) 冒泡排序的三种实现

冒泡排序是非常容易理解和实现,,以从小到大排序举例: 设数组长度为N. 1.比较相邻 的前后二个数据,如果前面数据大于后面的数据,就将二个数据交换. 2.这样对数组的第0个数据到 N-1个数据进行一次遍历后,最大的一个数据就"沉"到数组第N-1个位置. 3.N=N-1,如果N不为0就 重复前面二步,否则排序完成. 按照定义很容易写出代码: //冒泡排序1 void BubbleSort1(int a[], int n) { int i, j; for (i = 0; i < n;

php数组冒泡排序算法实例_php技巧

本文实例讲述了php数组冒泡排序算法.分享给大家供大家参考,具体如下: <?php /*@冒泡排序算法 */ $array=array(5,45,22,11,32,28,35,56,17,21,92); $len=count($array);//计算数组长度 for($i=0;$i<$len-1;$i++){//需要比较$len-1轮,每一轮需要比较$len-1次 for($j=0;$j<$len-1;$j++){//需要比较$len-1次,因为循环到最后一个数时,后面没有数可以比较了,

JavaScript实现十种经典排序算法(js排序算法)

 冒泡排序算法 冒泡排序(Bubble Sort)是一种简单直观的排序算法.冒泡排序算法的步骤描述如下: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.这步做完后,最后的元素会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. JavaScript实现冒泡排序算法的代码如下: function bubbleSort(arr) {     var l

用java实现冒泡排序算法_java

冒泡排序的算法分析与改进 交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止. 应用交换排序基本思想的主要排序方法有:冒泡排序和快速排序. 复制代码 代码如下: public class BubbleSort implements SortUtil.Sort{ public void sort(int[] data) { int temp; for(int i=0;i<data.length;i++){ for(int j=data.le

冒泡排序算法 递归算法,求n的阶乘 求最大公约数和最小公倍数 java分解质因数

   1.  /**     2.  * 冒泡排序算法     3.  */      4. public class BubbleSort {      5.     public static void sort(int[] values) {      6.         int temp;      7.         for (int i = 0; i < values.length; ++i) {      8.             for (int j = 0; j <

Java实现冒泡排序算法及对其的简单优化示例_java

原理 冒泡排序大概是所有程序员都会用的算法,也是最熟悉的算法之一. 它的思路并不复杂: 设现在要给数组arr[]排序,它有n个元素. 1.如果n=1:显然不用排了.(实际上这个讨论似乎没什么必要) 2.如果n>1: (1)我们从第一个元素开始,把每两个相邻元素进行比较,如果前面的元素比后面的大,那么在最后的结果里面前者肯定排在后面.所以,我们把这两个元素交换.然后进行下两个相邻的元素的比较.如此直到最后一对元素比较完毕,则第一轮排序完成.可以肯定,最后一个元素一定是数组中最大的(因为每次都把相对