交换排序之快速排序

今天大鹏哥跟大家一起学习下交换排序中的快速排序。

快速排序是对冒泡排序的一种改进。它的基本思想是,通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到真个序列有序。

快速排序基本步骤:

Step1、定义两个变量low和high,他们的初值分别为low和high,此外还有一个变量pivotkey。

Step2、首先从high所指位置向前搜索找到第一个关键字小于pivotkey的记录和pivotkey交换。

Step3、从low所指位置向后搜索,找到第一个关键字大鱼pivotkey的记录和pivotkey交换。

Step4、重复以上步骤直到low=high为止。

待排序列:49   38   65   97   76   13   27  49

1、附设low和high以及设枢轴记录的关键字为pivotkey:

49   38   65   97  76   13   27   49

↑(low)                               ↑(high)

↑(pivotkey)

2、从high所指位置向前搜索,找到第一个小于pivotkey的记录(此处为27)和枢轴记录互相交换:

27   38   65   97  76   13   49   49

↑(low)                               ↑(high)

↑(pivotkey)

3、从low所指位置向后搜索,找到第一个大于pivotkey的记录(此处为65)和枢轴记录互相交换:

27   38   49  97   76   13   65   49

↑(low)              ↑(high)

↑(pivotkey)

4、重复2、3步直至low=high为止。

27   38   13   97  76   49   65   49

↑(low)         ↑(high)

↑(pivotkey)

27   38   13   49  76   97   65   49

↑(low) ↑(high)

↑(pivotkey)

27   38   13   49  76   97   65   49

↑(low=high)

↑(pivotkey)

上面给出的是一趟快排过程,整个快排过程可递归进行,上述操作完成后,再分别对两个子序列进行快速排序。

Java实现如下:

public
class
QuickSort {

public
static void
main(String[] args) {

// TODO Auto-generatedmethod stub

int[] a={49,38,65,97,76,13,27,49};

int pivotloc,low=0,high=a.length-1;

System.out.print("排序前:");

for(int x:a){

System.out.print(x+",");

}

if(low<high){

pivotloc = quickSort(a,low,high);

quickSort(a,low,pivotloc-1);

quickSort(a,pivotloc+1,high);

}

System.out.print("排序后:");

for(int x:a){

System.out.print(x+",");

}

}

private
static int
quickSort(int[] a,
int low, int high) {

int pivotkey=a[low];

while(low<high){

while(low<high&&a[high]>=pivotkey)

high--;

a[low]=a[high];

while(low<high&&a[low]<=pivotkey)

low++;

a[high]=a[low];

}

a[low]=pivotkey;

return low;

}

}

快速排序的时间复杂度为O(NlogN)。

时间: 2024-11-06 09:39:34

交换排序之快速排序的相关文章

数据结构例程—— 交换排序之快速排序

本文是[数据结构基础系列(9):排序]中第5课时[交换排序之快速排序]的例程. 1.以第1个元素作为基准 #include <stdio.h> #define MaxSize 20 typedef int KeyType; //定义关键字类型 typedef char InfoType[10]; typedef struct //记录类型 { KeyType key; //关键字项 InfoType data; //其他数据项,类型为InfoType } RecType; //排序的记录类型定

交换排序:快速排序

快速排序(Quick Sort)也是一种交换排序,它在排序中采取了分治策略. 快速排序的主要思想: 从待排序列中选取一元素作为轴值(也叫主元). 将序列中的剩余元素以该轴值为基准,分为左右两部分.左部分元素不大于轴值,右部分元素不小于轴值.轴值最终位于两部分的分割处. 对左右两部分重复进行这样的分割,直至无可分割. 从快速排序的算法思想可以看出,这是一递归的过程. 两个问题: 要想彻底弄懂快速排序,得解决两个问题: 如何选择轴值?(轴值不同,对排序有影响吗?) 如何分割? 问题一:轴值的选取?

1)①排序算法之交换排序[2]快速排序

1 #include<iostream> 2 using namespace std; 3 4 //************快速排序法********* 5 int partiton(int array[10],int s,int t,int &cutpoint){ 6 int x=array[s]; 7 int i,j; 8 i=s; 9 j=t; 10 while(i!=j){ 11 while(i<j&&array[j]>x)j--; 12 if(i&

交换排序——2快速排序实现

快速排序的效率比较高的算法,如果我们只能掌握一种排序,那快速排序是最佳的选择. private int Division(int[] list, int left, int right) { // 以最左边的数(left)为基准 int bs = list[left]; while (left < right) { // 从序列右端开始,向左遍历,直到找到小于base的数 while (left < right && list[right] >= bs) right--;

交换排序-快速排序

复杂的案例 [9, 3, 5, 7, 5, 1, 6, 13, 0, 4] [4, 3, 5, 7, 5, 1, 6, 13, 0, 9] [4, 3, 5, 7, 5, 1, 6,  9, 0, 13] 第一趟交换完毕,然后会将原数组分割为两个数组,其中[基准元素]9已经是在正确的位置了 先对左半部分[4, 3, 5, 7, 5, 1, 6, 0]排序 [4, 3, 5, 7, 5, 1, 6, 0, 9, 13] [0, 3, 5, 7, 5, 1, 6, 4, 9, 13] [0, 3, 

java 交换排序之(冒泡排序、快速排序)

2016年上班第一天,闲来无事,先写篇博文来结束今天.我们大家都知道java的排序算法很多,接下来我就先看看java最常用的几种排序算法的思想源码附上.(本文所有排序只针对值排序,关于对象排序问题待续.....) 1.插入排序(直接插入排序.二分法插入排序.表插入排序.shell排序) 2.选择排序(直接选择排序.堆排序) 3.交换排序(冒泡排序.快速排序) 4.分配排序(基数排序) 5.归并排序(内排序.外排序) 一.java冒泡排序实现(大家最喜欢也是最简单的排序算法,但是性能不是那么ok

排序算法(三)——交换排序

前两篇文章中介绍了选择排序和插入排序,今天我们继续往下来介绍其他的排序算法,介绍交换排序中的冒泡排序和快速排序. 1.交换排序:冒泡排序 定义:首先将第一个记录的关键字和第二个记录的关键字进行比较,若为逆序,则交换这两个记录的值,然后比较第二个记录和第三个记录的关键字,依此类推直至第n-1个记录和第n个记录的关键字比较过为止. 做法:上述过程称为第一趟冒泡排序.其结果是关键字最大的记录被交换到第n个记录的位置.然后进行第二趟冒泡排序,对前n-1个记录进行同样的操作,其结果是关键字次大的记录被交换

浅谈算法和数据结构: 四 快速排序

原文:浅谈算法和数据结构: 四 快速排序 上篇文章介绍了时间复杂度为O(nlgn)的合并排序,本篇文章介绍时间复杂度同样为O(nlgn)但是排序速度比合并排序更快的快速排序(Quick Sort). 快速排序是20世纪科技领域的十大算法之一 ,他由C. A. R. Hoare于1960年提出的一种划分交换排序. 快速排序也是一种采用分治法解决问题的一个典型应用.在很多编程语言中,对数组,列表进行的非稳定排序在内部实现中都使用的是快速排序.而且快速排序在面试中经常会遇到. 本文首先介绍快速排序的思

(2)排序之快速排序

参考:http://www.cnblogs.com/jingmoxukong/p/4302891.html 要点 快速排序是一种交换排序. 快速排序由C. A. R. Hoare在1962年提出. 它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分:分割点左边都是比它小的数,右边都是比它大的数. 然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列. 详细的图解往往比大堆的文字更有说明力,所以直接上图: 上图中,演示了快速排序的处理过程: