快速排序算法及比较

         最近想看了下算法，想至少对于优秀的算法有个大致的了解。最后发觉，快速排序是综合来说很好的一个算法，于是记录一下快排算法，和于其小弟冒泡排序的时间比较，让我具体了解，其效率的差别,一下是代码，和测试几率

快速排序（Quicksort）是对 冒泡排序的一种改进。

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以 递归进行，以此达到整个数据变成有序 序列。

递归的 算法如下：

 

public static void kuaipai(int a [],int low,int high){
    int i, j, index;
    if (low > high) {
        return;
    }
    i = low;
    j = high;
    index = a[i]; // 用子表的第一个记录做基准
    while (i < j) { // 从表的两端交替向中间扫描

        while (i < j && a[j] >= index)
            j--;
        if (i < j)
            a[i++] = a[j];// 用比基准小的记录替换低位记录
        while (i < j && a[i] < index)
            i++;
        if (i < j) {// 用比基准大的记录替换高位记录
            a[j--] = a[i];
        }

    }
    a[i] = index;// 将基准数值替换回 a[i]
    kuaipai(a, low, i - 1); // 对低子表进行递归排序
    kuaipai(a, i + 1, high); // 对高子表进行递归排序
}

        简单冒泡的算法如下：

static void maopao(int[] unsorted)
{
    for (int i = 0; i < unsorted.length; i++)
    {
        for (int j = i; j < unsorted.length; j++)
        {
            if (unsorted[i] > unsorted[j])
            {
                int temp = unsorted[i];
                unsorted[i] = unsorted[j];
                unsorted[j] = temp;
            }
        }
    }
}

       完整的测试如下（设置了一个按需求增加随机数的方法，和两个线程，同时对同样的数组进行排序分析，看其分析时间）：

package 排序;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class 快排 {

public static void main(String[] args) {
	
	final int a[] =createarray(1000000);
	final int b[] =a;
	ExecutorService  executorService= Executors.newFixedThreadPool(2);
	for(int i =0;i<2;i++)
	executorService.execute(new Runnable() {
		@Override
		public void run() {
			Long StartTime;
			if(Thread.currentThread().getName().contains("pool-1-thread-1")){
			StartTime=	System.currentTimeMillis();
			System.out.println("快排排序 开始时间"+StartTime);
			kuaipai(a,0, a.length-1);
			System.out.println("快排排序  所需时间："+(System.currentTimeMillis()-StartTime));
			}else{
			StartTime=	System.currentTimeMillis();
			System.out.println("冒泡排序 开始时间"+StartTime);
			maopao(b);
			System.out.println("冒泡排序  所需时间："+(System.currentTimeMillis()-StartTime));
			}
		
		}
	});
}

public static void kuaipai(int a [],int low,int high){
	  int i, j, index;
      if (low > high) {
          return;
      }
      i = low;
      j = high;
      index = a[i]; // 用子表的第一个记录做基准
      while (i < j) { // 从表的两端交替向中间扫描
          while (i < j && a[j] >= index)
              j--;
          if (i < j)
              a[i++] = a[j];// 用比基准小的记录替换低位记录
          while (i < j && a[i] < index)
              i++;
          if (i < j) // 用比基准大的记录替换高位记录
              a[j--] = a[i];
      }
      a[i] = index;// 将基准数值替换回 a[i]
      kuaipai(a, low, i - 1); // 对低子表进行递归排序
      kuaipai(a, i + 1, high); // 对高子表进行递归排序
}


public static  int[] createarray(int count){
	int [] shuzu=new int[count];
	for(int i=0;i<shuzu.length;i++){
		shuzu[i]=(int) (Math.random()*1000);
	}
	return shuzu;
}

static void maopao(int[] unsorted)
{
    for (int i = 0; i < unsorted.length; i++)
    {
        for (int j = i; j < unsorted.length; j++)
        {
            if (unsorted[i] > unsorted[j])
            {
                int temp = unsorted[i];
                unsorted[i] = unsorted[j];
                unsorted[j] = temp;
            }
        }
    }
}
}

   

  其中 测试结果如下：

当一万条数据 一起排序时

快排排序 开始时间1496393551289
冒泡排序 开始时间1496393551289
快排排序  所需时间：6
冒泡排序  所需时间：21

当十万条数据 一起排序时

快排排序 开始时间1496393293376
冒泡排序 开始时间1496393293376
快排排序  所需时间：37
冒泡排序  所需时间：1557

当一百万条数据 一起排序时

快排排序 开始时间1496393599713
冒泡排序 开始时间1496393599713
快排排序  所需时间：708
冒泡排序  所需时间：153588