经典排序算法之bin排序

原创 2013年12月04日 23:28:51

bin排序,顾名思义就是把对象放在盒子里进行排序,盒子本身已经代表了大小,所以,只要把对象放在对应的盒子,即可看做完成了排序,其排序时间复杂度为O(n)可以说是一种较为快捷的排序,然而,由于不是本地排序,所以空间复杂度较高。

结合链表特性,将bin排序放在了链表里面如下:

.h

#include <stdio.h>
#include <cassert>

template<typename T>
class CLinearLink;

template<typename T>
struct SNode
{
friend CLinearLink<T>;
private:
	T m_nData;
	SNode<T>* m_pNext;
public:
	SNode();
	SNode(T data);
	~SNode();
};

template <typename T>
class CLinearLink{
private:
	// Data;
	SNode<T>* m_pHead;
public:
	// constructors;
	CLinearLink();
	~CLinearLink();
	// methods;
	CLinearLink<T>& mInsert(const int& k, const T& data);
	CLinearLink<T>& mDelete(const int& k, T& data);
	bool mFind(const int& k, T& data) const;
	int mSearch(const T& data);
	
	void mBinSort(const int& range);
}; 
template<typename T>
SNode<T>::SNode():
	m_pNext(NULL){}


template<typename T>
SNode<T>::SNode(T data):
	m_nData(data),m_pNext(NULL){}

template<typename T>
SNode<T>::~SNode() {}


// defination;
// constructors;
template<typename T>
CLinearLink<T>::CLinearLink():
    m_pHead(NULL){} 

template<typename T>
CLinearLink<T>::~CLinearLink(){
	SNode<T>* pTmp = NULL;
	while(m_pHead){
	       pTmp = m_pHead;
           m_pHead = m_pHead -> m_pNext;
	       delete pTmp;
	       pTmp = NULL;
	}
}
// methods;
// Insert;
template<typename T>
CLinearLink<T>& CLinearLink<T>::mInsert(const int& k, const T& data){
	assert(k >=0);
	SNode<T>* pPre = m_pHead;
	for(int i = 1; i < k && pPre; i ++)
		pPre = pPre -> m_pNext;
	SNode<T>* pInsert = new SNode<T>(data);
	if(k > 0 && (pPre != NULL)){
		pInsert -> m_pNext = pPre -> m_pNext;
		pPre -> m_pNext = pInsert;
	}else{
        pInsert -> m_pNext = m_pHead;
		m_pHead = pInsert;
	}
	return *this;
}

// methods;
// Delete;
template<typename T>
CLinearLink<T>& CLinearLink<T>::mDelete(const int& k, T& data){
	assert(k > 0 && m_pHead != NULL);
    SNode<T>* pPre = m_pHead;
    // delete about head;
	SNode<T>* pDelete = m_pHead;
	if(1 == k)
		m_pHead = m_pHead -> m_pNext;
	else{
		for(int i = 1; i < k - 1 && (pPre != NULL); i ++){
		    pPre = pPre -> m_pNext; 
		}
        assert(pPre && pPre->m_pNext);
		pDelete = pPre -> m_pNext;
		pPre -> m_pNext = pDelete -> m_pNext;
	}
	data = pDelete ->m_nData;
	delete pDelete;
	return *this;
}

// methods;
// Find;
	//bool mFind(const int& k, T& data) const;
template<typename T>
bool CLinearLink<T>::mFind(const int& k, T& data) const{
	SNode<T>* pTmp = m_pHead;
	assert(k > 0 && k <= m_nLength);
    int i = 1;
	while( i < k && pTmp != NULL){
		pTmp = pTmp -> m_pNext;
		i ++;
	}
    if(NULL != pTmp -> m_pNext)
		pTmp->m_nData = data;
	else
		return false;
	return true;
}

template<typename T>
int CLinearLink<T>::mSearch(const T& data){
    int i = 1;
	SNode<T>* pTmp = m_pHead;
	while(pTmp){

		if(pTmp->m_nData == data)
			return i;
        pTmp = pTmp -> m_pNext;
		i ++;
	}
	return -1;
}

// binSort;
template<typename T>
void CLinearLink<T>::mBinSort(const int& range){
	// pBegins records the beginning of each bin;
    SNode<T>** pBegins = new SNode<T>*[range + 1]; 
	// pEnds records the ends of each bin;
	SNode<T>** pEnds = new SNode<T>*[range + 1];
    
	for(int i = 0; i <= range; i++)
		pBegins[i] = NULL;
    SNode<T>* pTmp = m_pHead;
	for(; pTmp; pTmp = pTmp -> m_pNext){
		int data = pTmp -> m_nData; 
		// pBegins is NULL means the bin is empty;
		if(pBegins[data]){
			pEnds[data] -> m_pNext = pTmp;
			pEnds[data] = pTmp;
		}else
			pBegins[data] = pEnds[data] = pTmp;
	}
	// collect into a new link using the thought of bin sort;
	pTmp = NULL;
    for(int i = 0; i < range; i ++){
		if(pBegins[i]){
			if(pTmp)
				pTmp -> m_pNext = pBegins[i];
			// if pTmp is NULL, that must be the 0th bin ;
			else
				m_pHead = pBegins[i];
		    pTmp = pEnds[i];
		}
	}
	if(pTmp)
		pTmp -> m_pNext = NULL;	
	delete [] pBegins;
	delete [] pEnds;
}

bin排序可以轻易扩展为基排序,即是在保证元素相对位置的情况下,分别对末位,倒数第二位。。。第一位进行bin排序。

C语言8大经典排序算法代码和详细注释

冒泡排序 void bubbleSort(int *a, int an) { //从i开始排,总是在[i+1,nsize]去寻找比当前元素小的,并且交换,使得当前位置的值总是其后面最小...
  • washCutBlow
  • washCutBlow
  • 2017年05月03日 17:12
  • 388

C/C++十大经典排序算法之希尔排序

 声明: 1、读者莫要看到大量的代码就晕头,其实核心的语句就那么几句,详细请看代码说明 2、关于希尔排序相关概念及文字描述,请百度百科 代码说明: 1、小编为了方便监...
  • RicardoMTan
  • RicardoMTan
  • 2017年04月28日 00:31
  • 336

java的几种经典排序算法

最近闲着没事,就想研究下java的数据结构,现在就从最简单的排序算法开始吧。大二的时候上过数据结构这门课,系统的学习过排序算法,但是当时老师讲的都是理论,真正的实现没有搞过,心里老师觉得空空的,所以趁...
  • playboyanta123
  • playboyanta123
  • 2012年07月09日 16:28
  • 8754

八大经典排序算法基本思想及代码实现(插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序,基数排序)

一.插入排序——简单插入排序基本思想:每步将一个待排序的纪录,按其关键码值的大小插入前面已经排序的文件中适当位置上,直到全部插入完为止。def insertSort(arr): if len(...
  • qq_34342154
  • qq_34342154
  • 2017年07月26日 12:56
  • 426

剖析八种经典排序算法

排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个关键字有序的序列。 我整理了以前自己所写的一些排序算法结合网上的一些资料,共...
  • l953972252
  • l953972252
  • 2016年04月29日 23:50
  • 1897

七种经典排序算法最全攻略

经典排序算法在面试中占有很大的比重,也是基础。包括冒泡排序,插入排序,选择排序,希尔排序,归并排序,快速排序,堆排序。希望能帮助到有需要的同学。全部程序采用JAVA实现。 本篇博客所有排序实现均默认...
  • ls5718
  • ls5718
  • 2016年07月02日 10:10
  • 3390

冒泡法排序-经典排序算法

原理: 是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子例子:...
  • fendoubasaonian
  • fendoubasaonian
  • 2016年03月03日 21:24
  • 242

深度剖析八大经典排序算法—C++实现(通俗易懂版)

内容会持续更新,有错误的地方欢迎指正,谢谢! 引言 该博客的示例代码均以递增排序为目的~ 学习建议:切忌看示例代码去理解算法,而是理解算法原理写出代码,否则会很快就会忘记。 //排序原...
  • BillCYJ
  • BillCYJ
  • 2017年11月06日 19:45
  • 407

笔试面试中关于排序算法看这里就够了

排序算法应该是我们最为熟悉的算法,从最基础的《数据结构与算法》到《算法导论》都有涉及。在笔试和面试中,基本上都会有所涉及,统计百度、阿里、腾讯的近三年的算法、研发的笔试题中都有对排序算法的考察。虽然实...
  • hitxueliang
  • hitxueliang
  • 2016年07月31日 12:05
  • 2272

十大排序算法(java实现)

十大常用排序算法(java实现)
  • qq_21688757
  • qq_21688757
  • 2016年12月19日 21:24
  • 3147
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:经典排序算法之bin排序
举报原因:
原因补充:

(最多只允许输入30个字)