#ifndef INDIRECTLIST_H_
#define INDIRECTLIST_H_
#include <iostream>
using namespace std;
template <class T> class IndirectIterator;
template <class T>
class IndirectList
{
friend IndirectIterator<T>;
public:
IndirectList(int nMaxSize = 10);
~IndirectList();
bool IsEmpty() const { return m_nLength==0; };
int Length() const { return m_nLength; };
bool Find(int nIndex,T& nValue) const;
int Search(const T& nValue) const;
IndirectList<T>& Delete(int nIndex,T& nValue);
IndirectList<T>& Insert(int nIndex,const T& nValue);
void Output(ostream& out) const;
int SearchHalf(const T& nValue) const;
void InsertSort();
void BubbleSort();
protected:
private:
T **m_Table;
int m_nMaxSize;
int m_nLength;
};
template <class T>
class IndirectIterator
{
public:
T* Initialize(const IndirectList<T>& ilValue)
{
m_cnLocation = ilValue.m_Table[0];
m_nLength = ilValue.m_nLength;
if (m_cnLocation) {
m_nCurrent = 1;
return m_cnLocation;
}
return 0;
}
T* Next(const IndirectList<T>& ilValue){
if (!m_cnLocation) {
return 0;
}
m_nCurrent++;
if (m_nCurrent<=m_nLength) {
m_cnLocation = ilValue.m_Table[m_nCurrent-1];
}else{
return 0;
}
if (m_cnLocation) {
return m_cnLocation;
}
return 0;
}
protected:
private:
T* m_cnLocation;
int m_nLength;
int m_nCurrent;
};
#endif
#include <iostream>
#include "IndirectList.h"
#include "xcept.h"
/************************************************************************
Function:构造函数
Parameter:
Return:
************************************************************************/
template <class T>
IndirectList<T>::IndirectList(int nMaxSize /* = 10 */)
{
m_nMaxSize = nMaxSize;
m_Table = new T *[m_nMaxSize];
m_nLength = 0;
}
/************************************************************************
Function:析构函数
Parameter:
Return:
************************************************************************/
template <class T>
IndirectList<T>::~IndirectList()
{
int i;
for (i= 0;i < m_nLength; i++) {
delete m_Table[i];
}
delete [] m_Table;
}
/************************************************************************
Function:按索引nIndex查找
Parameter:
Return:
************************************************************************/
template <class T>
bool IndirectList<T>::Find(int nIndex,T& nValue) const
{
if (nIndex>m_nLength||nIndex<1) {
return false;
}
nValue = *m_Table[nIndex-1];
return true;
}
/************************************************************************
Function:按索引nIndex删除元素
Parameter:
Return:
************************************************************************/
template <class T>
IndirectList<T>& IndirectList<T>::Delete(int nIndex,T& nValue)
{
int i;
if (Find(nIndex,nValue)) {
delete m_Table[nIndex - 1];
m_Table[nIndex - 1] = 0;
for (i = nIndex;i < m_nLength; i++) {
m_Table[i-1] = m_Table[i];
}
m_nLength--;
return *this;
}else{
throw OutOfBounds();
}
}
/************************************************************************
Function:按索引nIndex插入元素
Parameter:
Return:
************************************************************************/
template <class T>
IndirectList<T>& IndirectList<T>::Insert(int nIndex,const T& nValue)
{
int i;
if (nIndex < 0||nIndex > m_nLength) {
throw OutOfBounds();
}
if (nIndex==m_nMaxSize) {
throw NoMem();
}
for (i = m_nLength - 1;i >= nIndex; i--) {
m_Table[i+1] = m_Table[i];
}
m_Table[nIndex] = new T;
*m_Table[nIndex] = nValue;
m_nLength++;
return *this;
}
/************************************************************************
Function:按值查找,并返回索引
Parameter:
Return:
************************************************************************/
template <class T>
int IndirectList<T>::Search(const T& nValue) const
{
int nIndex = 0;
T *temp;
for (nIndex = 0;nIndex < m_nLength; nIndex++) {
temp = m_Table[nIndex];
if (*temp==nValue) {
nIndex++;
break;
}
}
return nIndex;
}
/************************************************************************
Function:递增线性表,折半搜索
Parameter:
Return:
************************************************************************/
template <class T>
int IndirectList<T>::SearchHalf(const T& nValue) const
{
int nLeft,nRight,nMiddle;
nLeft = 0;
nRight = m_nLength-1;
nMiddle = m_nLength/2;
while (*m_Table[nMiddle]!=nValue) {
if (*m_Table[nMiddle]<nValue) {
nLeft = nMiddle;
nMiddle = (nLeft + nRight + 1)/2;
}else{
nRight = nMiddle;
nMiddle = (nLeft + nRight)/2;
}
}
if (((nMiddle==0)||(nMiddle==m_nLength-1))&&((*m_Table[nMiddle])!=nValue)) {
throw OutOfBounds();
}
nMiddle++;
return nMiddle;
}
/************************************************************************
Function:插入排序
Parameter:
Return:
************************************************************************/
template <class T>
void IndirectList<T>::InsertSort()
{
int i,j;
T* temp;
for (i = 1;i < m_nLength; i++) {
temp = m_Table[i];
for (j = i-1;(j >= 0)&&(*m_Table[j] > *temp); j--) {
m_Table[j+1] = m_Table[j];
}
m_Table[j+1] = temp;
}
}
/************************************************************************
Function:冒泡排序
Parameter:
Return:
************************************************************************/
template <class T>
void IndirectList<T>::BubbleSort()
{
int i,j;
T *temp;
bool swapped = false;//交换标记
for (i = m_nLength;i > 1; i--) {
swapped = false;
for (j = 0;j < i-1; j++) {
if (*m_Table[j] > *m_Table[j+1]) {
swapped = true;
temp = m_Table[j];
m_Table[j] = m_Table[j+1];
m_Table[j+1] = temp;
}
}
if (swapped==false) {
break;
}
}
}
/************************************************************************
Function:输出
Parameter:
Return:
************************************************************************/
template <class T>
void IndirectList<T>::Output(ostream& out) const
{
int i = 0;
for (i = 0;i < m_nLength; i++) {
out << *m_Table[i] << " ";
}
}
/************************************************************************
Function:
Parameter:
Return:
************************************************************************/
template <class T>
ostream& operator<<(ostream& out,const IndirectList<T>& ilvalue)
{
ilvalue.Output(out);
return out;
}