浅析java快速排序算法_java

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

一趟快速排序的算法是:

1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;
2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];
3)从j开始向前搜索,即由后开始向前搜索(j--),找到第一个小于key的值A[j],将A[j]和A[i]互换;
4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]和A[j]互换;
5)重复第3、4步,直到i=j; (3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。找到符合条件的值,进行交换的时候i, j指针位置不变。另外,i==j这一过程一定正好是i+或j-完成的时候,此时令循环结束)。

举例说明一下吧,这个可能不是太好理解。假设要排序的序列为

复制代码 代码如下:

package com.zc.manythread;
import java.util.Random;
/**
* 快速排序
* @author Administrator
*
*/
public class QSort {
   int [] date;
   public QSort(int[] date) {
       this.date=date;
   }
   /**
    * 交换函数
    * @param a
    * @param i
    * @param j
    */
   private void swap(int a[],int i,int j) {
       int T;
       T=a[i];
       a[i]=a[j];
       a[j]=T;
   }
   /*******************
    * 排序函数
    * @param a
    * @param lo0
    * @param hi0
    * @return
    */
   int[] QuickSort(int a[],int lo0,int hi0){//分治法,作用就是将数组分为A[lo0..q-1] 和A[q+1..hi0] 
       int lo=lo0;
       int hi=hi0;
       int mid;
       if (hi0>lo0) {
           mid=a[(hi0+lo0)/2];
           while(lo<=hi){
               while((lo<hi0)&&(a[lo]<mid))  ++lo;
               while((hi>lo0)&&(a[hi]>mid))  --hi;
               if (lo<=hi) {
                   swap(a,lo,hi);
                   ++lo;
                   --hi;
               }
           }
           if (lo0<hi) {
               QuickSort(a, lo0, hi);
           }
           if (lo<hi0) {
               QuickSort(a, lo, hi0);
           }
       }
       return a;
   }
   /**************
    *
    * 创建有重复数组数据
    * *****************/
   private static int[]  createDate(int count) {
       int[] data=new int[count];
       for (int i = 0; i < data.length; i++) {
           data[i]=(int)(Math.random()*count);
       }
       return data;
   }
   /**
    * 无重复数组数据
    * @param count
    * @return
    */
   private static int[]  createDate1(int count) {
       int[] data=new int[count];
         Random rand = new Random();
         boolean[] bool = new boolean[100];
         int num = 0;
         for (int i = 0; i < count; i++) {
          do {
           // 如果产生的数相同继续循环
           num = rand.nextInt(100);
          } while (bool[num]);
          bool[num] = true;
          data[i]=num;
         }
         return data;
   }
   /**************主函数*****************/
   public static void main(String[] args) {
       final int count=10;
       int[] data=createDate1(count);
       for (int n:data) {
           System.out.print(n+"\t");
       }
       QSort data1=new QSort(data);
       System.out.println();
       int[] a=data1.QuickSort(data,0, count-1);
       for (int n:a) {
           System.out.print(n+"\t");
       }
   }
}

结果如下:

以上就是本文所述的全部内容了,希望小伙伴们能够喜欢。

时间: 2024-09-30 10:40:18

浅析java快速排序算法_java的相关文章

浅析java 归并排序算法_java

归并排序(Merge)是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的.然后再把有序子序列合并为整体有序序列. 归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用. 将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为2-路归并. 归并排序算法稳定,数组需要O(n)的额外空间,链表需要O(log(n))

浅析java贪心算法_java

贪心算法的基本思路    1.建立数学模型来描述问题. 2.把求解的问题分成若干个子问题. 3.对每一子问题求解,得到子问题的局部最优解. 4.把子问题的解局部最优解合成原来解问题的一个解. 实现该算法的过程: 从问题的某一初始解出发: while 能朝给定总目标前进一步 do 求出可行解的一个解元素: 由所有解元素组合成问题的一个可行解. 贪心选择性质       所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择,换句话说,当考虑做何种选择的时候,我们只考虑对当前问题最佳的

java实现快速排序算法_java

1.算法概念. 快速排序(Quicksort)是对冒泡排序的一种改进.由C. A. R. Hoare在1962年提出. 2.算法思想. 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列. 3.实现思路. ①以第一个关键字 K 1 为控制字,将 [K 1 ,K 2 ,-,K n ] 分成两个子区,使左区所有关键字小于等于 K 1 ,右区所有关键字大于

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 < 1

深入浅析Java注解框架_java

我们经常会在java代码里面看到:"@Override","@Target"等等样子的东西,这些是什么? 在java里面它们是"注解". 下面是百度百科的解释:java.lang.annotation.Retention可以在您定义Annotation型态时,指示编译器如何对待您的自定义 Annotation,预设上编译器会将Annotation资讯留在class档案中,但不被虚拟机器读取,而仅用于编译器或工具程式运行时提供资讯. 也就是说,注解

Java排序算法总结之插入排序_java

本文实例讲述了Java插入排序方法.分享给大家供大家参考.具体分析如下: 有一个已经有序的数据序列,要求在这个已经排好的数据序列中插入一个数,但要求插入后此数据序列仍然有序,这个时候就要用到插入排序法.本文主要介绍的是插入排序的java实现.   插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的.个数加一的有序数据.比较和交换的时间复杂度为O(n^2),算法自适应,对于数据已基本有序的情况,时间复杂度为O(n),算法稳定,开销很低.算法适合于数据已基本有序或者数据量

如何实现快速排序算法

快速排序: 代码: <?php /** 快速排序算法 * 1. 在数组中找一个元素作为key,一般取数组第一个元素作为key * 2. i=0, j=数组长度-1 * 3. j-- 当 arr[j]<key, arr[i]与arr[j]交换位置 * 4. i++ 当 arr[i]>key, arr[i]与arr[j]交换位置 * 5. 重复3,4 直到 i==j 时,完成. * 6. 将key分隔的左右两组元素再分别执行 1,2,3,4,5 (递归). */ $arr = array()

java排序算法

Java 1.0和1.1库都缺少的一样东西是算术运算,甚至没有最简单的排序运算方法.因此,我们最好创建一个Vector,利用经典的Quicksort(快速排序)方法对其自身进行排序. 编写通用的排序代码时,面临的一个问题是必须根据对象的实际类型来执行比较运算,从而实现正确的排序.当然,一个办法是为每种不同的类型都写一个不同的排序方法.然而,应认识到假若这样做,以后增加新类型时便不易实现代码的重复利用. 程序设计一个主要的目标就是"将发生变化的东西同保持不变的东西分隔开".在这里,保持不

图文讲解Java中实现quickSort快速排序算法的方法_java

相对冒泡排序.选择排序等算法而言,快速排序的具体算法原理及实现有一定的难度.为了更好地理解快速排序,我们仍然以举例说明的形式来详细描述快速排序的算法原理.在前面的排序算法中,我们以5名运动员的身高排序问题为例进行讲解,为了更好地体现快速排序的特点,这里我们再额外添加3名运动员.实例中的8名运动员及其身高信息详细如下(F.G.H为新增的运动员): A(181).B(169).C(187).D(172).E(163).F(191).G(189).H(182) 在前面的排序算法中,这些排序都是由教练主