为什么我写的快速排序比冒泡排序慢?

//快速排序
public class QuickSort {
    public static void quickSort(int[] a,int low,int high){
        int mid;
        int ltemp,rtemp;
        ltemp=low;rtemp=high;
        mid=a[(low+high)>>>1];
        while(ltemp<rtemp){//把比mid小的放在左侧,比mid大的放在右侧
            while(a[ltemp]<mid){
                ltemp++;
            }
            while(a[rtemp]>mid){
                rtemp--;
            }
            if(ltemp<rtemp){//交换
                a[ltemp]=a[ltemp]^a[rtemp];
                a[rtemp]=a[ltemp]^a[rtemp];
                a[ltemp]=a[ltemp]^a[rtemp];
                ltemp++;rtemp--;
            }
        }
        if(ltemp==rtemp){
            ltemp++;
        }
        if(ltemp<high) quickSort(a,ltemp,high);
        if(low<rtemp) quickSort(a,low,rtemp);
    }
}
//冒泡排序
public class Sort {
    public static void sort(int[] a){
        int j=0;
        for(int i=1;i<a.length;i++){//循环
            
            j=i-1;
            while(j>=0&&a[j+1]<a[j]){//交换

                a[j]=a[j+1]^a[j];a[j+1]=a[j+1]^a[j];a[j]=a[j+1]^a[j];//交换
                j--;
            }

        }

    }

}
//测试
class MyTimer{//计时方法。
    private final long start;
    public MyTimer(){
        start=System.currentTimeMillis();
    }
    public long getElapsed(){
        return System.currentTimeMillis()-start;
    }
}

public class Test {
    //测试方法
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyTimer t1=new MyTimer();
        for(int i=0;i<100;i++){//测试快速排序速度
            int[]  a = new int[1000];
            for(int j=0;j<a.length-1;j++){
                a[j]=(int) (Math.random()*100);
                QuickSort.quickSort(a,0,a.length-1);
            }
        }
        System.out.println(t1.getElapsed());
        t1=new MyTimer();
        for(int i=0;i<100;i++){//测试冒泡排序速度
            int[]  a = new int[1000];
            for(int j=0;j<a.length-1;j++){
                a[j]=(int) (Math.random()*100);
                Sort.sort(a);
            }
        }
        System.out.println(t1.getElapsed());
        t1=new MyTimer();
        for(int i=0;i<100;i++){//测试系统内快速排序速度
            int[]  a = new int[1000];
            for(int j=0;j<a.length-1;j++){
                a[j]=(int) (Math.random()*100);
                java.util.Arrays.sort(a);
            }
        }
        System.out.println(t1.getElapsed());
    }

}

结果:

2150
221
730

时间: 2024-10-25 21:10:29

为什么我写的快速排序比冒泡排序慢?的相关文章

使用JAVA直观感受快速排序与冒泡排序的性能差异

初学算法,肯定会编写排序算法 其中两个最为有名的就是冒泡排序和快速排序 理论上冒泡排序的时间复杂度为O(N^2),快速排序的时间复杂度为O(NlogN) 下面本门使用JAVA,分别编写三段排序程序 对十万个0-9999的整数进行一次冒泡排序 对十万个0-9999的整数进行1000次快速排序,使用递归完成 对十万个0-9999的整数进行1000次快速排序,使用堆栈完成 对十万个0-9999的整数进行一次冒泡排序: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

快速排序、冒泡排序

我目前最常用的两种排序:冒泡排序和快速排序 比较一下他们的性能: 1 #include<stdio.h> 2 3 void QuickSort(int * a,int left,int right) 4 { 5 if(left>right) 6 { 7 return; 8 } 9 int stand=a[left]; 10 int i=left; 11 int j=right; 12 //得到基准数位置 13 while(i!=j) 14 { 15 while(i<j&&a

php实现快速排序和冒泡排序

<?php $arr = array(9,4,12,34,1,43,23,7,3,4,5,6,33,22,12,21,15,62,1222,21,322,432,31,54,64); //$sorted_arr = quickSort($arr); $sorted_arr = bublleSort($arr); var_dump($sorted_arr); // 快速排序算法 function quickSort($arr){ if(count($arr)>1){ $k=$arr[0]; $x

快速排序和冒泡排序

前言:并不能一文就解释清楚排序到底是怎么一回事,我所有几乎文章都需要和别的材料配合才比较容易产生理解. 推荐书目: <算法精解> <啊哈,算法> 主要内容: 冒泡排序冒泡排序是一种比较简单的排序算法,容易用C语言写成也非常好理解, 但是它的时间效率不高. 快速排序快速排序是常用的排序算法,时间效率高,而且算法简单,但是乍一看上去,是没有冒泡排序那么“粗浅”的, 我不是说冒泡排序粗浅.冒泡两个字已经非常有意思了. 冒泡排序(Bubble sort) 算法过程 如果说你现在有一组数据需

PHP之快速排序和冒泡排序性能对比

//冒泡排序 function bubble_sort($arr){ $count = count($arr); for($i=0;$i<$count;$i++){ for($j=$count-1;$j>$i;$j--){ if($arr[$j]<$arr[$j-1]){ $tmp = $arr[$j]; $arr[$j] = $arr[$j-1]; $arr[$j-1] = $tmp; } } } return $arr; } //快速排序 function quick_sort($a

有关快速排序和冒泡排序的理解

冒泡排序:将第一位的值与后面所有的值比较,碰到小的就与其交换,第一次循环得到最小的数,再对后面的数循环,得到最小的数,依次下去,复杂度为o(n*n): 快速排序:将第一位的值与后面的值比较,得到这个值在数组中的准确位置,第一次循环与冒泡排序的复杂度式一样的,都是n,可循环之后把数组分为两个数组,继续对两个数组排序.复杂度为log2(n)*n~n*n. 那么为什快速排序会比冒泡排序快呢? 本质原因是快速排序将每一步比较的信息都利用了,而快速排序则丢失了一些比较的信息.为将两种排序类比为一个全国打架

用多线程判断快速排序和冒泡排序的速度

一般的,我们知道快排是优于冒泡排序的,下面就让我们用多线程验证一下,具体操作:先产生一个随机整数n(大于10),再产生n个随机正数存放于数组中,然后创建两个线程并发地对锁生成的随机整数进行排序,其中一个线程采用冒泡排序,另一个线程采用快速排序,最后比较这两个线程哪个先完成排序 闲话少说哈,上代码: 结果分析: (1)当随机数个数取值为10.100时,一般情况下,若冒泡排序的进程先调用,冒泡排序先完成,否则快速排序先完成(线程执行start()函数时并不能说明线程开始执行,只是加入了就绪队列,执不

列举你所知道的排序方法,请写出快速排序的伪代码

排序的方法有:插入排序(直接插入排序.希尔排序),交换排序(冒泡排序.快速排序),选择排序(直接选择排序.堆排序),归并排序,分配排序(箱排序.基数排序) 快速排序的伪代码: / /使用快速排序方法对a[ 0 :n- 1 ]排序 从a[ 0 :n- 1 ]中选择一个元素作为m i d d l e,该元素为支点 把余下的元素分割为两段left 和r i g h t,使得l e f t中的元素都小于等于支点,而right 中的元素都大于等于支点 递归地使用快速排序方法对left 进行排序 递归地使用

比较快速排序,冒泡排序,双向冒泡排序的执行快慢

快速排序 原理是找出一个元素(理论上可以随便找一个)作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值,如此作为基准的元素调整到排序后的正确位置.递归快速排序,将其他n-1个元素也调整到排序后的正确位置.最后每个元素都是在排序后的正 确位置,排序完成.所以快速排序算法的核心算法是分区操作,即如何调整基准的位置以及调整返回基准的最终位置以便分治递归. 冒泡排序算法 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,