【算法-排序】快速排序

最新推荐文章于 2021-09-22 03:52:45 发布
最新推荐文章于 2021-09-22 03:52:45 发布
阅读量313 收藏 1
点赞数
分类专栏： 排序算法 Python Java C++ 文章标签： 排序算法 快速排序 Python实现 Java实现 JavaScript实现
Python 同时被 3 个专栏收录
64 篇文章 3 订阅
订阅专栏
Java
13 篇文章 0 订阅
订阅专栏
排序算法
11 篇文章 0 订阅
订阅专栏

    快速排序（Quick sort）最早由东尼·霍尔提出，它又称划分交换排序（partition-exchange sort），简称快排。在平均状况下，排序 n 个项目要O(nlogn) 次比较。在最坏状况下则需要O(n^{2})次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 O(nlogn)  算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

    快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 z最欢 的时间复杂度达到了 O(n^{2})，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(nlogn)的排序算法表现要更好，《算法艺术与信息学竞赛》上说：快速排序的最坏运行情况是 O(n^{2})，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn)记号中隐含的常数因子很小，比复杂度稳定等于O(nlogn)的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

1. 算法步骤

    （1）挑选基准值：从数列中挑出一个元素，称为 "基准"（pivot）;

    （2）分割：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

    （3）递归排序子序列：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

    递归到最底部的判断条件是数列的大小是0或1，此时该数列显然已经有序。

    选取基准值有数种具体方法，此选取方法对排序的时间性能有决定性影响。

2. 算法复杂度

    最坏时间复杂度：O(nlogn)

    最优时间复杂度：O(n^{2})

    平均时间复杂度：O(nlogn)

    最坏空间复杂度：O(logn)

3. 动图演示

4. 代码实现

    （1）Python

def quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex-1)
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    pivot = left
    index = pivot+1
    i = index
    while  i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

    （2）Java

public class QuickSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return quickSort(arr, 0, arr.length - 1);
    }

    private int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    private int partition(int[] arr, int left, int right) {
        // 设定基准值（pivot）
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

    （3）JavaScript

function quickSort(arr, left, right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left != 'number' ? 0 : left,
        right = typeof right != 'number' ? len - 1 : right;

    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}

function partition(arr, left ,right) {     // 分区操作
    var pivot = left,                      // 设定基准值（pivot）
        index = pivot + 1;
    for (var i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }        
    }
    swap(arr, pivot, index - 1);
    return index-1;
}

function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
function partition2(arr, low, high) {
  let pivot = arr[low];
  while (low < high) {
    while (low < high && arr[high] > pivot) {
      --high;
    }
    arr[low] = arr[high];
    while (low < high && arr[low] <= pivot) {
      ++low;
    }
    arr[high] = arr[low];
  }
  arr[low] = pivot;
  return low;
}

function quickSort2(arr, low, high) {
  if (low < high) {
    let pivot = partition2(arr, low, high);
    quickSort2(arr, low, pivot - 1);
    quickSort2(arr, pivot + 1, high);
  }
  return arr;
}

    （4）C++

//严蔚敏《数据结构》标准分割函数
 Paritition1(int A[], int low, int high) {
   int pivot = A[low];
   while (low < high) {
     while (low < high && A[high] >= pivot) {
       --high;
     }
     A[low] = A[high];
     while (low < high && A[low] <= pivot) {
       ++low;
     }
     A[high] = A[low];
   }
   A[low] = pivot;
   return low;
 }

 void QuickSort(int A[], int low, int high) //快排母函数
 {
   if (low < high) {
     int pivot = Paritition1(A, low, high);
     QuickSort(A, low, pivot - 1);
     QuickSort(A, pivot + 1, high);
   }
 }

//函数法
sort(a,a + n);// 排序a[0]-a[n-1]的所有数.

//迭代法
// 参考：http://www.dutor.net/index.php/2011/04/recursive-iterative-quick-sort/
struct Range {
    int start, end;
    Range(int s = 0, int e = 0) {
        start = s, end = e;
    }
};
template <typename T> // 整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)、"大於"(>)、"不小於"(>=)的運算子功能
void quick_sort(T arr[], const int len) {
    if (len <= 0)
        return; // 避免len等於負值時宣告堆疊陣列當機
    // r[]模擬堆疊,p為數量,r[p++]為push,r[--p]為pop且取得元素
    Range r[len];
    int p = 0;
    r[p++] = Range(0, len - 1);
    while (p) {
        Range range = r[--p];
        if (range.start >= range.end)
            continue;
        T mid = arr[range.end];
        int left = range.start, right = range.end - 1;
        while (left < right) {
            while (arr[left] < mid && left < right) left++;
            while (arr[right] >= mid && left < right) right--;
            std::swap(arr[left], arr[right]);
        }
        if (arr[left] >= arr[range.end])
            std::swap(arr[left], arr[range.end]);
        else
            left++;
        r[p++] = Range(range.start, left - 1);
        r[p++] = Range(left + 1, range.end);
    }
}

//递归法
template <typename T>
void quick_sort_recursive(T arr[], int start, int end) {
    if (start >= end)
        return;
    T mid = arr[end];
    int left = start, right = end - 1;
    while (left < right) { //在整个范围内搜寻比枢纽元值小或大的元素，然后将左侧元素与右侧元素交换
        while (arr[left] < mid && left < right) //试图在左侧找到一个比枢纽元更大的元素
            left++;
        while (arr[right] >= mid && left < right) //试图在右侧找到一个比枢纽元更小的元素
            right--;
        std::swap(arr[left], arr[right]); //交换元素
    }
    if (arr[left] >= arr[end])
        std::swap(arr[left], arr[end]);
    else
        left++;
    quick_sort_recursive(arr, start, left - 1);
    quick_sort_recursive(arr, left + 1, end);
}
template <typename T> //整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)、"大於"(>)、"不小於"(>=)的運算子功能
void quick_sort(T arr[], int len) {
    quick_sort_recursive(arr, 0, len - 1);
}

    （5）C

typedef struct _Range {
    int start, end;
} Range;

Range new_Range(int s, int e) {
    Range r;
    r.start = s;
    r.end = e;
    return r;
}

void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}

void quick_sort(int arr[], const int len) {
    if (len <= 0)
        return; // 避免len等於負值時引發段錯誤（Segment Fault）
    // r[]模擬列表,p為數量,r[p++]為push,r[--p]為pop且取得元素
    Range r[len];
    int p = 0;
    r[p++] = new_Range(0, len - 1);
    while (p) {
        Range range = r[--p];
        if (range.start >= range.end)
            continue;
        int mid = arr[(range.start + range.end) / 2]; // 選取中間點為基準點
        int left = range.start, right = range.end;
        do {
            while (arr[left] < mid) ++left;   // 檢測基準點左側是否符合要求
            while (arr[right] > mid) --right; //檢測基準點右側是否符合要求
            if (left <= right) {
                swap(&arr[left], &arr[right]);
                left++;
                right--;               // 移動指針以繼續
            }
        } while (left <= right);
        if (range.start < right) r[p++] = new_Range(range.start, right);
        if (range.end > left) r[p++] = new_Range(left, range.end);
    }
}


//递归法
void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}

void quick_sort_recursive(int arr[], int start, int end) {
    if (start >= end)
        return;
    int mid = arr[end];
    int left = start, right = end - 1;
    while (left < right) {
        while (arr[left] < mid && left < right)
            left++;
        while (arr[right] >= mid && left < right)
            right--;
        swap(&arr[left], &arr[right]);
    }
    if (arr[left] >= arr[end])
        swap(&arr[left], &arr[end]);
    else
        left++;
    if (left)
        quick_sort_recursive(arr, start, left - 1);
    quick_sort_recursive(arr, left + 1, end);
}

void quick_sort(int arr[], int len) {
    quick_sort_recursive(arr, 0, len - 1);
}

    （6）C#

public static void Sort(int[] numbers)
{
    Sort(numbers, 0, numbers.Length - 1);
}

private static void Sort(int[] numbers, int left, int right)
{
    if (left < right)
    {
        int middle = numbers[(left + right) / 2];
        int i = left - 1;
        int j = right + 1;
        while (true)
        {
            while (numbers[++i] < middle) ;

            while (numbers[--j] > middle) ;

            if (i >= j)
                break;

            Swap(numbers, i, j);
        }

        Sort(numbers, left, i - 1);
        Sort(numbers, j + 1, right);
    }
}

private static void Swap(int[] numbers, int i, int j)
{
    int number = numbers[i];
    numbers[i] = numbers[j];
    numbers[j] = number;
}

    （7）Go

func qsort(data []int) {
	if len(data) <= 1 {
		return
	}
	mid := data[0]
	head, tail := 0, len(data)-1
	for i := 1; i <= tail; {
		if data[i] > mid {
			data[i], data[tail] = data[tail], data[i]
			tail--
		} else {
			data[i], data[head] = data[head], data[i]
			head++
			i++
		}
	}
	qsort(data[:head])
	qsort(data[head+1:])
}

    （8）PHP

//从尾端取元素作为比较基准
function quick_sort($arr) {
	$len = count($arr);

	if ($len <= 1)
		return $arr;

	$left = $right = array();
	$mid_value = $arr[0];

	for ($i = 1; $i < $len; $i++)
		if ($arr[$i] < $mid_value)
			$left[] = $arr[$i];
		else
			$right[] = $arr[$i];

	return array_merge(quick_sort($left), (array)$mid_value, quick_sort($right));
}

//从正中间取元素作为比较基准
function quick_sort($arr) {
	$len = count($arr);

	if ($len <= 1)
		return $arr;

	$left = $right = array();
	$mid_index = $len>>1;
	$mid_value = $arr[$mid_index];

	for ($i = 0; $i < $len; $i++) {
		if ($i == $mid_index)
			continue;

		if ($arr[$i] < $mid_value)
			$left[] = $arr[$i];
		else
			$right[] = $arr[$i];
	}

	return array_merge(quick_sort($left), (array)$mid_value, quick_sort($right));
}

$arr = array(21, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70);
$arr = quick_sort($arr);
for ($i = 0; $i < count($arr); $i++) {
	echo $arr[$i] . ' ';
}

    （9）Ruby

def quick_sort(array)
  return array if array.size < 2
  left, right = array[1..-1].partition { |y| y <= array.first }
  quick_sort(left) + [array.first] + quick_sort(right)
end

    （10）VB.NET

Public Shared Sub Sort(numbers As Integer())
	Sort(numbers, 0, numbers.Length - 1)
End Sub

Private Shared Sub Sort(numbers As Integer(), left As Integer, right As Integer)
	If left < right Then
		Dim middle As Integer = numbers((left + right) \ 2)
		Dim i As Integer = left - 1
		Dim j As Integer = right + 1 
		While True
			Do
				i+=1
			Loop While numbers(i) <= middle

			Do
				j-=1
			Loop While numbers(j) >= middle

			If i >= j Then
				Exit While
			End If

			Swap(numbers, i, j)
		End While

		Sort(numbers, left, i - 1)
		Sort(numbers, j + 1, right)
	End If
End Sub

Private Shared Sub Swap(numbers As Integer(), i As Integer, j As Integer)
	Dim number As Integer = numbers(i)
	numbers(i) = numbers(j)
	numbers(j) = number
End Sub

 

参考来源：http://www.runoob.com/w3cnote/quick-sort-2.html

GitHub推荐：https://github.com/hustcc/JS-Sorting-Algorithm/blob/master/6.quickSort.md

原文地址：https://zh.wikipedia.org/wiki/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F

holysll
关注
专栏目录
DS排序—快速排序
m0_46914741的博客
10-22 1036
数据结构快速排序
DS排序--快速排序
luoyeliufeng的博客
01-01 715
DS排序–快速排序 题目描述 给出一个数据序列，使用快速排序算法进行从小到大的排序 –程序要求– 若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio 程序中若include多过一个头文件，不看代码，作0分处理 不允许使用第三方对象或函数实现本题的要求 输入 第一行输入t，表示有t个测试示例 第二行输入n，表示第一个示例有n个数据 第三行输入...
Quicksort算法之父——1980年图灵奖获得者查尔斯·霍尔
weixin_34380296的博客
05-26 532
指针就像跳转一样，疯狂地在数据结构之间到处指来指去。在高级语言里面引入指针是个退步。我们可能永远无法从这一失败之中恢复过来。这段话出自查尔斯·霍尔（CharlesA.R.Hoare），1980年他因“对程序设计语言的定义和设计方面的基础性贡献”而获得图灵奖。他26岁就发明了闻名于世的快速排序算法Quicksort。当然，他对计算机科学技术的贡献还远远不止于此，在程序设计语...
[Java算法-排序]快速排序.java
09-07
这份资源提供了Java中如何实现快速排序的全面指南。文档中涵盖了快速排序的基本概念，包括如何对数组进行排序以及如何在Java中实现快速排序。此外，文档还包括一个逐步指南，介绍了如何在Java中实现快速排序，包括...
详解Java常用排序算法-快速排序
08-26
快速排序算法详解 快速排序（Quick Sort）是一种分治思想的排序算法，它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后再分别对这两部分记录继续...
FPGA并行快速排序算法-位宽可设
11-24
在本文中，我们将深入探讨基于FPGA的并行快速排序算法，特别关注“位宽可设”的特性。这种算法能够高效地处理大量数据，并且在硬件实现上具有很高的灵活性。我们将从以下几个方面来阐述这个主题： 一、快速排序算法...
c语言链表的排序算法-排序链表最快的算法是什么？.pdf
04-07
* 不同排序算法的比较：合并排序、快速排序和内置的qsort算法的性能比较。 * 实验结果分析：合并排序和快速排序在链表中的性能远远超过内置的qsort算法。 * 计算机环境对链表排序算法的影响：计算机环境和链表的特点...
算法-数据结构和算法-13-快速排序.rar
09-16
快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出。它的基本思想是分治法（Divide and Conquer），通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的...
Hibernate(HQL、QBC查询)源码
10-20
Hibernate(HQL、QBC查询)源码 Hibernate(HQL、QBC查询)源码 Hibernate(HQL、QBC查询)源码 Hibernate(HQL、QBC查询)源码 Hibernate(HQL、QBC查询)源码
快速排序算法的发明者霍尔
多米学算法的博客
06-26 5376
霍尔介绍 霍尔 (Sir Charles Antony Richard Hoare) 是一位英国计算机科学家，他也是著名的快速排序算法的发明者。他出生于斯里兰卡，1956年毕业于牛津大学。然后的两年里他服役于英国皇家海军，主要工作任务是研究俄国的现代军事，并因为这个原因开始学习俄语。在他结束服役后，他以研究生的身份进入莫斯科大学主攻计算机翻译。在莫斯科学习的一年中，因为偶然的机会他为参加展览的公司Elliott Brothers充当翻译。当他回国后，这家公司立即聘用了他，因为霍尔会俄语的缘故，公司还为..
【DS】排序算法之快速排序（Quick Sort）
weixin_30482181的博客
04-07 478
一、算法思想 快速排序，顾名思义，效率比较于其他算法，效率比较高。《算法导论》也专门对其进行讲解。其算法设计使用分治思想，如下： 1）从数组A[p...r]中选择一个元素，将数组划分成两个子数组：A[p...q-1]和A[q+1...r]，使得A[p...q-1]中的元素全部小于等于A(q)，使得A[q+1...r]中的元素全部大于A(q); 2）通过递归调用快速排序，分别对A[p...
数组的Partition与快速排序
weixin_39350124的博客
03-01 795
数组的Partition与快速排序数组的Partition快速排序没有任何改进的快排稍微改进的快排彻底改进的快排快速排序的时间复杂度分析快速排序的Code 数组的Partition 在数组中取一个数p，把&amp;amp;lt;=p的数都放在左边，&amp;amp;gt;p的数放在右边，数的排序可以是无序的。 流程： 在a[0]之前建一个&amp;amp;lt;=区，i指向a[0] 若a[i] &amp;amp;lt;= p, a[i]与&amp;amp;lt;=区的
partition、快排和随机快排
weixin_42582008的博客
09-18 723
做了《剑指offer》中最小的k个数的题目（详情可见这篇博客https://blog.csdn.net/weixin_42582008/article/details/100937950） 和数组中出现次数超过一半的数字的题目（详情可见这篇博客https://blog.csdn.net/weixin_42582008/article/details/100760644） 都可以用partit...
从partition到Quicksort
m0_47096428的博客
09-22 321
本文主要讨论quicksort和寻找第k大元素的两个相关问题。 力扣连接https://leetcode-cn.com/problems/sort-an-array/【排序算法精华3】快速排序 (上）_哔哩哔哩_bilibili"五点七边-算法学习" QQ交流群：539835344快速排序（英语：Quicksort），简称快排，是一种排序算法，最早由东尼·霍尔提出。正如它的名字所暗示的那样，快速排序的最大优点在于它的速度非常快。在实现的比较好的时候，快速排序往往比归并排序、堆排序等优秀的排序算法更快...
006.归并排序
dosdiosas_的博客
05-09 166
       以下内容参考自Wikipedia #include<iostream> using namespace std; void merge_sort_recursive(int arr[], int reg[], int start, int end) { if (start >= end) return; int len = end - start, mid = (len
快速排序
Turne的博客
09-01 331
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 通俗的来说，就是每次选数组的第一个数作为基数，然后以后的操作就是把在基数右边且小于该基数的数与该基数交换和在基数左边且大于该
快速排序（Quick Sort）及优化
weixin_34268753的博客
05-18 188
原理介绍 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 具体实现 左右指针法 实现说明 代码实现 public static void sort1(int[] arr, int start, int end) { if (s...
数据结构与算法 - 排序
最新发布
09-14
4. 快速排序（Quick Sort）：选取一个基准元素，将数组划分为两个子数组，小于基准元素的放在左边，大于基准元素的放在右边，然后对子数组进行递归排序。时间复杂度平均情况下为O(nlogn)，最坏情况下为O(n^2)。 5. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值