[算法拾遗]排序算法

最新推荐文章于 2022-08-08 19:10:20 发布
最新推荐文章于 2022-08-08 19:10:20 发布
阅读量1.4k 收藏
点赞数 1
分类专栏： 算法拾遗 文章标签： 算法 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yunduanmuxue/article/details/21403861
版权


[算法拾遗]系列文章主要用以归纳整理一些自己学过的主要算法。


本篇介绍几种主要的排序算法。


排序算法，顾名思义，就是用来对数组进行排序的算法，鉴于其在整个算法研究中的重要地位，很多介绍算法的书籍都是从排序算法开始，笔者也不能免俗。


1. 插入排序（Insert Sort）

这个算法的思路就跟我们玩扑克牌时整理手牌的方式差不多，一个数字一个数字读进来，把新读进来的数字按照其大小放在已读进来的数组中的合适位置。

这是一个对少量元素进行排序的有效算法，数据量较大时并不适用。


2. 归并排序（Merge Sort）

典型的“分而治之”的思想，通过不断的对数据拆半到单一元素后再将拆分后的数据按照大小进行归并整理来实现排序。运行速度比较快（O(nlogn)），但是不是原地排序，比较费内存。


3. 冒泡排序（Bubble Sort）

这个算法，重复走访待排序的序列，每次只比较相邻的元素，让最小或者最大的元素逐步浮向序列的顶端，就跟气泡在水中不断往上冒出来一样。是原地排序，但是算法运行比较慢（O(n^2)），不适合大数据量。


4. 堆排序（Heapsort）

这种排序算法利用了一种叫做堆数据结构，近似于完全二叉树。算法时间复杂度与归并排序一致（O(nlogn)），而且还是一种原地排序算法，运行不会太耗内存。


5. 臭皮匠排序（Stooge Sort）

俗话说“三个臭皮匠，抵过一个诸葛亮”，这个算法就有这种味道，这是一种低效的排序算法，实践中不推荐使用。原理大概就是把数据分成三份，先看前两部分，把大的往后段挤，再对后两段执行同样的操作，最后再一次对前两段进行操作。


6. 快速排序（Quick Sort）

这种算法在实践中被广泛使用，同样采用“分而治之”的方法，不过是分的方法不同而已，就是每次取最后的元素作为分割点，将数据分为比之大和比之小两部分，再对各部分执行相同的操作，直至结束，是二叉查找树的空间优化版本。原地排序，最坏情况不理想（O(n^2)），但是期望速度快（O(nlogn)），实际运行过程常比归并排序和堆排序快。

其优化版本有随机快速排序，就是对上面介绍的分割点随机选取。


7. 计数排序（Counting Sort）

稳定排序算法，要用到额外的数组存取数据，运行速度非常快（O(n)），但是对数据类型有要求，为非负整数。

在这个算法基础上可以得到基数排序算法，这里不多做介绍。

下面是笔者自己写的一个类，包含了上面介绍的所有算法。

// Head  file: libSort.h
// Edited by Sunshy.
// Home page: http://blog.csdn.net/longyindiyi
// 2014.03.16

// Introdution of LIBSORT
//
// Here, I edit a class called libSort, user can use the methods of this class to sort their own data.
// To define a libSort class, the typename of the data and its length must be given.
//
// i.e.
// If the data are in a array, A = [1.2, 1.6, 7.8, 9.0, 100, 0.78],
// then, you can write your code as below:
// libSort<double, unsigned int> Sort;
// since A is a array including double numbers, and its length is 6, which can be represented by a unsigned int variable.
//
// The sort method contained in the library including:
//
// void insertSort(T *A, NUMT start, NUMT end);
// void mergeSort(T *A, NUMT start, NUMT end);
// void bubbleSort(T *A, NUMT start, NUMT end);
// void heapSort(T *A, NUMT start, NUMT end);
// void quickSort(T *A, NUMT start, NUMT end);
// void randomizedQuickSort(T *A, NUMT start, NUMT end);
// void stoogeSort(T *A, NUMT start, NUMT end);
// void countSort(T *A, NUMT k, NUMT start, NUMT end);
//
// the sorted data was save in your input array, namely, A.
// start and end represent the starting and ending index, defining the areas of A that you want to use a sorting operation.
// T and NUMT is the data typename given by you when you define a libSort class, whose meaning is introduced above.
// k in countSort is the maxmum value in your array A, to use this function, please make sure A contains usigned int number only.
//
// To print your data, using
// void printData(T *A, NUMT start, NUMT end);

#ifndef LIBSORT_EDITED_BY_SUN
#define LIBSORT_EDITED_BY_SUN

#include <stdlib.h>
#include <iostream>
#include <limits.h>
#include <cstdlib>
using namespace std;

#define PARENT(i) (i >> 1)
#define LEFT(i) (i << 1)
#define RIGHT(i) ((i << 1) + 1)

template<typename T, typename NUMT> 
class libSort
{
private:

	// Public internal function 

	// Exchage the vlaues of two elements
	void libSort::exchange(T *a, T *b)
	{
		T tmp;
		tmp = *a;
		*a = *b;
		*b = tmp;
	}

	// Function used in merge sort
	void libSort::merge(T *A, NUMT start, NUMT mid, NUMT end)
	{
		NUMT n1 = mid - start + 1;
		NUMT n2 = end - mid;
		T *L = new T[n1 + 1];
		T *R = new T[n2 + 1];
		for(NUMT i = 0; i < n1; i++)
			L[i] = A[start + i];
		for(NUMT j = 0; j < n2; j++)
			R[j] = A[mid + j + 1];
		L[n1] = (numeric_limits<T>::max)();
		R[n2] = (numeric_limits<T>::max)();
		NUMT i = 0;
		NUMT j = 0;
		for(NUMT k = start; k <= end; k++)
		{
			if(L[i] <= R[j])
			{
				A[k] = L[i];
				i = i + 1;
			}
			else
			{
				A[k] = R[j];
				j = j + 1;
			}
		}
		delete []L;
		delete []R;
	}



	// Functions uesd in heap sort
	NUMT heapSize;

	void libSort::maxHeapify(T *A, NUMT i, NUMT start, NUMT end)
	{
		NUMT largest;
		i = i - start;
		NUMT l = LEFT(i);
		NUMT r = RIGHT(i);
		if(l <= heapSize && A[l - 1 + start] > A[i - 1 + start])
		{
			largest = l;
		}
		else
		{
			largest = i;
		}
		if(r <= heapSize && A[r - 1 + start] > A[largest - 1 + start])
		{
			largest = r;
		}
		if(largest != i)
		{
			exchange(&A[i - 1 + start], &A[largest - 1 + start]);
			maxHeapify(A, largest + start, start, end);
		}
	}

	void libSort::buildMaxHeap(T *A, NUMT start, NUMT end)
	{
		heapSize = end - start + 1;
		for(NUMT i = (end - start + 1)/2; i >= 1; i--)
		{
			maxHeapify(A, start + i, start, end);
		}
	}

	// Function used in quickSort

	NUMT libSort::partition(T *A, NUMT start, NUMT end)
	{
		T x = A[end];
		NUMT i = start;
		for(NUMT j = start; j < end; j++)
		{
			if(A[j] <= x)
			{
				exchange(&A[i], &A[j]);
				i++;
			}
		}
		exchange(&A[i], &A[end]);
		return i;
	}

	// Functions used in randomized quickSort

	T libSort::random(T start, T end)
	{
		return start+(end-start)*rand()/(RAND_MAX + 1.0);
	}

	NUMT libSort::randomizedPartition(T *A, NUMT start, NUMT end)
	{
		NUMT i = (NUMT)(random(start, end));
		exchange(&A[end], &A[i]);
		return partition(A, start, end);
	}

public:

    // Construct and deconstruct
	libSort(){};
	~libSort(){};

	// User functions


	/
	//    Insert sort      //
	/

	// Time complexity O(n^2)
	void libSort::insertSort(T *A, NUMT start, NUMT end)
	{
		if(start > end)
			return;
		NUMT n = end;
		for(NUMT j = start + 1; j <= end; j++)
		{
			T key = A[j];
			//Insert A[j] into the sorted sequence A[start + 1 .. j - 1]
			NUMT i = j;
			while(i > start && A[i - 1] > key)
			{
				A[i] = A[i - 1];
				i--;
			}
			A[i] = key;
		}
	}

	/
	//    Merge sort       //
	/

	void libSort::mergeSort(T *A, NUMT start, NUMT end)
	{
		if(start < end)
		{
			int mid = (start + end) / 2;
			mergeSort(A, start, mid);
			mergeSort(A, mid + 1, end);
			merge(A, start, mid, end);
		}
	}

	///
	//  Bubble sort  //
	///

	void libSort::bubbleSort(T *A, NUMT start, NUMT end)
	{
		if(start > end)
			return;
		for(NUMT i = start; i <= end; i++)
		{
			for(NUMT j = end; j >= i + 1; j--)
			{
				if(A[j] < A[j - 1])
				{
					exchange(&A[j], &A[j - 1]);
				}
			}
			printData(A, 10);
		}
	}

	//
	//  heap  sort  //
	//

	void libSort::heapSort(T *A, NUMT start, NUMT end)
	{
		if(start > end)
			return;
		buildMaxHeap(A, start, end);
		for(NUMT i = end - start + 1; i > 1; i--)
		{
			exchange(&A[0 + start], &A[i - 1 + start]);
			heapSize = heapSize - 1;
			maxHeapify(A, 1 + start, start, end);
		}
	}

	//
	//  quick sort  //
	//

	void libSort::quickSort(T *A, NUMT start, NUMT end)
	{
		if(start < end)
		{
			NUMT key = partition(A, start, end);
			if(key != 0)
				quickSort(A, start, key - 1);
			quickSort(A, key + 1, end);
		}
	}

	/
	//  randomized quick sort  //
	/

	void libSort::randomizedQuickSort(T *A, NUMT start, NUMT end)
	{
		if(start < end)
		{
			NUMT key = randomizedPartition(A, start, end);
			if(key != 0)
				randomizedQuickSort(A, start, key - 1);
			randomizedQuickSort(A, key + 1, end);
		}
	}

	/
	//   stooge sort   //
	/

	void libSort::stoogeSort(T *A, NUMT start, NUMT end)
	{
		if(A[start] > A[end])
		{
			exchange(&A[start], &A[end]);
		}
		if(start + 1 >= end)
		{
			return;
		}
		NUMT key = (end - start + 1) / 3; // Round down
		stoogeSort(A, start, end - key);  // First two-third
		stoogeSort(A, start + key, end);  // Last two-third
		stoogeSort(A, start, end - key);  // First two-third again
	}

	//
	//  count sort  //
	//

	void libSort::countSort(NUMT *A, NUMT k, NUMT start, NUMT end)
	{
		if(start >= end)
			return;
		NUMT *C = new NUMT[k + 1];
		NUMT len = end - start + 1;
		NUMT *B = new NUMT[len];
		for(NUMT i = 0; i <= k; i++)
		{
			C[i] = 0;
		}
		for(NUMT i = 0; i < len; i++)
		{
			B[i] = 0;
		}
		for(NUMT j = start; j <= end; j++)
		{
			C[A[j]]++;
		}
		for(NUMT i = 1; i <= k; i++)
		{
			C[i] = C[i] + C[i - 1];
		}
		for(NUMT j = len; j >= 1; j--)
		{
			B[C[A[j - 1 + start]] - 1] = A[j - 1 + start];
			C[A[j - 1 + start]]--;
		}
		for(NUMT i = 0; i <= end - start; i++)
		{
			A[start + i] = B[i];
		}
		delete []C;
		delete []B;
	}

	//
	//  Print data  //
	//

	void libSort::printData(const T *A, NUMT start, NUMT end)
	{
		if(start > end)
			return;
		for(NUMT i = start; i <= end; i++)
		{
			cout<<A[i]<<'\t';
		}
		cout<<'\n';
	}

};

#endif


测试代码如下：

#include <iostream>  
#include "libSort.h"
using namespace std;  
 
#define length(x) (sizeof(x)/sizeof(x[0]))

int main()  
{  
	double A[] = {16, 14, 10, 8, 7, 9, 3, 2, 4, 1};
	libSort<double, unsigned int> B;
	B.insertSort(A, 2, length(A) - 1);
	B.printData(A, 0, length(A) - 1);

	
	libSort<unsigned int, unsigned int> E;

	unsigned int D[] = {2, 3, 4, 1, 0, 1, 2, 3, 4};
	unsigned int *C = new unsigned int[length(D)];
	E.countSort(D, 4, 3, length(D) - 1);
	
	E.printData(D, 0, length(D) - 1);

	delete []C;
	return 0;
}

运行结果如下：







云端暮雪
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现排序算法
ancientmoondjay的博客
04-03 1001
八大排序算法有直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序、基数排序。 今天想把排序算法系统学习一下，所以上网搜索了下排序算法。真是个好家伙，那么多！不怕，一个个学习并用代码实现出来！ 排序算法大体可以分为以下几类： 交换类排序：冒泡排序、鸡尾酒排序、奇偶换位排序、梳子排序、侏儒排序、快速排序、臭皮匠排序 选择类排序：选择排序、堆排序、Smooth排序、笛卡尔树排序
三个臭皮匠顶个诸葛亮的随机森林算法！
weixin_30398227的博客
03-07 244
http://mp.weixin.qq.com/s?__biz=MzIzNDM2OTMzOQ==&mid=2247484211&idx=1&sn=5eb8958f7a87fcbb3992a5226e367445&mpshare=1&scene=23&srcid=0306A97NjBiE9Zsp5GmRJSUt#rd 随机森林一个已被证明了的成...
精妙的Stooge排序算法
Crucifixio's BLOG
03-16 856
精妙的Stooge算法： STOOGE-SORT(A, i, j) {  if A[i] > A[j]      then exchange A[i] and A[j]  if i + 1 >= j      then return  k = (j - i + 1) / 3  STOOGE-SORT(A, i, j - k)         // First two
关于“三个臭皮匠”的思考（一）
dzcs2001的专栏
06-23 629
<br /><br />附键盘记录演示程序<br /> <br />本文无意危害他人信息系统安全，如果内容有不宜公开发表的情况，请版主及时删除。<br />一、   开发一个软件，实现功能：在下班时间以后，如果指定时间内没有键盘鼠标操作，就自动关机。于是对键盘鼠标操作进行记录，为了保证输入密码时不会意外关机，对密码也进行记录。所有记录信息存到一个日志文件中，当软件出错时便于调试。为了保证记录信息不会被用于不正当的目的，对记录信息进行简单的压缩和加密。<br />二、   开发一个软件，实现功能：在下班前，把
几种有趣的不常见排序
ice110956的专栏
09-29 3232
几种有趣的不常见排序算法 我们常见的排序算法有简单选择，冒泡，插入，两路合并，希尔，堆，快速排序等等，下面介绍几种有趣的不常见的排序算法。 如：鸡尾酒排序,鸽巢排序,奇偶排序,梳排序,臭皮匠排序,图书馆排序,bogo排序等等。
数据排序算法.docx
最新发布
07-22
### 数据排序算法详解 #### 一、概述 排序算法作为数据结构与算法分析中的核心内容之一，被广泛应用于计算机科学的各个领域。根据处理数据的方式不同，排序算法大致可以分为两类：内部排序算法和外部排序算法。 #...
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
java实现桶排序算法
06-14
在该示例代码中，我们将桶的数量设为数组长度，桶的索引由元素的...将元素分配到不同的桶中后，对每个桶进行排序，可以选择使用简单的排序算法如插入排序。最后，按照桶的顺序将元素取出放回原始数组，完成桶排序过程。
实验十 排序算法1
08-03
在计算机科学中，排序算法是数据处理的重要组成部分，它们用于将一组无序的数据按照特定顺序进行排列。本实验主要关注三种经典的排序算法：冒泡排序、选择排序和快速排序，通过对这些算法的理解、实现和分析，可以...
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
算法：臭皮匠排序
OceanStar的博客
08-05 1311
在《算法导论》第二版第 7 章（快速排序）的思考题（第 95 页）中提及到一种 低效的递归排序算法：Stooge 排序， Howard、Fine 等教授将这个算法称为 漂亮排序算法（完美排序算法）。 经过证明，Stooge 排序的性能是慢于冒泡排序的，因为这个，在《算法导论》中作者悄悄的 “diss” 了一下这几位终生教授，“怀疑”他们是否“名副其实”。 顾名思义， 漂亮排序算法 它的代码实现 看、上、去 很整齐很好看！ private static void stoogeSort(int[] A, i
鸡尾酒排序Cocktail Sort(排序算法九)
赵侠客
10-24 2241
1.算法原理  2.代码实现 #include //printArray打印出数组 void printArray(int a[],int size){ printf("数组为：[%d] ",a[0]); for (int i=1;i<size;i++) { printf(" %x ",a[i]); }
C++模板快速排序和Stooge排序
上善若水
03-29 848
快速排序和Stooge排序
Python:实现stooge sort臭皮匠排序算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-08 177
Python:实现stooge sort臭皮匠排序算法(附完整源码)
臭皮匠排序
tan_1208815066的专栏
08-11 829
import java.math.* ; import java.util.* ; /** * */ public class Test extends Base{ public static void main(String[] args) throws Exception{ int[] arr = getRandomArr() ; println(arr); stoo
你知道什么是漂亮排序法吗？哦，知道，不就是臭皮匠排序法嘛！
程序员吴师兄的博客
06-04 369
在《算法导论》第二版第 7 章（快速排序）的思考题（第 95 页）中提及到一种 低效的递归排序算法：Stooge 排序， Howard、Fine 等教授将这个算法称为 漂...
排序高级之交换排序_臭皮匠排序
Benjamin
01-06 2577
Stooge 排序是一种低效的递归排序算法，甚至慢于冒泡排序。在《算法导论》第二版第7章（快速排序）的思考题中被提到，是由Howard、Fine等教授提出的所谓“漂亮的”排序算法。 该算法得名于三个臭皮匠，每个臭皮匠都打其他两个 实现 如果最后一个值小于第一个值，则交换这两个数如果当前集合元素数量大于等于3： 使用臭皮匠排序前2/3的元素使用臭皮
浅谈 Adaboost 算法
热门推荐
haidao2009的专栏
04-26 19万+
菜鸟最近开始学习machine learning。发现adaboost 挺有趣，就把自己的一些思考写下来。 主要参考了http://stblog.baidu-tech.com/?p=19，其实说抄也不为过，但是我添加了一些我认为有意思的东西，所以我还是把它贴出来了，呵呵。 一 Boosting 算法的起源 boost 算法系列的起源来自于PAC Learnability(PAC 可学习性)。
基于分治策略的排序算法实现
快速排序算法也是一种基于分治策略的排序算法。它的基本思想是选择一个ivot元素，然后将待排序序列分成两个部分，一部分元素小于ivot，另一部分元素大于ivot。然后，对这两个部分分别进行快速排序，直到整个序列排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值