数据结构系列之线性表（链表描述）

最新推荐文章于 2024-05-03 16:54:29 发布
最新推荐文章于 2024-05-03 16:54:29 发布
阅读量278 收藏
点赞数
分类专栏： 数据结构算法与应用-C++语言描述学习中 文章标签： 数据结构 function class delete insert merge
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/riyueming184/article/details/6285649
版权


#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;
 }
}

riyueming184
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
山东大学数据结构实验4 线性表报告
10-14
山东大学数据结构实验4线性表报告2012年
数据结构 线性表和链表 c++实现
12-14
数据结构 线性表和链表 c++面向对象实现 分文件编写
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构之线性表（链表实现）
SurpriseKuang的博客
03-22 368
首先，我们需要定义链表中的节点结构。每个节点包含两个部分：存储的数据（类型为T）和指向下一个节点的指针。// 链表节点public:// 存储的数据T data;// 指向下一个节点public:// 默认构造函数// 拷贝构造函数// 带参数构造函数使用链表实现的线性表是一种常见的数据结构，它通过链式存储方式来存储元素，每个元素都包含一个指向下一个元素的指针。相比于使用数组实现的线性表，链表在插入和删除操作上更加灵活，因为它们只需要更改相邻元素的指针即可，而不需要移动元素。
数据结构之线性表、多重链表
weixin_73293671的博客
11-05 1261
本篇是对于学习到的数据结构线性表，广义表，多重链表的总结，内容有点小多。
数据结构【线性表-链表】
huajian225的博客
06-06 637
链表的概念，初始化链表、插入、删除节点、合并链表、计算链表的长度
数据结构之线性表—链表描述
whhcs的博客
09-05 434
@TOC 线性表—链式描述 在基于数组的描述中，元素的地址是由数学公式决定的，分布在一段连续的内存空间中。 在链式描述中，线性表的元素在内存中的存储位置是随机的。每个元素都有一个明确的指针或链指向线性表的下一个元素的地址 。   单向链表 设L = (e0e_0e0​, e1e_1e1​,…, en−1e_n-_1en​−1​) 是一个线性表，在这个线性表中，每个元素都在一个单独的节点中描述，每一个节点都有一个链域，它的值是线性表的下一个元素的地址。所以，元素eie_iei​的节点链接着元素ei+
【数据结构——线性表之链表】
lflcodeplus的博客
10-04 2270
线性表之《链表的表示及基本操作的实现》 目录线性表之《链表的表示及基本操作的实现》一、单链表（一）单链表的描述（一）单链表的操作实现1、初始化2、查找3、插入4、删除二、循环链表三、循环链表 一、单链表 （一）单链表的描述 typedef struct LNode { ElemType data;//结点数据域 struct LNode* next;//结点指针域 }LNode ,*LinkList; 变量定义： LNode* p, * q LinkList L; p, q, L都是指针变量，
数据结构-线性表的链表总结
qq_63959489的博客
04-19 1011
线性表的链表总结、顺序表与链表关系与适用场景
数据结构线性表之链表（详解）
qq_45515182的博客
09-09 1772
1、什么是线性表 首先，线性表是一种数据结构，是一种数据在逻辑上是连续的结构。 其次，线性表在计算机内部可以用顺序结构和链式结构存储数据。 顺序结构可以采用数组的方式完成，而本文主要描述的就是链式的线性表 2、什么是链表 链表是一个十分抽象的名词，但是开发者可以将其和火车结合进行理解，每一节车厢就是一个节点，而车厢与车厢之间的连接就是节点和节点之间的连接，但是在程序世界并不存在车厢与车厢那种的实际连接，因为程序世界的构成是内存，学过C/C++的开发者都知道，内存与内存的关系就是指针指向，那么就很好理解
数据结构之线性表之线性表顺序存储结构
m0_74018560的博客
12-10 599
数据结构之线性表部分之线性表存储结构
python数据结构之线性表
m0_71417856的博客
04-12 1180
python线性表的一些基本操作，包括顺序表和单链表
数据结构与算法：链表.pptx
05-11
链表是通过每个结点的指针域将线性表的n个结点按其逻辑次序链接在一起的。 每一个结只包含一个指针域的链表，称为单链表。 为操作方便，总是在链表的第一个结点之前附设一个头结点(头指针)head指向第一个结点。头...
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验内容 （1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均...编写一个算法将此表改为循环双链表。
数据结构——链表（精简易懂版）
最新发布
qq_34434522的博客
05-03 673
1，链表（Linked List）是一种常见的数据结构，用于存储一系列元素。它由一系列节点（Node）组成，每个节点包含两部分：数据域（存储数据的部分）和指针域（指向下一个节点的指针）。链表的特点是节点在内存中的存储位置不必是连续的，而是通过指针来相互连接。具体可以想象成一个很多个积木连接的蛇链表可以分为单向链表和双向链表两种常见形式单向链表（Singly Linked List）：每个节点包含一个指针，指向下一个节点。单向链表只能从头节点开始顺序访问，无法从尾节点快速访问到头节点。（就是上面那种）
数据结构可视化（适合考研党）
qq_51281451的博客
04-30 532
还在疑惑平衡二叉树、红黑树、B树、B+树怎么插入构建的吗，不要慌张，这个网站会一步一步来演示.
数据结构中的栈（C语言版）
z6665454的博客
04-30 1268
被移除的元素是最后一个入栈的元素，即栈顶元素。出栈操作会改变栈的结构，并返回被移除的元素。对于基于数组实现的栈，如果数组已满，即栈已满，该函数返回真；获取栈顶元素：获取栈顶的元素，但不对栈进行修改。如果栈中没有元素，即栈为空，该函数返回真；函数检查栈是否为空，如果为空，则打印错误信息并返回-1；函数检查栈是否为空，如果为空，则打印错误信息并返回-1；3.栈中的元素没有编号或索引，只有栈顶指针来指示栈的当前位置。1.元素的插入和删除操作只能在栈的一端进行，该端被称为栈顶。等于-1，表示栈为空，返回1；
C语言/数据结构——每日一题（移除链表元素）
yiqingaa的博客
04-30 489
今天在leetcode刷到了一道关于单链表的题。想着和大家分享一下。废话不多说，让我们开始今天的知识分享吧。
线性表的公式化描述与链表描述
08-06
线性表是一种数据结构，通常用于存储具有相同数据类型的有序元素。线性表可以通过公式化描述和链表描述来实现。 公式化描述是指使用数组来实现线性表。通过定义一个固定大小的数组，元素按照一定的顺序依次存储在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值