二分插入排序

来源：互联网发布：查看linux下所有用户编辑：程序博客网时间：2024/05/18 01:02

今天，我们一起用C++实现二分插入排序，具体如下。

Data.h具体内容：

[cpp] view plaincopy
template<typename Type> class Element{  
public:  
    Type GetKey(){  
        return key;  
    }  
  
    void SetKey(Type item){  
        key = item;  
    }  
  
public:  
    Element<Type>& operator =(Element<Type> copy){  
        key = copy.key;  
        return *this;  
    }  
  
    bool operator ==(Element<Type> item){  
        return this->key == item.key;  
    }  
  
    bool operator !=(Element<Type> item){  
        return this->key != item.key;  
    }  
  
    bool operator <(Element<Type> item){  
        return this->key < item.key;  
    }  
  
    bool operator >(Element<Type> item){  
        return this->key > item.key;  
    }  
  
    bool operator >=(Element<Type> item){  
        return this->key >= item.key;  
    }  
  
    bool operator <=(Element<Type> item){  
        return this->key <= item.key;  
    }  
  
  
private:  
    Type key;  
};  
  
template<typename Type> class Sort;  
template<typename Type> class DataList{  
public:  
    friend class Sort < Type > ;  
    DataList(int size = m_nDefaultSize) : m_nMaxSize(size), m_ncurrentsize(0){  
        m_pvector = new Element<Type>[size];  
    }  
  
    DataList(Type *data, int size);  
  
    bool Insert(Type item);  
    ~DataList(){  
        delete[] m_pvector;  
    }  
  
    int Size(){  
        return this->m_ncurrentsize;  
    }  
    void Swap(Element<Type> &left, Element<Type> &right){  
        Element<Type> temp = left;  
        left = right;  
        right = temp;  
    }  
  
    void Print();  
private:  
    static const int m_nDefaultSize = 10;  
    Element<Type> *m_pvector;  
    const int m_nMaxSize;  
    int m_ncurrentsize;  
};  
  
template<typename Type> DataList<Type>::DataList(Type *data, int size)  
    : m_nMaxSize(size > m_nDefaultSize ? size : m_nDefaultSize), m_ncurrentsize(0){  
    this->m_pvector = new Element<Type>[size];  
    for (int i = 0; i < size; i++){  
        this->m_pvector[i].SetKey(data[i]);  
    }  
    this->m_ncurrentsize += size;  
  
}  
  
template<typename Type> bool DataList<Type>::Insert(Type item){  
    if (this->m_ncurrentsize == this->m_nMaxSize){  
        cerr << "The list is full!" << endl;  
        return 0;  
    }  
    this->m_pvector[this->m_ncurrentsize++].SetKey(item);  
}  
  
template<typename Type> void DataList<Type>::Print(){  
    cout << "The list is:";  
    for (int i = 0; i < this->m_ncurrentsize; i++){  
        cout << " " << this->m_pvector[i].GetKey();  
    }  
}  

LinkQueue.h具体内容如下：

[cpp] view plaincopy
#include "QueueNode.h"  
  
template<typename Type> class LinkQueue{  
public:  
    LinkQueue() :m_prear(NULL), m_pfront(NULL){}  
    ~LinkQueue(){  
        MakeEmpty();  
    }  
    void Append(const Type item);  
    Type Delete();  
    Type GetFront();  
    void MakeEmpty();  
    bool IsEmpty() const{  
        return m_pfront == NULL;  
    }  
    void Print();  
  
private:  
    QueueNode<Type> *m_prear, *m_pfront;  
};  
  
template<typename Type> void LinkQueue<Type>::MakeEmpty(){  
    QueueNode<Type> *pdel;  
    while (m_pfront){  
        pdel = m_pfront;  
        m_pfront = m_pfront->m_pnext;  
        delete pdel;  
    }  
}  
  
template<typename Type> void LinkQueue<Type>::Append(const Type item){  
    if (m_pfront == NULL){  
        m_pfront = m_prear = new QueueNode<Type>(item);  
    }  
    else{  
        m_prear = m_prear->m_pnext = new QueueNode<Type>(item);  
    }  
}  
  
template<typename Type> Type LinkQueue<Type>::Delete(){  
    if (IsEmpty()){  
        cout << "There is no element!" << endl;  
        exit(1);  
    }  
    QueueNode<Type> *pdel = m_pfront;  
    Type temp = m_pfront->m_data;  
    m_pfront = m_pfront->m_pnext;  
    delete pdel;  
    return temp;  
}  
  
template<typename Type> Type LinkQueue<Type>::GetFront(){  
    if (IsEmpty()){  
        cout << "There is no element!" << endl;  
        exit(1);  
    }  
    return m_pfront->m_data;  
}  
  
template<typename Type> void LinkQueue<Type>::Print(){  
    QueueNode<Type> *pmove = m_pfront;  
    cout << "front";  
    while (pmove){  
        cout << "--->" << pmove->m_data;  
        pmove = pmove->m_pnext;  
    }  
    cout << "--->rear" << endl << endl << endl;  
}  

QueueNode.h具体内容如下：

[cpp] view plaincopy
template<typename Type> class LinkQueue;  
  
template<typename Type>  
class QueueNode  
{  
private:  
    friend class LinkQueue < Type > ;  
    QueueNode(const Type item, QueueNode<Type> *next = NULL)  
        :m_data(item), m_pnext(next){}  
private:  
    Type m_data;  
    QueueNode<Type> *m_pnext;  
};  

Sort.h具体内容如下:

[cpp] view plaincopy
#include "Data.h"  
#include "LinkQueue.h"  
  
template<typename Type> class Sort{  
public:  
    void BinaryInsertSort(DataList<Type> &list, int n = -1);  
};  
template<typename Type>  
void Sort<Type>::BinaryInsertSort(DataList<Type> &list, int n){  
    if (-1 == n){  
        for (int i = 1; i < list.m_ncurrentsize; i++){  
            BinaryInsertSort(list, i);  
        }  
        return;  
    }  
    Element<Type> temp = list.m_pvector[n];  
    int left = 0, right = n - 1;  
    while (left <= right){  
        int middle = (left + right) / 2;  
        if (temp < list.m_pvector[middle]){  
            right = middle - 1;  
        }  
        else {  
            left = middle + 1;  
        }  
    }  
    for (int i = n - 1; i >= left; i--){  
        list.m_pvector[i + 1] = list.m_pvector[i];  
    }  
    list.m_pvector[left] = temp;  
}  

main.cpp具体内容如下：

[cpp] view plaincopy
#include <iostream>  
  
using namespace std;  
  
#include "Sort.h"  
  
int main()  
{  
    int init[15] = { 1, 3, 5, 7, 4, 2, 8, 0, 6, 9, 29, 13, 25, 11, 32 };  
    DataList<int> data(init, 15);  
    Sort<int> sort;  
    data.Print();  
    cout << endl << endl << endl;  
    sort.BinaryInsertSort(data);      
    data.Print();  
    cin.get();  
    return 0;  
}  

运行效果如图1所示：

图1 运行效果

0 0