c++十大排序之快速排序

发布于:2023-01-20 ⋅ 阅读:(20) ⋅ 点赞:(0) ⋅ 评论:(0)


活动地址:CSDN21天学习挑战赛

正文

  • At first,我们先look一张我从某文章*的表格,来了解一下这几大算法
    alt

  • 图都看了,那我也不得不提一嘴,图里面的东西了

    • 算法效率
      在一个算法设计完成后,还需要对算法的执行情况做一个评估。一个好的算法,可以大幅度的节省运行的资源消耗和时间。在进行评估时不需要太具体,毕竟数据量是不确定的,通常是以数据量为基准来确定一个量级,通常会使用到时间复杂度和空间复杂度这两个概念。

    • 时间复杂度
      通常把算法中的基本操作重复执行的频度称为算法的时间复杂度。算法中的基本操作一般是指算法中最深层循环内的语句(赋值、判断、四则运算等基础操作)。我们可以把时问频度记为T(n),它与算法中语句的执行次数成正比。其中的n被称为问题的规模,大多数情况下为输入的数据量。

      对于每一段代码,都可以转化为常数或与n相关的函数表达式,记做f(n)。如果我们把每一段代码的花费的时间加起来就能够得到一个刻画时间复杂度的表达式,在合并后保留量级最大的部分即可确定时间复杂度,记做O(f(n)),其中的O就是代表数量级。
      常见的时间复杂度有(由低到高): O(1)、O(log2 n)、O(n)、O(n log2n)、O(n2)、o(n3)、O(2")、O(nl)。

    • 空间复杂度

    程序从开始执行到结束所需要的内存容量,也就是整个过程中最大需要占用多少的空间。为了评估算法本身,输入数据所占用的空间不会考虑,通常更关注算法运行时需要额外定义多少临时变量或多少存储结构。如:如果需要借助一个临时变量来进行两个元素的交换,则空间复杂度为O(1).

时间复杂度与空间复杂度的分类

时间复杂度

  • 最坏的情况
    最坏的情况莫过于,完整的遍历了整个集合,也没有找到需要找的的元素,循环执行次数与n相关,所以时间复杂度为O(n).

  • 最好的情况
    第一次循环便找到了元素,则时间复杂度为常数级O(1);

  • 平常的情况
    综合两种情况,顺序查找的时间复杂度为O(n),属于查找较慢的算法。

空间复杂度

算法不会改变原有的元素集合,只需要一个额外的变量控制索引变化,所以空间复杂度为常数级:O(1)。

快速排序

  • 快速排序的核心思想也是分治法,分而治之。它的实现方式是每次从序列中选出一个基准值,其他数依次和基准值做比较,比基准值大的放右边,比基准值小的放左边,然后再对左边和右边的两组数分别选出一个基准值,进行同样的比较移动,重复步骤,直到最后都变成单个元素,整个数组就成了有序的序列。

上图(借的):
alt

(小数,基准元素,大数)。在区间中随机挑选一个元素作基准,将小于基准的元素放在基准之前,大于基准的元素放在基准之后,再分别对小数区与大数区进行排序。

快速排序思路:

  • 选取第一个数为基准
  • 将比基准小的数交换到前面,比基准大的数交换到后面
    - 对左右区间重复第二步,直到各区间只有一个数
    快速排序的时间复杂度和归并排序一样,O(n log n),但这是建立在每次切分都能把数组一刀切两半差不多大的前提下,如果出现极端情况,比如排一个有序的序列,如[ 9,8,7,6,5,4,3,2,1 ],选取基准值 9 ,那么需要切分 n – 1 次才能完成整个快速排序的过程,这种情况下,时间复杂度就退化成了 O(n^2),当然极端情况出现的概率也是比较低的。

所以说,快速排序的时间复杂度是 O(nlogn),极端情况下会退化成 O(n^2),为了避免极端情况的发生,选取基准值应该做到随机选取,或者是打乱一下数组再选取。

另外,快速排序的空间复杂度为 O(1)。

讲解

我们对一下是个数进行快速排序操作:
alt

  • 首先在这个序列中随便选择一个数作为基准数,
    这里我们为了方便就选1,作为基准数。
    alt

  • 在初始状态下,数字1在序列的第1位。我们的目标是将1挪到序列中间的某个位置,假设这个位置是 k 。现在就需要寻找这个 k ,并且以第k位为分界点,k左边的数都 ≤ 1,k,右边的数都 ≥ 1。那么如何找到这个位置 k 呢?

  • 我们知道,快速排序其实是冒泡排序的一种改进,冒泡排序每次对相邻的两个数进行比较,这显然是一种比较浪费时间的。会大大提高循环次数。

  • 而快速排序是分别从两端开始”检测”的,先从右往左找一个小于1的数,再从左往右找一个大于1的数,然后交换他们。这里可以用两个变量 i 和 j,分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“门神i”和“门神j”。刚开始的时候让门神1指向序列的最左边,指向数字1。让门神j指向序列的最右边,指向数字2。

alt
然后依次如此交换位置进行排序,直到运行完成

void QuickSort(vector<int>& v, int low, int high) {
	if (low >= high)		// 结束标志
		return;
	int first = low;		// 低位下标
	int last = high;		// 高位下标
	int key = v[first];		// 设第一个为基准

	while (first < last)
	{
		// 将比第一个小的移到前面
		while (first < last && v[last] >= key)
			last--;
		if (first < last)
			v[first++] = v[last];

		// 将比第一个大的移到后面
		while (first < last && v[first] <= key)
			first++;
		if (first < last)
			v[last--] = v[first];
	}
	// 基准置位
	v[first] = key;
	// 前半递归
	QuickSort(v, low, first - 1);
	// 后半递归
	QuickSort(v, first + 1, high);
}
    if(begin > end)
        return;
    int tmp = arr[begin];
    int i = begin;
    int j = end;
    while(i != j){
        while(arr[j] >= tmp && j > i)
            j--;
        while(arr[i] <= tmp && j > i)
            i++;
        if(j > i){
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }
    arr[begin] = arr[i];
    arr[i] = tmp;
    Quick_Sort(arr, begin, i-1);
    Quick_Sort(arr, i+1, end);
}


public class QuickSort {
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];
 
        while (i<j) {
            //先看右边,依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边,依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
 
        }
        //最后将基准为与i和j相等位置的数字交换
         arr[low] = arr[i];
         arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }
 
 
    public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

伪代码

parttitioned (input list[], input left, input right)
	pivot <- list[left]
	i <- left
	j <- right
	while (i < j) do
		whlie (i < j and list[j] >= pivot) do
			j <- j - 1
		end
		if (i < j)
			list[i] <- list [j]
		
		whlie (i < j and list[i] < pivot) do
			i <- i + 1
		end
		if (i < j)
			list[j] <- list [i]
	end
	list[i] <- pivot
	return i

quicksort (input list[], input left, input right)
	if (left < right)
		mid = parttitioned(list, left, left)
		quicksort (list, left, mid-1)
		quicksort (list, mid+1, right)
	end if

网站公告

欢迎关注微信公众号

今日签到

点亮在社区的每一天
签到