随机化快速排序(Java实现)

Randomized quicksort(随机化快速排序)

  • running time is independent of input ordering.
  • no assumption about the input distribution.(无需对输入序列分布做任何假设)
  • no specific input elicit the worst-case behavior.(没有特定输入引起最差的运行效率)
  • worst-case determined only by a random -number generator.(最差的情况由随机数产生器决定)
  • pivot a random element.(随机选择一个主元)

根据《算法导论》中快速排序的随机化样本中的伪代码如下:

数组的划分:

1 RANDOMIZED-PARTITION(A, p, r)
2 i = RANDOM(p, r)
3 exchange A[r] with A[i]
4 return PARTITION(A, p ,r)

其中PARTITION(A, p, r)参考快速排序(Java实现)

1 RANDOMIZED-QUICKSORT(A, p, r)
2     if p < r
3         q = RANDOMIZED-PARTITION(A, p, r)
4         RANDOMIZED-QUICKSORT(A, p, q-1)
5         RANDOMIZED-QUICKSORT(A, q+1, r)

随机快速排序,随机选择一个主元和数组划分:RandomQuickSort.java

 1 package quicksort;
 2
 3 import java.util.Random;
 4
 5 public class RandomQuickSort {
 6
 7     public void Sort(int[] a, int p, int r) {
 8         if (p < r) {
 9             int q = Partition(a, p, r);
10             Sort(a, p, q-1);
11             Sort(a,q+1, r);
12         }
13     }
14
15     private int Partition(int[] A, int p, int r) {
16         /*随机选取主元元素*/
17         Random random = new Random();
18         int random_index = random.nextInt(r-p+1)+p;
19         System.out.println("random_index="+random_index);
20         int temp = A[random_index];
21         A[random_index] = A[r];
22         A[r] = temp;
23
24         int x = A[r];  //pivot = A[p]
25         int i = p-1;
26         for (int j = p; j < r; j++) {
27             if (A[j] <= x) {  //与pivot作比较
28                 i++;
29                 int tmp = A[j];
30                 A[j] = A[i];
31                 A[i] = tmp;
32             }
33         }
34
35         int tmp = A[r];
36         A[r] = A[i+1];
37         A[i+1] = tmp;
38
39         return i+1;
40
41     }
42
43 }

测试随机化快速排序:RandomQuickSortTest.java

 1 package quicksort;
 2
 3 public class RandomQuickSortTest {
 4
 5 //    static int[] a ={2, 8, 7, 1, 3, 5, 6, 4};
 6     static int[] a ={13, 19, 9, 5, 12, 8, 7, 4, 21, 2, 6, 11};
 7     public static void main(String[] args) {
 8         RandomQuickSort randomQuickSort = new RandomQuickSort();
 9         randomQuickSort.Sort(a, 0, a.length-1);
10
11         for (int i = 0; i < a.length; i++) {
12             System.out.print(a[i]+" ");
13         }
14     }
15 }

测试结果:

random_index=2
random_index=2
random_index=0
random_index=0
random_index=8
random_index=10
random_index=7
random_index=7
2 4 5 6 7 8 9 11 12 13 19 21 
时间: 2024-10-08 14:08:41

随机化快速排序(Java实现)的相关文章

排序算法五:随机化快速排序(Randomized quicksort)

上一篇提到,快速排序的平均时间复杂度是O(nlgn),比其他相同时间复杂度的堆排序.归并排序都要快,但这是有前提的,就是假定要排序的序列是随机分布的,而不是有序的.实际上,对于已经排好的序列,如果用快速排序时间复杂度是O(n2).为应对这样的有序序列,于是出现了本篇要讲的随机化快速排序(Randomized quicksort). 快速排序在选主元(pivot)时,总是选择第一个:随机化快速排序的思想是,随机从序列中选择一个作为主元. (一)算法实现 1 protected void quick

随机化快速排序法

为什么要有随机化快速排序.对于快速排序大家知道,如果选取某个固定的值作为分界点(左边小于当前值,右边大于当前值),当排序的数组近乎有序,极有可能退化成O(n^2)级别的算法,因为拆分的数组极不均匀,两边的数组大小相差太大.如果采取随机化选取分界点,这样的化退化成O(n^2)几乎为零. package com.newtouch.data.sort; import com.newtouch.data.test.SortTestHelper; public class QuickSortRandoml

算法导论-排序(二)快速排序、随机化快速排序

目录 1.本文介绍 2.快速排序 3.随机化快速排序 4.完整源码 5.参考资料 内容 1.本文介绍 主要内容分为两部分,一部分是介绍快速排序算法,分析其在最好.最坏以及最好最差交替出现情况下的算法效率:另一部分则是介绍随机化快排算法,以及分析其算法复杂度.最后给出c++实现代码. 2.快速排序 快速排序也是基于分治思想,首先把要排序的数组分为两份,然后再分别对分好的子数组进行快速排序.当子数组为1个元素时递归介绍,排序完成.快速排序属于“原地排序”,就是说在原有的数组内存上排序.不占用其他内存

排序算法----快速排序java

快速排序是对冒泡排序的一种改进,平均时间复杂度是O(nlogn) import java.util.Arrays; import java.util.Scanner; public class test02{ public static void main(String[] args) { int n = 1; while (n != 0){ Scanner scanner = new Scanner(System.in); n = scanner.nextInt(); int s[] = ne

插入排序,希尔排序,堆排序,归并排序,快速排序Java实现

参看:数据结构与算法分析-c语言描述 public class Main { public static void main(String[] args) { String[] a = { "a", "d", "e", "f", "m" }; String[] b = { "a", "h", "g", "l", "z&

手写快速排序(java实现)

手写快速排序(java实现) 时间复杂度: O(nlogn) 快速排序原理: 定义一个基准元素base(我这里定义的是最左面的元素定位基准元素) 定义两个变量i和j j先从右向左遍历,找到第一个比base小的数就停止 i再从左向右便利找到第一个比base大的数停止 交换i和j指向的元素 直到i和j指向同一个元素,将这个元素与基准元素交换 递归求解即可 图解:(排序过程) 注意: 上图为第一次快速排序的过程,递归过程和上图一致(没有给出) 每一次的排序结果: 现在在火车上没有给出具体每次排序结果,

快速排序的优化(一)随机化快速排序

这周研究快速排序优化策略,首先是利用随机化对快速排序进行优化. 众所周知,之前的基础快速排序算法,其效率一个关键点就在与划分元素的选取,由于之前一直选取的是第一个元素,所以当遇到特殊输入,比如太大或者太小,就会造成区间划分极度不合理. 引入随机化,就是在每一次划分的时候随机选取一个元素作为关键字,用它来进行划分.由于每一次划分都是随机选取,所以每一次都选到不好的元素概率低,可以作为一个优化的方向. 和之前的基础快速排序主要区别有两个 1.首先是partition部分 利用rand产生随机数  ,

快速排序java代码

import java.util.Scanner; import java.util.ArrayList; public class Paixu2{ public int[] alist; //快速排序 public static void main(String args[]) { Paixu2 he=new Paixu2(); he.setup(); he.look(); he.go(0,9); he.look(); } public void setup(){ Scanner sc=new

快速排序(Java实现)

在<算法导论>的第7章快速排序(QuiclSort)采用分治思想(Divide and Conquer).对一个典型的子数组A[p..r]进行快速排序的三步分治过程: 分解(divide):数组A[p..r]被划分为两个(可能为空)子数组A[p..q-1]和A[q+1..r],使得A[p..q-1]中的每个元素都小于等于A[q],而A[q]也小于等于A[q+1..r]中的每个元素.其中,计算下标q也是划分过程的一部分. 解决(Conquer):通过递归调用快速排序,对子数组A[p..q-1]和