• 算法笔记--快速排序



    快速排序是交换排序的一种,算法效率高,需要额外的辅助空间


    1. 算法思想

              从待排序序列中选取一个元素,以其值作为中间值,把比其小的元素放到左边,比起大的元素放到右边;然后递归地对左、右部分排序,直至每一部分元素个数为1,整个序列有序。

    2. 时间复杂度

              用递归树的思想,每次划分操作的元素总数都是n,因此每次划分的时间复杂度都是O(n),接下来只需考虑划分次数:

              最好情况 O(nlogn):每次都将序列等分为两部分,因此划分次数为logn

              最坏情况 O(n^2):每次都有一部分只分出一个元素,因此划分次数为n

    3. 空间复杂度 O(logn)

              递归调用,考虑递归栈的空间消耗

    4. 稳定性

              不稳定。划分时要跨中轴交换元素,不相邻交换不稳定

    5. 代码实现(C语言)

              划分时有两类方法:

              一种是挖坑法,将A[0]作为中轴值保存到value中,A[0]空出一个坑;先从后往前遍历,遇到不大于value的数A[j],则将A[j]填到A[0]中,A[j]空出一个坑;再从前往后遍历,遇到不小于value的数A[i],则将A[i]填到A[j]中,A[i]空出一个坑。如此循环,直至i、j重合,将value填到这个坑中。

              另一种是交换法,同时从后往前找小于value的A[j],从前往后找不小于value的A[i],然后交换A[i]、A[j];循环直至i、j重合。这种方法在保证重合处的值A[i]小于value,因此递归划分时前半部分要包括A[i]。但是将等于value的值都放到后半部分了,对于有大量相同元素的序列,会因为划分不均匀而导致效率偏低,因此整体看来稍逊一筹。

              为了使中轴值取得更有效,这里采用取序列首、尾、中间元素的中值的方法,代码如下:

    int Adjust(int *A, int low, int high)
    {
    	int ind;
    	int mid = (low + high) / 2;
    	int value = A[low];
    
    	if (A[low] <= A[mid])
    	{
    		ind = A[mid] <= A[high] ?
    			mid : (A[low] <= A[high] ? high : low);
    	}
    	else
    	{
    		ind = A[low] <= A[high] ?
    			mid : (A[mid] <= A[high] ? high : mid);
    	}
    
    	if (ind != low)
    	{
    		value = A[ind];
    		A[ind] = A[low];
    		A[low] = value;
    	}
    
    	return value;
    }
              另外为了接口一致,增加了一个入口函数:

    void QuickSort(int *A, int n)
    {
    	QSort(A, 0, n - 1);
    }

              接下来是快排函数,首先是挖坑版:

    void QSort(int *A, int low, int high)
    {
    	int i, j, value;
    
    	if (low >= high)
    	{
    		return;
    	}
    
    	i = low;
    	j = high;
    	value = Adjust(A, low, high);
    
    	while(i < j)
    	{			
    		while (i < j && A[j] > value)
    		{
    			--j;
    		}
    		
    		if (i < j)
    		{
    			A[i++] = A[j];
    		}
    
    		while (i < j && A[i] < value)
    		{
    			++i;
    		}
    
    		if (i < j)
    		{
    			A[j--] = A[i];
    		}
    	}
    	
    	A[i] = value;
    	QSort(A, low, i - 1);
    	QSort(A, i + 1, high);
    }

    
              再看一下交换版:
    

    void QSort(int *A, int low, int high)
    {
    	int i, j;
    	int tmp, value;
    
    	if (low >= high)
    	{
    		return;
    	}
    
    	i = low;
    	j = high;
    	value = Adjust(A, low, high);
    
    	while (i < j)
    	{
    		while (i < j && A[j] >= value)
    		{
    			--j;
    		}
    
    		while (i < j && A[i] < value)
    		{
    			++i;
    		}
    
    		if (i < j)
    		{
    			tmp = A[i];
    			A[i] = A[j];
    			A[j] = tmp;
    		}
    	}
    
    	QSort(A, low, i);
    	QSort(A, i + 1, high);
    }

  • 相关阅读:
    第二周课程进度
    Codeforces Round #479 (Div. 3) F. Consecutive Subsequence (简单dp)
    Codeforces Round #538 (Div. 2) C. Trailing Loves (or L'oeufs?) (分解质因数)
    Codeforces Round #162 (Div. 1) B. Good Sequences (dp+分解素数)
    Codeforces Round #552 (Div. 3) F. Shovels Shop (前缀和预处理+贪心+dp)
    桂林电子科技大学第三届ACM程序设计竞赛 G 路径
    Codeforces Round #551 (Div. 2) D. Serval and Rooted Tree (树形dp)
    Codeforces Round #324 (Div. 2) (哥德巴赫猜想)
    Codeforces Round #244 (Div. 2) C. Checkposts (tarjan 强连通分量)
    Codeforces Round #207 (Div. 1) A. Knight Tournament (线段树离线)
  • 原文地址:https://www.cnblogs.com/ltxdzh/p/3960146.html
Copyright © 2020-2023  润新知