群体类和群体数据的组织

1. 函数模板与类模板

1.1 函数模板

定义形式：

template<模板参数表>
类型名 函数名(参数)
{}

模板参数表由用逗号分隔的模板参数组成，可以包括：

（1）class或typename标识符，指明可以接收一个类型参数。代表的是类型，可以是内部类型或自定义类型。

（2）“类型说明符”标识符，指明可以接收一个由“类型说明符”所规定类型的常量作为参数。

（3）template<参数表>class 标识符，指明可以接收一个类模板名作为参数。

1.2 类模板

语法形式：

template<模板参数表>
class 类名
{}

如果在类模板以外定义成员函数，形式如下：

template<模板参数表>
类型名 类名<模板参数标识符列表>::函数名(参数表)
{}

使用一个类模板来实例化对象：

模板名<模板参数表>对象名1, 对象名2,...;

2.线性群体

线性群体分为：可直接访问的线性群体，按顺序从头开始访问各个元素的线性群体。

2.1 直接访问群体—数组类

2.2 顺序访问群体—链表类

（1）结点类

template<class T>
class Node
{
public:
    T data;                                  //数据域
    Node(const T &data, Node<T>* next = 0);  //构造函数
    void insertAfter(Node<T> *p);            //插入
    Node<T>* deleteAfter();                  //删除
    Node<T>* nextNode();                     //获取后继节点地址
 
private:
    Node<T>* next;                           //指针域
};

template<class T>
Node<T>::Node(constT &data, Node<T>* next)
{
    this.data = data
    this.next = next;
}

template<class T>
Node<T>* Node<T>*::nextNode()
{
    return next;
}

template<class T>
void Node<T>::insertAfter(Node<T>* p)
{
    p->next = next;
    next = p;
}

template<class T>
Node<T>* Node<T>*::deleteAfter()
{
    if(next == 0)
        return 0;
    Node<T>* ptr = next;
    next = next->next;
    return ptr;
}

（2）链表类

template<class T>
class LinkedList{
private:
    Node<T>* front, * rear;      //头指针，尾指针
    Node<T>* prevPtr, * currPtr; //记录表当前遍历位置的指针
    int size;                    //元素个数
    int position;                //当前元素在表中的序号

    //生成新结点
    Node<T>* newNode(const T &item, Node<T>* ptrNext = NULL); 

    //释放结点
    void freeNode(Node<T>* p);

    //将链表L复制到当前表
    void copy(const LinkedList<T> &L);

public:
    LinkedList();                                       //构造函数
    LinkEdList(const LinkedList<T> &L);                 //重载构造函数
    ~LinkedList();
    LinkedList<T>& operactor=(const LinkedList<T> &L);  //运算符重载
    
    int getsize();                                //返回元素个数
    bool isEmpty();                               //是否为空
    
    void reset(int pos = 0);                      //初始化游标位置
    void next();                                  //移动到下一个结点
    bool endOfList() const;                       //游标是否在链尾
    int currentPosition()conmst;                  //当前位置
    
    void insertFront(const T &item);              //表头插入结点
    void insertRear(const T &item);               //表尾插入结点
    void insertAt(const T &item);                 //当前结点前插入结点
    void insertAfter(const T &item);              //当前结点后插入结点

    T deleteFront();                              //删除头结点
    void deleteCurrent();                         //删除当前结点
    
    T& data();                                    //返回数据域引用
    
    void clear();                                 //清空链表
};

2.3 栈类

template<class T, int SIZE = 50>
class Stack
{
private:
    T list[SIZE];
    int top;            //栈顶
public：
    Stack();                      //构造函数
    void push(const T &item);     //入栈
    T pop();                      //出栈
    void clear();                 //清空栈
    const T &peek() const;        //访问栈顶元素
    bool isEmpty() const;
    bool isFull() const;
};

template<class T,int SIZE>
Stack<T, SIZE>::Stack()
{
    top = -1;
}

template<class T,int SIZE>
void Stack<T, SIZE>::push(const T &item)
{
    assert(!isFull());            //如果栈满了则报错
    list[++top] = item;
}

template<class T,int SIZE>
T Stack<T, SIZE>::pop()
{
    assert(!isEmpty());          //如果栈为空则报错
    return list[top--];
}

template<class T,int SIZE>
const T& Stack<T, SIZE>::peek() const
{
    assert(!isEmpty());
    return list[top];
}

template<class T,int SIZE>
bool Stack<T, SIZE>::isEmpty()
{
    return top == -1;
}

template<class T,int SIZE>
bool Stack<T, SIZE>::isFull()
{
    return top == SIZE-1;
}

template<class T,int SIZE>
void Stack<T, SIZE>::clear()
{
    top = -1;
}

2.4 队列类

template<class T,int SIZE = 50>
class Queue
{
private:
    int front, rear, count;  //队头、队尾指针，元素个数
    T list[SIZE];
public:
    Queue();                      //构造函数
    void insert(const T &item);   //入队
    T remove();                   //出队
    void clear();                 //清空队列
    const T &getFront() const;    //访问队首

    int getLength();              //队列长度
    bool isEmpty();
    bool isFull();
};

template<class T,int SIZE>
Queue<T, SIZE>::Queue()
{
    front = 0;
    rear = 0;
    count = 0;
}

template<class T,int SIZE>
T Queue<T, SIZE>::insert(const T &item)
{
    assert(!isFull());
    count ++;
    list[rear] = item;
    rear = (rear + 1)%SIZE;
}

template<class T,int SIZE>
T Queue<T, SIZE>::insert(const T &item)
{
    assert(!isEmpty());
    int temp = front;
    front = (front + 1)%SIZE;
    return list[temp];
}

template<class T,int SIZE>
T Queue<T, SIZE>::getFront const()
{
    assert(!isEmpty());
    return list[front];
}

template<class T,int SIZE>
int Queue<T, SIZE>::getLength const()
{
    return count;
}

template<class T,int SIZE>
bool Queue<T, SIZE>::isEmpty()
{
    return count == 0;
}

template<class T,int SIZE>
bool Queue<T, SIZE>::isFull()
{
    return count == SIZE;
}

template<class T,int SIZE>
void Queue<T, SIZE>::clear()
{
    front = 0;
    rear = 0;
    count = 0;
}

3. 群体数据的组织

3.1插入排序

直接插入排序函数模板

template<class T>
void insertionsort(T a[], int n)
{
    int i, int j;
    T temp;
    for(i = 1; i<n, i++)
    {
        int j = i;
        T temp = a[i];
        while(j>0 && temp<a[j-1])
        {
            a[j] = a[j-1];
            j--;
        }
        a[j] = temp;
    }

}

3.2 选择排序

直接选择排序函数模板

template<class T>
void mySwap(T &x, T &y)
{
    T temp = x;
    x = y;
    y = temp;
}

template<class T>
void selectionSort(T a[], int n)
{
    for(int i = 0; i<n-1;i++)
    {
        int leastinsex = i;
        for(int j = i+1; j<n; j++)
            if(a[j] < a[leastindex])
                leastindex = j;
        mySwap(a[i], a[leastindex]);
    }
}

3.3 交换排序

冒泡排序函数模板

template<class T>
void mySwap(T &x, T &y)
{
    T temp = x;
    x = y;
    y = temp;
}

template<class T>
void bubbleSort(T a[], int n)
{
    int i = n-1;
    while(i>0)
    {
        int lastchangeindex = 0;
        for(j = 0; j<i; j++)
            if(a[j+1] < a[j])
            {
                mySwap(a[j+1], a[j]);
                lastchangeindex = j;
            }
        i = lastchangeindex;
    }
}

3.4 顺序查找

3.5 折半查找

template<class T>
int binSearch(const T list[], int n, const T &key)
{
    int low = 0;
    int high = n-1;
    while(low <= high)
    {
        int mid = (low+high)/2;
        if(key == list[mid])
            return mid;
        else if(key < list[mid])
            high = mid-1;
        else 
            low = mid+1;
    }
    return -1;
}