#ifndef CHAINLIST_H_
#define CHAINLIST_H_
#include <iostream>
#include "LinearList.h"
using namespace std;
template <class T> class Chain;
template <class T> class ChainIterator;
template <class T> class CircularList;
template <class T>
class ChainNode
{
friend Chain<T>;
friend ChainIterator<T>;
friend CircularList<T>;
public:
protected:
private:
T m_Data;
ChainNode<T>* m_Link;
};
//单向链表
template <class T>
class Chain
{
friend ChainIterator<T>;
public:
Chain(){ m_cnFirst = 0; m_cnLast = 0;};
Chain(const Chain<T>& cValue);
~Chain();
void Max(T& nValue);
bool IsEmpty() const { return m_cnFirst==0; }
int Length() const;
bool Find(int nIndex,T& nValue) const;
int Search(const T& nValue) const;
Chain<T>& Delete(int nIndex,T& nValue);
Chain<T>& Insert(int nIndex,const T& nValue);
void OutPut(ostream& out) const;
void Erase();
void Zero() { m_cnFirst=0; };
Chain<T>& Append(const T& nValue);
void FromLinearList(const LinearList<T>& llValue);
void ToLinearList(LinearList<T>& llValue);
void Reverse();
Chain<T>& Alternate(Chain<T>& cValueA,Chain<T>& cValueB);
Chain<T>& AlternateEx(Chain<T>& cValueA,Chain<T>& cValueB);
Chain<T>& Merge(Chain<T>& cValueA,Chain<T>& cValueB);
void Split(Chain<T>& cValueA,Chain<T>& cValueB);
void InsertionSort();
void BubbleSort();
void BinSort(int nRange);
void BinSortEx(int nRange,int (*Value)(T& nValue));
void RadixSort(int nRadix,int nCount);//基数排序
protected:
private:
ChainNode<T>* m_cnFirst;//第一个节点指针
ChainNode<T>* m_cnLast;
};
template <class T>
class ChainIterator
{
public:
T* Initialize(const Chain<T>& cValue)
{
m_cnLocation = cValue.m_cnFirst;
if (m_cnLocation) {
return &m_cnLocation->m_Data;
}
return 0;
}
T* Next(){
if (!m_cnLocation) {
return 0;
}
m_cnLocation = m_cnLocation->m_Link;
if (m_cnLocation) {
return &m_cnLocation->m_Data;
}
return 0;
}
protected:
private:
ChainNode<T>* m_cnLocation;
};
#endif
#include "ChainList.h"
#include "xcept.h"
#include <cmath>
/************************************************************************
Function:复制构造函数
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>::Chain(const Chain<T>& nValue)
{
ChainNode<T> *cnNewNode;
ChainNode<T> *cnNext;
ChainIterator<T> *ciIterator = new ChainIterator<T>;
T *tValue;
int nLength = nValue.Length();
if (nValue.IsEmpty()) {
m_cnFirst = 0;
m_cnLast = 0;
}else{
cnNewNode = new ChainNode<T>;
m_cnFirst = cnNewNode;
m_cnFirst->m_Data = *(ciIterator->Initialize(nValue));
cnNext = m_cnFirst;
cnNext->m_Data = m_cnFirst->m_Data;
cnNewNode = 0;
tValue = ciIterator->Next();
while (tValue) {
cnNewNode = new ChainNode<T>;
cnNext->m_Link = cnNewNode;
cnNext = cnNewNode;
cnNext->m_Data = *tValue;
cnNewNode = 0;
tValue = ciIterator->Next();
}
cnNext->m_Link = 0;
m_cnLast = cnNext;
}
}
/************************************************************************
Function:析构函数
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>::~Chain()
{
ChainNode<T>* Next;
if (m_cnFirst) {
Next = m_cnFirst->m_Link;
delete m_cnFirst;
m_cnFirst = Next;
}
}
/************************************************************************
Function:将LinearList转换成ChainList
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::FromLinearList(const LinearList<T>& llValue)
{
Erase();
int nIndex,nLength = llValue.Length();
T temp;
for (nIndex = 1;nIndex <= nLength;nIndex++) {
if (llValue.Find(nIndex,temp)) {
Append(temp);
}
}
}
/************************************************************************
Function:将ChainList转换成LinearList
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::ToLinearList(LinearList<T>& llValue)
{
ChainNode<T>* cnCurrent = m_cnFirst;
int nIndex = 0;
while (cnCurrent) {
llValue.Insert(nIndex,cnCurrent->m_Data);
cnCurrent = cnCurrent->m_Link;
nIndex++;
}
}
/************************************************************************
Function:反序
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::Reverse()
{
ChainNode<T> *cnCurrent,*cnNext,*cnLast;
cnCurrent = m_cnFirst;
m_cnLast = m_cnFirst;
cnNext = cnCurrent->m_Link;
cnCurrent->m_Link = 0;
if (cnNext) {
while (cnNext->m_Link) {
cnLast = cnNext->m_Link;
cnNext->m_Link = cnCurrent;
cnCurrent = cnNext;
cnNext = cnLast;
}
if (!cnNext->m_Link) {
cnNext->m_Link = cnCurrent;
}
}
m_cnFirst = cnNext;
}
/************************************************************************
Function:确定表长
Parameter:
Return:
************************************************************************/
template <class T>
int Chain<T>::Length() const
{
ChainNode<T>* nCurrent = m_cnFirst;
int nLength = 0;
while (nCurrent) {
nLength++;
nCurrent = nCurrent->m_Link;
}
return nLength;
}
/************************************************************************
Function:寻找表中第nIndex个元素,并放入nValue中
Parameter:
Return:
************************************************************************/
template <class T>
bool Chain<T>::Find(int nIndex,T& nValue) const
{
if (nIndex<1) {
return false;
}
ChainNode<T>* nCurrent = m_cnFirst;
int Index = 1;
while (Index<nIndex&&nCurrent) {
nCurrent = nCurrent->m_Link;
Index++;
}
if (nCurrent) {
nValue = nCurrent->m_Data;
return true;
}
return false;
}
/************************************************************************
Function:在链表中搜索
Parameter:
Return:
************************************************************************/
template <class T>
int Chain<T>::Search(const T& nValue) const
{
ChainNode<T>* nCurrent = m_cnFirst;
int Index = 1;
while (nCurrent&&nCurrent->m_Data!=nValue) {
nCurrent = nCurrent->m_Link;
Index++;
}
if (nCurrent) {
return Index;
}
return 0;
}
/************************************************************************
Function:输出
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::OutPut(ostream& out) const
{
ChainNode<T>* nCurrent = m_cnFirst;
while (nCurrent) {
out << nCurrent->m_Data << " ";
nCurrent = nCurrent->m_Link;
}
}
/************************************************************************
Function:删除nIndex元素
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>& Chain<T>::Delete(int nIndex,T& nValue)
{
int Index;
if (nIndex<1||!m_cnFirst) {
throw OutOfBounds();//越界
}
ChainNode<T>* cnCurrent = m_cnFirst;
if (nIndex==1) {
m_cnFirst = m_cnFirst->m_Link;//删除
}else{
ChainNode<T>* cnNext = m_cnFirst;
for (Index = 1;Index < nIndex - 1&&cnNext;Index++) {
cnNext = cnNext->m_Link;
}
if (!cnNext||!cnNext->m_Link) {
throw OutOfBounds();
}
cnCurrent = cnNext->m_Link;
if (cnCurrent == m_cnLast) {
m_cnLast = cnNext;
}
cnNext->m_Link = cnCurrent->m_Link;
}
nValue = cnCurrent->m_Data;
delete cnCurrent;
cnCurrent = 0;
return *this;
}
/************************************************************************
Function:在nIndex元素后插入新元素
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>& Chain<T>::Insert(int nIndex,const T& nValue)
{
int Index;
if (nIndex<0) {
throw OutOfBounds();
}
ChainNode<T>* cnCurrent = m_cnFirst;
for (Index = 1;Index < nIndex && cnCurrent; Index++) {
cnCurrent = cnCurrent->m_Link;
}
if (nIndex > 0 && !cnCurrent) {
throw OutOfBounds();
}
ChainNode<T> *cnNewNode = new ChainNode<T>;
cnNewNode->m_Data = nValue;
if (nIndex) {
cnNewNode->m_Link = cnCurrent->m_Link;
cnCurrent->m_Link = cnNewNode;
}else{
cnNewNode->m_Link = m_cnFirst;
m_cnFirst = cnNewNode;
}
if (!cnNewNode->m_Link) {
m_cnLast = cnNewNode;
}
return *this;
}
/************************************************************************
Function:擦除所有节点
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::Erase()
{
ChainNode<T>* cnNext = m_cnFirst;
while (m_cnFirst) {
cnNext = m_cnFirst->m_Link;
delete m_cnFirst;
m_cnFirst = cnNext;
}
}
/************************************************************************
Function:尾部插入
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>& Chain<T>::Append(const T& nValue)
{
ChainNode<T>* cnNewNode = new ChainNode<T>;
cnNewNode->m_Data = nValue;
cnNewNode->m_Link = 0;
if (m_cnFirst) {
m_cnLast->m_Link = cnNewNode;
m_cnLast = cnNewNode;
}else{
m_cnFirst = m_cnLast = cnNewNode;
}
return *this;
}
/************************************************************************
Function:轮流合并
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>& Chain<T>::Alternate(Chain<T>& cValueA,Chain<T>& cValueB)
{
T temp;
ChainNode<T> *cnCurrent,*cnNext;
int nMinLen = min(cValueA.Length(),cValueB.Length());
int nIndex;
cnCurrent = new ChainNode<T>;
m_cnFirst = cnCurrent;
for (nIndex = 0;nIndex < nMinLen;nIndex++) {
cValueA.Find(nIndex+1,temp);
cnCurrent->m_Data = temp;
cnNext = 0;
cnNext = new ChainNode<T>;
cnCurrent->m_Link = cnNext;
cnCurrent = cnNext;
cnNext = 0;
cValueB.Find(nIndex+1,temp);
cnCurrent->m_Data = temp;
cnNext = new ChainNode<T>;
cnCurrent->m_Link = cnNext;
m_cnLast = cnCurrent;
cnCurrent = cnNext;
}
if ((cValueA.Length()) < cValueB.Length()) {
for (nIndex = nMinLen; nIndex < cValueB.Length();nIndex++) {
cnNext = 0;
cValueB.Find(nIndex+1,temp);
cnCurrent->m_Data = temp;
cnNext = new ChainNode<T>;
cnCurrent->m_Link = cnNext;
m_cnLast = cnCurrent;
cnCurrent = cnNext;
}
}else if (cValueA.Length()>cValueB.Length()) {
for (nIndex = nMinLen; nIndex < cValueA.Length();nIndex++) {
cnNext = 0;
cValueA.Find(nIndex+1,temp);
cnCurrent->m_Data = temp;
cnNext = new ChainNode<T>;
cnCurrent->m_Link = cnNext;
m_cnLast = cnCurrent;
cnCurrent = cnNext;
}
}
m_cnLast->m_Link = 0;
delete cnNext;
return *this;
}
/************************************************************************
Function:轮流合并,AB变空表
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>& Chain<T>::AlternateEx(Chain<T>& cValueA,Chain<T>& cValueB)
{
ChainNode<T> *cnCurrentA,*cnCurrentB,*cnCurrentC;
cnCurrentA = cValueA.m_cnFirst;
cnCurrentB = cValueB.m_cnFirst;
Erase();//清除本表
if (!cnCurrentA&&!cnCurrentB) {//两张空表
m_cnFirst = m_cnLast = 0;
return *this;
}
if (!cnCurrentA) {//A表空
m_cnFirst = cValueB.m_cnFirst;
m_cnLast = cValueB.m_cnLast;
cValueB.m_cnFirst = 0;
cValueB.m_cnLast = 0;
return *this;
}
if (!cnCurrentB) {//B表空
m_cnFirst = cValueA.m_cnFirst;
m_cnLast = cValueA.m_cnLast;
cValueA.m_cnFirst = 0;
cValueA.m_cnLast = 0;
return *this;
}
int nMinLen = min(cValueA.Length(),cValueB.Length());
int nIndex;
m_cnFirst = cnCurrentA;
for (nIndex = 0;nIndex < nMinLen;nIndex++) {
cnCurrentC = cnCurrentA;
cnCurrentA = cnCurrentA->m_Link;
cnCurrentC->m_Link = cnCurrentB;
cnCurrentB = cnCurrentB->m_Link;
cnCurrentC = cnCurrentC->m_Link;
cnCurrentC->m_Link = cnCurrentA;
}
if (cnCurrentA) {//链表
m_cnLast = cValueA.m_cnLast;
}else if(cnCurrentB) {
cnCurrentC->m_Link = cnCurrentB;//cnCurrentA 为空
m_cnLast = cValueB.m_cnLast;
}else{
m_cnLast = cValueB.m_cnLast;
}
cValueB.m_cnFirst = cValueB.m_cnLast = 0;
cValueA.m_cnFirst = cValueA.m_cnLast = 0;
return *this;
}
/************************************************************************
Function:有序合并
Parameter:
Return:
************************************************************************/
template <class T>
Chain<T>& Chain<T>::Merge(Chain<T>& cValueA,Chain<T>& cValueB)
{
ChainNode<T> *cnCurrent,*cnCurrentA,*cnCurrentB;
cnCurrentA = cValueA.m_cnFirst;
cnCurrentB = cValueB.m_cnFirst;
Erase();//清除本表
if (!cnCurrentA&&!cnCurrentB) {//两张空表
m_cnFirst = m_cnLast = 0;
return *this;
}
if (!cnCurrentA) {//A表空
m_cnFirst = cValueB.m_cnFirst;
m_cnLast = cValueB.m_cnLast;
cValueB.m_cnFirst = 0;
cValueB.m_cnLast = 0;
return *this;
}
if (!cnCurrentB) {//B表空
m_cnFirst = cValueA.m_cnFirst;
m_cnLast = cValueA.m_cnLast;
cValueA.m_cnFirst = 0;
cValueA.m_cnLast = 0;
return *this;
}
//两张表非空,首地址
if (cnCurrentA&&cnCurrentB) {
if (cnCurrentA->m_Data<=cnCurrentB->m_Data) {
cnCurrent = cnCurrentA;
cnCurrentA = cnCurrentA->m_Link;
}else{
cnCurrent = cnCurrentB;
cnCurrentB = cnCurrentB->m_Link;
}
m_cnFirst = cnCurrent;
}
//主循环
while (cnCurrentA&&cnCurrentB) {
if (cnCurrentA->m_Data<=cnCurrentB->m_Data) {
cnCurrent->m_Link = cnCurrentA;
cnCurrentA = cnCurrentA->m_Link;
}else
{
cnCurrent->m_Link = cnCurrentB;
cnCurrentB = cnCurrentB->m_Link;
}
cnCurrent = cnCurrent->m_Link;
}
//剩余部分
if (cnCurrentA) {
cnCurrent->m_Link = cnCurrentA;
m_cnLast = cValueA.m_cnLast;
}
if (cnCurrentB) {
cnCurrent->m_Link = cnCurrentB;
m_cnLast = cValueB.m_cnLast;
}
cValueA.m_cnFirst = cValueA.m_cnLast = 0;
cValueB.m_cnFirst = cValueB.m_cnLast = 0;
return *this;
}
/************************************************************************
Function:拆分链表C奇偶项为链表A和链表B
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::Split(Chain<T>& cValueA,Chain<T>& cValueB)
{
ChainNode<T> *cnCurrentA,*cnCurrentB,*cnCurrentC;
cnCurrentC = m_cnFirst;
if (!cnCurrentC) {//C为空表
cValueA.m_cnFirst = 0;
cValueA.m_cnLast = 0;
cValueB.m_cnFirst = 0;
cValueB.m_cnLast = 0;
return;
}
if (cnCurrentC) {//A表奇数位
cnCurrentA = cnCurrentC;
cValueA.m_cnFirst = cnCurrentC;
}
if (!cnCurrentC->m_Link) {//C表只有一个元素
cnCurrentA->m_Link = 0;
cValueA.m_cnLast = cnCurrentC;
cValueB.m_cnFirst = cValueB.m_cnLast =0;
m_cnFirst = m_cnLast =0;
return;
}else{//C表至少两个元素
cnCurrentB = cnCurrentC->m_Link;
cValueB.m_cnFirst = cnCurrentC->m_Link;
}
int nIndex,nLength = Length()/2;
for (nIndex =0;nIndex < nLength;nIndex++) {
cnCurrentA->m_Link = cnCurrentB->m_Link;
if (!cnCurrentA->m_Link) {
break;
}
cnCurrentA = cnCurrentB->m_Link;
cnCurrentB->m_Link = cnCurrentA->m_Link;
if (!cnCurrentB->m_Link) {
break;
}
cnCurrentB = cnCurrentA->m_Link;
}
cValueA.m_cnLast = cnCurrentA;
cValueB.m_cnLast = cnCurrentB;
m_cnFirst = m_cnLast = 0;
return;
}
/************************************************************************
Function:插入排序
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::InsertionSort()
{
ChainNode<T> *cnCurrent,*cnNext,*cnTemp,*cnPrevious;
if (!m_cnFirst) {//空表
return;
}
cnCurrent = m_cnFirst;
cnNext = cnCurrent->m_Link;
if (!cnNext) {//一个元素
return;
}
while (cnNext) {
cnTemp = m_cnFirst;
cnPrevious = cnTemp;
while (cnNext->m_Data>cnTemp->m_Data) {
if (cnTemp!=m_cnFirst) {
cnPrevious = cnTemp;
}
cnTemp = cnTemp->m_Link;
}
if (cnNext==cnTemp) {//同一个节点
cnCurrent = cnNext;
cnNext = cnCurrent->m_Link;
continue;
}
//交换位置
cnCurrent->m_Link = cnNext->m_Link;
cnNext->m_Link = cnTemp;
if (cnTemp==m_cnFirst) {
m_cnFirst = cnNext;
}else{
cnPrevious->m_Link = cnNext;
}
cnNext = cnCurrent->m_Link;
}
m_cnLast = cnCurrent;
}
/************************************************************************
Function:冒泡排序
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::BubbleSort()
{
ChainNode<T> *cnPrevious,*cnCurrent,*cnNext,*cnTemp;
if (!m_cnFirst) {//空表
return;
}
cnPrevious = m_cnFirst;
cnCurrent = cnPrevious->m_Link;
if (!cnCurrent) {//一个元素
return;
}
cnNext = cnCurrent->m_Link;
if (!cnNext) {//两个元素
if (cnPrevious->m_Data>cnCurrent->m_Data) {
m_cnFirst = cnCurrent;
m_cnLast = cnPrevious;
m_cnFirst->m_Link = m_cnLast;
}
return;
}
cnTemp = m_cnLast;
while (cnTemp!=cnCurrent) {
if (cnPrevious->m_Data>cnCurrent->m_Data) {//交换首两个节点
m_cnFirst = cnCurrent;
cnPrevious->m_Link = cnCurrent->m_Link;
cnCurrent->m_Link = cnPrevious;
cnPrevious = m_cnFirst;
cnCurrent = cnPrevious->m_Link;
}
while (cnNext!=cnTemp) {
if (cnCurrent->m_Data>cnNext->m_Data) {//交换后两个节点
cnPrevious->m_Link = cnNext;
cnCurrent->m_Link = cnNext->m_Link;
cnNext->m_Link = cnCurrent;
cnCurrent = cnPrevious->m_Link;
cnNext = cnCurrent->m_Link;
}
cnPrevious = cnPrevious->m_Link;
cnCurrent = cnCurrent->m_Link;
cnNext = cnNext->m_Link;
}
if (cnCurrent->m_Data>cnNext->m_Data) {//交换最后两个节点
cnPrevious->m_Link = cnNext;
cnCurrent->m_Link = cnNext->m_Link;
cnNext->m_Link = cnCurrent;
cnCurrent = cnPrevious->m_Link;
cnNext = cnCurrent->m_Link;
}
//重新初始化
cnTemp = cnCurrent;
cnPrevious = m_cnFirst;
cnCurrent = cnPrevious->m_Link;
cnNext = cnCurrent->m_Link;
}
}
/************************************************************************
Function:
Parameter:
Return:
************************************************************************/
template <class T>
ostream& operator<<(ostream& out,const Chain<T>& cValue)
{
cValue.OutPut(out);
return out;
}
/***********************************************************************
Function:箱子排序,时间复杂度为O(n+nRange),适用于nRange比n大不多时
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::BinSort(int nRange)
{
int nBinIndex;// 箱子索引号
ChainNode<T> **cnBottom, **cnTop;
//箱子初始化
cnBottom = new ChainNode<T>* [nRange + 1];
cnTop = new ChainNode<T>* [nRange + 1];
for (nBinIndex = 0;nBinIndex <= nRange; nBinIndex++) {
cnBottom[nBinIndex] = 0;
}
//把节点分配到各箱子中
for (;m_cnFirst;m_cnFirst = m_cnFirst->m_Link) {
nBinIndex = m_cnFirst->m_Data;
if (cnBottom[nBinIndex]) {//箱子非空
cnTop[nBinIndex]->m_Link = m_cnFirst;
cnTop[nBinIndex] = m_cnFirst;
}else{
cnBottom[nBinIndex] = m_cnFirst;
cnTop[nBinIndex] = m_cnFirst;
}
}
//收集各箱子中的元素,产生一个排序链表
ChainNode<T> *cnTemp = 0;
for (nBinIndex = 0;nBinIndex <= nRange; nBinIndex++) {
if (cnBottom[nBinIndex]) {
if (cnTemp) {
cnTemp->m_Link = cnBottom[nBinIndex];
}else{
m_cnFirst = cnBottom[nBinIndex];
}
cnTemp = cnTop[nBinIndex];
}
}
if (cnTemp) {
cnTemp->m_Link = 0;
}
delete [] cnBottom;
delete [] cnTop;
}
/***********************************************************************
Function:箱子排序,时间复杂度为O(n+nRange),适用于nRange比n大不多时
Parameter:nRange数值范围;Value函数名,返回T中相应数据,T多值数据结构
Return:
************************************************************************/
template <class T>
void Chain<T>::BinSortEx(int nRange,int (*Value)(T& nValue))
{
int nBinIndex;// 箱子索引号
ChainNode<T> **cnBottom, **cnTop;
//箱子初始化
cnBottom = new ChainNode<T>* [nRange + 1];
cnTop = new ChainNode<T>* [nRange + 1];
for (nBinIndex = 0;nBinIndex <= nRange; nBinIndex++) {
cnBottom[nBinIndex] = 0;
}
//把节点分配到各箱子中
for (;m_cnFirst;m_cnFirst = m_cnFirst->m_Link) {
nBinIndex = Value(m_cnFirst->m_Data);//返回相应数据
if (cnBottom[nBinIndex]) {//箱子非空
cnTop[nBinIndex]->m_Link = m_cnFirst;
cnTop[nBinIndex] = m_cnFirst;
}else{
cnBottom[nBinIndex] = m_cnFirst;
cnTop[nBinIndex] = m_cnFirst;
}
}
//收集各箱子中的元素,产生一个排序链表
ChainNode<T> *cnTemp = 0;
for (nBinIndex = 0;nBinIndex <= nRange; nBinIndex++) {
if (cnBottom[nBinIndex]) {
if (cnTemp) {
cnTemp->m_Link = cnBottom[nBinIndex];
}else{
m_cnFirst = cnBottom[nBinIndex];
}
cnTemp = cnTop[nBinIndex];
}
}
if (cnTemp) {
cnTemp->m_Link = 0;
}
delete [] cnBottom;
delete [] cnTop;
}
/************************************************************************
Function:基数排序
Parameter:nRadix基数;nCount位数
Return:
************************************************************************/
template <class T>
void Chain<T>::RadixSort(int nRadix,int nCount)
{
int i,j,nBinIndex,nModulus,nModulusRadix;
ChainNode<T> **cnBottom,**cnTop;
cnBottom = new ChainNode<T>* [nRadix];
cnTop = new ChainNode<T>* [nRadix];
ChainNode<T> *cnTemp = 0;
nModulus = 1;
nModulusRadix = 1;
for (i = 1;i <= nCount; i++) {
cnTemp = 0;
nModulus *= nRadix;
for (j=0;j<nRadix;j++) {
cnBottom[j]=0;
cnTop[j]=0;
}
for (;m_cnFirst;m_cnFirst = m_cnFirst->m_Link) {
nBinIndex = ((m_cnFirst->m_Data)%nModulus)/nModulusRadix;//返回相应数据
if (cnBottom[nBinIndex]) {//箱子非空
cnTop[nBinIndex]->m_Link = m_cnFirst;
cnTop[nBinIndex] = m_cnFirst;
}else{
cnBottom[nBinIndex] = m_cnFirst;
cnTop[nBinIndex] = m_cnFirst;
}
}
//收集各箱子中的元素,产生一个排序链表
for (nBinIndex = 0;nBinIndex < nRadix; nBinIndex++) {
if (cnBottom[nBinIndex]) {
if (cnTemp) {
cnTemp->m_Link = cnBottom[nBinIndex];
}else{
m_cnFirst = cnBottom[nBinIndex];
}
cnTemp = cnTop[nBinIndex];
}
}
if (cnTemp) {
cnTemp->m_Link = 0;
}
nModulusRadix *=nRadix;
}
delete [] cnBottom;
delete [] cnTop;
}
/************************************************************************
Function:求最大元素
Parameter:
Return:
************************************************************************/
template <class T>
void Chain<T>::Max(T& nValue)
{
ChainNode<T> cnTemp;
cnTemp = m_cnFirst;
if (cnTemp) {
nValue = cnTemp.m_Data;
cnTemp = cnTemp.m_Link;
}else{
return;
}
while (cnTemp) {
if (cnTemp.m_Data>nValue) {
nValue = cnTemp.m_Data;
}
cnTemp = cnTemp.m_Link;
}
}