排序（2）

最新推荐文章于 2024-09-21 14:48:47 发布

brucest0078

最新推荐文章于 2024-09-21 14:48:47 发布

阅读量662

点赞数

分类专栏：算法文章标签： integer vector exception 算法 java thread

本文链接：https://blog.csdn.net/BruceXX/article/details/4300843

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

冒泡说到底，是一种非常低级的排序方式，为什么，写一个主函数来见识一下就知道了。。

public static void main(String args[]){
int a[]=GenerateNumber(100000, 100);
long s=System.currentTimeMillis();
bubbleSort(a);
long e=System.currentTimeMillis();
System.out.println("execute time:"+(e-s));
}

下面的一数据比较：10000 ，execute time:172

10*10000, execute time:15391

100*10000, 机器无尽的燃烧中

还有什么选择排序，简单排序之类的，就不作一一介绍，没有必要去研究，都是差不多的原理。

level2：下面即将登场的是的快速排序，如其名，快，但是有其缺点，就是不稳定，用于数字排序比较好，

在字符串排序方面，归并要好的多，先不多说这些，介绍一下原理。

首先需要设置一个哨兵p,也就是存储每次排序后的关键字位置，

53,80,86,96,92,30,14,25,70,75

因为快速是基于分治法的一种，拿一个block来说明一下这种partition过程。start,end为首尾数组地址

哨兵一般是取block第一个。53，与最后一个来做比较，如果最后一个大于p，把尾指针向前移，end--,

指向前一个,这里就是53和75比较，显然75要大，

往前，然后起到20，这时候把25和53交换，即block[start]=block[end]

这里要注意，p是一个临时变量，这里的交换是交换的实际地址，也就是p不会变的，所以才叫哨兵。

交换后再从start开始，这时候block[start]现在已经是25了，因为已经交换过了，再和p比较，如果小，

start++,向前进，直至80,比p大，交换，

然后再从end往前推。。。最后肯定会到一个位置，好像夹逼准则一样，然后这个位置就是我们需要的关键位置。

程序如下：

 private static int partition(int a[],int s,int e){
  
  int key=a[s];
  while(s<e){
   while(s<e && a[e]>=key)
    e--;
   a[s]=a[e];
   while(s<e && a[s]<=key)
    s++;
   a[e]=a[s];
  }
  a[s]=key;
  return s;
 }

这时候只是一个分治的一个小方法，剩下的事情就是我们向上看了，写大方法

 public static void Qsort(int a[],int s,int e){
  if(s<e){
   int privot=partition(a, s, e);
   Qsort(a, s, privot-1);
   Qsort(a, privot+1, e); 
  }
 }

OK。。递归，简单清楚，不需要多说，就是一个将整体数组分块成n份进行整理。。

如果不清楚，可以用排序1里面的AlgorithmAnimation来进行调试一下，看下数据走向是如何的。

看下level2和level1的差别。。看差别，再说为什么。。

数据： 10*10000 ，execute time:78

100*10000，Exception in thread "main" java.lang.StackOverflowError

为什么，递归的伤，因为函数体是存储在全局数据区的，即栈空间，直至生命周期结束才over,

递归是一个超耗空间的东西，将其改造一下，写成非递归。

改造一下，改为非递归的：

public static void noQsort(int[] a,int s,int e){

Stack s1=new Stack();
Stack s2=new Stack();
s1.push(s);
s2.push(e);
int tl,th,p;
while(!s1.isEmpty() && !s2.isEmpty()){
tl=(Integer)s1.pop();
th=(Integer)s2.pop();
if(tl>=th) continue;
p=partition(a, tl, th);
s1.push(tl);
s2.push(p-1);
s1.push(p+1);
s2.push(th);
}