C++实现快速排序(Quicksort)算法

本文实例为大家分享了C++快速排序算法,供大家参考,具体内容如下

一、基本思想是:

通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

二、方法1实现程序:左右两个方向扫描

// 快速排序:选第一个对象作为基准,按照该对象的排序码大小,将整个对象
// 序列划分为左右两个字序列:
// 左侧子序列中所有对象的排序码都小于或等于基准对象的排序码;
// 右侧子序列中所有对象的排序码都大于基准对象的排序码;
// 基准对象则排在这两个子序列中间,这也是该对象最终应放的位置
// 然后分别对这两个子序列重复施行上述方法,直到所有的对象都排在相应位置上为止
#include <iostream>

// 一次快速排序算法
int quickPass(int arr[], int low, int high) {
 int down, up, temp;

 down = low;
 up = high;
 temp = arr[low];
 while(down < up) {
  while((down < up) && arr[up] >= temp) // 从右向左扫描
   up--;
  if(down < up)
   arr[down++] = arr[up]; // 在被腾空出来的单元(由down指向)中填入arr[up]
  while((down < up) && arr[down] < temp) // 从左向右扫描
   down++;
  if(down < up)
   arr[up--] = arr[down]; // 在被腾空出来的单元(由up指向)中填入arr[down]
 }
 arr[down] = temp; // 最后把基准插回到数组中间去
 return down;
}

// 快速排序算法
void quickSort(int arr[], int low, int high) {
 // 对序列arr[low]到arr[high]作快速排序
 int mid;

 if(low < high) {
  mid = quickPass(arr, low, high); // 对序列arr[low]到arr[high]作一趟快速排序
  quickSort(arr, low, mid-1); // 对左半部分作递归处理
  quickSort(arr, mid+1, high); // 对右半部分作递归处理
 }
}

int main(int argc, const char * argv[]) {
 // insert code here...
 int len, i;
 int arr[] = {40, 30, 60, 90, 70, 10, 20, 40};

 len = sizeof(arr) / sizeof(arr[0]);
 std::cout << "排序前:\n";
 for(i = 0; i < len; i++)
  std::cout << arr[i] << " ";
 std::cout << std::endl;

 quickSort(arr, 0, len-1); // 调用快速排序法

 std::cout << "排序后:\n";
 for(i = 0; i < len; i++)
  std::cout << arr[i] << " ";
 std::cout << std::endl;
 return 0;
}

运行结果:

三、方法2:只往一边扫描

// 快速排序的另一种方法:只往一边扫描
#include <iostream>

// 交换两个数
void Exchange(int &a, int &b) {
 int temp;

 temp = a;
 a = b;
 b = temp;
}

// 将序列分为左右两部分,左部分较小,右部分较大
int Partition(int arr[], int low, int high) {
 int x, i, j;

 x = arr[high]; // 以high位置的数作为基准
 i = low - 1;
   // 进行数据分类:左部分较小,右部分较大
 for(j = low; j < high; j++)
  if(arr[j] <= x) { // 往右扫描找小于或者等于基准的数
   i = i + 1;
   Exchange(arr[i], arr[j]); // 交换
  }
 Exchange(arr[i+1], arr[high]); // 把基准放到中间
 return i+1;
}

// 快速排序算法
void quickSort(int arr[], int low, int high) {
 int q;

 if(low < high) {
  q = Partition(arr, low, high);
  quickSort(arr, low, q-1);
  quickSort(arr, q+1, high);
 }
}

int main(int argc, const char * argv[]) {
 int len, i;
 int arr[] = {40, 30, 60, 90, 70, 10, 20, 40};

 len = sizeof(arr) / sizeof(arr[0]);
 std::cout << "排序前:\n";
 for(i = 0; i < len; i++)
  std::cout << arr[i] << " ";
 std::cout << std::endl;
 quickSort(arr, 0, len-1); // 调用快速排序法

 std::cout << "排序后:\n";
 for(i = 0; i < len; i++)
  std::cout << arr[i] << " ";
 std::cout << std::endl;
 return 0;
}

运行结果:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • C++快速排序的分析与优化详解

    相信学过数据结构与算法的朋友对于快速排序应该并不陌生,本文就以实例讲述了C++快速排序的分析与优化,对于C++算法的设计有很好的借鉴价值.具体分析如下: 一.快速排序的介绍 快速排序是一种排序算法,对包含n个数的输入数组,最坏的情况运行时间为Θ(n2)[Θ 读作theta].虽然这个最坏情况的运行时间比较差,但快速排序通常是用于排序的最佳的实用选择.这是因为其平均情况下的性能相当好:期望的运行时间为 Θ(nlgn),且Θ(nlgn)记号中隐含的常数因子很小.另外,它还能够进行就地排序,在虚拟内存

  • C/C++实现三路快速排序算法原理

    书接上文,上次讲到了双路快速排序,双路快速排序是将等于v(标志数)的数也进行交换,从而避免了在处理有大量重复数据的数组分组时的不平衡.而三路快速排序则是将等于v的数也分成一组,同样可以解决上述问题.其原理如下: 1.采用随机排序的方法将某个数作为分割数,放在数组开头,该数定义为v.将小于v的一段数组开头的数索引定义为lt,将需要遍历的数组的索引定义为i,将小于v的一段数组的索引定义为gt,数组的开头和结尾的索引分别为l和r.原理图如下: 2.对索引i进行维护,逐个比较索引i对应的数与v的关系.如

  • c++快速排序详解

    说一说快速排序 快速排序,实际中最常用的一种排序算法,速度快,效率高,在N*logN的同等级算法中效率名列前茅.· 基本思想:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分所有数据要小,然后再按此方法对这两部分数据分别进行快速排序.整个排序过程可以递归进行,以此达到整个数据变成有序序列. 将数列变成上述形式,这一步很关键,做好这一步,才能对主元左右的部分进行递归调用.以下是实现这一部分的代码: int partition_sort(int arr[],int l

  • c++ 快速排序算法【过程图解】

    第一.算法描述 快速排序由C. A. R. Hoare在1962年提出,该算法是目前实践中使用最频繁,实用高效的最好排序算法, 快速排序算法是采用分治思想的算法,算法分三个步骤 1.从数组中抽出一个元素作为基数v(我们称之为划界元素),一般是取第一个.最后一个元素或中间的元素 2.将剩余的元素中小于v的移动到v的左边,将大于v元素移动到v的右边 3.对左右两个分区重复以上步骤直到所有元素都是有排序好. 第二.算法实现 /*序列划分函数*/ int partition(int a[], int p

  • c++实现对输入数组进行快速排序的示例(推荐)

    废话不多说,直接上代码 #include "stdafx.h" #include <iostream> #include <string> #include <vector> using namespace std; void quickSort(vector<int> &a, int, int); void swap(int &a, int&b); vector<string> split(strin

  • C/C++实现双路快速排序算法原理

    看了刘宇波的视频,讲双路快速排序的,原理讲的很直观,程序讲解也一看就懂.这里写一下自己的理解过程,也加深一下自己的理解. 首先说一下为什么需要双路排序,在有些带有许多重复数据的数组里,使用随机快速排序或者最简单的快速排序算法时,由于重复的数据会放在原来的索引位置不动,就回导致划分数组时划分的某一部分太长,起不到分段排序的效果,这样就导致算法退化成O(n^2)的复杂度.就像下图: 为了解决这个问题,双路快速排序采用的方法是对等于v的数也进行交换,原理如下所述: 首先选择一个数作为标志,放在数组的最

  • C/C++实现快速排序的方法

    快速排序不会直接得到最终结果,只会把比k大和比k小的数分到k的两边.(你可以想象一下i和j是两个机器人,数据就是大小不一的石头,先取走i前面的石头留出回旋的空间,然后他们轮流分别挑选比k大和比k小的石头扔给对面,最后在他们中间把取走的那块石头放回去,于是比这块石头大的全扔给了j那一边,小的全扔给了i那一边.只是这次运气好,扔完一次刚好排整齐.)为了得到最后结果,需要再次对下标2两边的数组分别执行此步骤,然后再分解数组,直到数组不能再分解为止(只有一个数据),才能得到正确结果. -- 取自百度百科

  • C++实现快速排序(Quicksort)算法

    本文实例为大家分享了C++快速排序算法,供大家参考,具体内容如下 一.基本思想是: 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列. 二.方法1实现程序:左右两个方向扫描 // 快速排序:选第一个对象作为基准,按照该对象的排序码大小,将整个对象 // 序列划分为左右两个字序列: // 左侧子序列中所有对象的排序码都小于或等于基准对象的排序码: /

  • PHP快速排序quicksort实例详解

    本文实例讲述了PHP快速排序quicksort.分享给大家供大家参考,具体如下: quicksort 在快速排序算法中,使用了分治策略.首先把序列分成两个子序列,递归地对子序列进行排序,直到整个序列排序结束.(即一分为二的思想) 步骤如下: 在序列中选择一个关键元素做为轴: 对序列进行重新排序,将比轴小的元素移到轴的前边,比轴大的元素移动到轴的后面.在进行划分之后,轴便在它最终的位置上: 递归地对两个子序列进行重新排序:含有较小元素的子序列和含有较大元素的子序列. 比如序列$arr: 5 3 0

  • Java快速排序QuickSort(实例)

    快速排序 ---------------------------------------------------------------------- 思想 如上图:每趟快速排序开始时,设置一个key,key=array[low],然后由high向左,找到小于key的值,复制到low位置,然后再由low向右找到大于key的值,复制到high位置,直到low=high结束, 将key的复制到low位置. 上图中第一轮划分后找到32的位置,然后递归的对32左边和右边的进行排序. 代码: packag

  • Java 快速排序(QuickSort)原理及实现代码

    快速排序(QuickSort )是常用到的效率比较高的一种排序算法,在面试过程中也经常提及.下面就详细讲解一下他的原理.给出一个Java版本的实现. 快速排序思想: 通过对数据元素集合Rn 进行一趟排序划分出独立的两个部分.其中一个部分的关键字比另一部分的关键字小.然后再分别对两个部分的关键字进行一趟排序,直到独立的元素只有一个,此时整个元素集合有序. 快速排序的过程--挖坑填数法(这是一个很形象的名称),对一个元素集合R[ low ... high ] ,首先取一个数(一般是R[low] )做

  • 大厂面试常考:快速排序冒泡排序算法

    目录 一.概念 二.基本思想 三.算法步骤 四.具体示例 五.快排代码 基本排序方式详图: 一.概念 快速排序,顾名思义就是一种以效率快为特色的排序算法,快速排序(Quicksort)是对冒泡排序的一种改进.由英国计算机专家:托尼·霍尔(Tony Hoare)在1960年提出. 二.基本思想 从排序数组中找出一个数,可以随机取,也可以取固定位置,一般是取第一个或最后一个,称为基准数. 然后将比基准小的排在左边,比基准大的放到右边: 如何放置呢,就是和基准数进行交换,交换完左边都是比基准小的,右边

  • 快速排序的算法思想及Python版快速排序的实现示例

    快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序.它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod). 1.分治法的基本思想 分治法的基本思想是:将原问题分解为若干个规模更小但结构与原问题相似的子问题.递归地解这些子问题,然后将这些子问题的解组合为原问题的解. 2.快速排序的基本思想 设当前待排序的无序区为R[low..high],利用分治法可将快速排序的基本思想描述为: (1)分解: 在R[low..high]中任选一个记录作为基准(

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

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

  • 浅析java快速排序算法

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

  • Python实现桶排序与快速排序算法结合应用示例

    本文实例讲述了Python实现桶排序与快速排序算法结合应用的方法.分享给大家供大家参考,具体如下: #-*- coding: UTF-8 -*- import numpy as np from QuickSort import QuickSort def BucketSort(a, n): barrel = {} for i in xrange(0,n): barrel.setdefault(i, []) min = np.min(a) max = np.max(a) for x in a: f

随机推荐