typedef int Type; //~ 节点数据类型
typedef struct Node
{
	Type data;
	int bf;
	Node *left, *right;
	Node(){ bf = 0; left = right = 0; }
} AVLNode, *AVLTree; //~ 平衡树及其节点
 
void RRotate(AVLTree & T) //~ 右旋处理,T的左孩子成为新子树根
{
	AVLNode * tmp = T->left;
	T->left = tmp->right;
	tmp->right = T;
	T = tmp;
}
 
void LLotate(AVLTree & T) //~ 左旋处理,T的右孩子成为新子树根
{
	AVLNode * tmp = T->right;
	T->right = tmp->left;
	tmp->left = T;
	T = tmp;
}
 
void LBalance(AVLTree & T) //~ 左平衡处理
{
	AVLNode * l = T->left;
	switch(l->bf)
	{
		case 1: //~ LL,单右旋转
			RRotate(T);
			T->bf = l->bf = 0; //~ 更新平衡因子
			return ;
		case -1: //~ LR双旋转
			AVLNode * lr = l->right;
			switch(lr->bf) //~ 更新平衡因子
			{
				case 1:
					l->bf = 0;
					T->bf = -1;
					break;
				case -1:
					T->bf = 0;
					l->bf = 1;
					break;
			}// switch
			lr->bf = 0;
			LLotate(l);
			RRotate(T);
	}// switch
}
 
void RBalance(AVLTree & T) //~ 右平衡处理
{
	AVLNode * r = T->right;
	switch(r->bf)
	{
		case -1: //~ RR,单左旋转
			LLotate(T);
			T->bf = r->bf = 0;
			return ;
		case 1: //~ RL双旋转
			AVLNode * rl = r->left;
			switch(rl->bf)//~ 更新平衡因子
			{
				case 1:
					r->bf = -1;
					T->bf = 0;
					break;
				case -1:
					T->bf = 1;
					r->bf = 0;
					break;
			}// switch
			rl->bf = 0;
			RRotate(r);
			LLotate(T);
	}// switch
}
bool Insert(AVLTree & T, Type & data) //~ 通过插入操作构建AVL树
{
	bool taller = true; //~ 标识此次插入操作是否使该树长高
	if(!T) //~ 该子树为空树，长高
	{
		T = new AVLNode;
		T->data = data;
		return taller;
	} // if
	if(data == T->data) return false; //~ 该数据已存在，不重复插入
	if(data < T->data) //~ 需要将该数据插入左子树
	{
		if(!Insert(T->left, data)) return false; //~ 左子树未长高
		switch(T->bf) //~ 左子树长高，判断是否需要调整
		{
			case 1: //~ 失衡，许进行左平衡调整
				LBalance(T);
				return false;
			case 0: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = 1;
				return true;
			case -1: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = 0;
				return false;
		} // switch
	} // if
	else
	{
		if(!Insert(T->left, data)) return false;
		switch(T->bf)
		{
			case 1: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = 0;
				return false;
			case 0: //~ 未失衡，只需调整当前节点的平衡因子
				T->bf = -1;
				return true;
			case -1: //~ 失衡，许进行右平衡调整
				RBalance(T);
				return false;
		} // switch
	} // if
}

template <class T>
class Heap
{
    public:
        //~ 构造容量n的堆
        Heap(size_t n = 64);
        //~ 以数组构造
        Heap(const T* beg, const T* end);
        ~Heap(){delete [] pHeap;}
        //~ 添加元素
        void push(const T& item);
        //~ 返回并删除堆顶元素
        T pop();
        //~ 返回堆顶元素的引用
        T& top()const;//! 不允许修改！
        size_t size() const;//~ 当前元素个数
        size_t capacity() const;//~ 当前容量
    private:
        void resize();//~ 重新调整堆容量
        void adjust(int i);//~ 调整以i为根的子树为最小堆
        T * pHeap;
        size_t _size;
        size_t _capacity;
};
 
template <class T>
Heap<T>::Heap(size_t n): pHeap(new T[n])
{
    _size = 0;
    _capacity = n;
}
template <class T>
Heap<T>::Heap(const T* beg,const T* end)
{
    _capacity = _size = end - beg;
    pHeap = new T[_size];
    for(int i = 0; i < _size; ++i)
    {
        pHeap[i] = *beg++;
    }
    int i = _size - 1;
    //~ 调用adjust(int)构造最小堆
    for( ; i >= 0; --i)
        adjust(i);
}
template <class T>
void Heap<T>::push(const T& item)
{
    //~ 容量不足时重新分配空间
    if(_size == _capacity)
        resize();
    _size++;
    int i = _size - 1;
    //~ 通过上溯寻找合适的插入位置
    while(i && pHeap[(i-1)/2] > item)
    {
        pHeap[i] = pHeap[(i-1)/2];
        i = (i-1) / 2;
    }
    pHeap[i] = item;
}
template <class T>
T Heap<T>::pop()
{
    //~ assert(_size);
    if(_size <= 0)exit(1);
    T rt = pHeap[0];
    //~ 先将堆尾元素置顶，然后重建
    pHeap[0] = pHeap[--_size];
    if(_size)
        adjust(0);
    return rt;
}
template <class T>
T& Heap<T>::top()const
{
    // assert(_size);
    if(_size <= 0)exit(1);
    return pHeap[0];
}
template <class T>
size_t Heap<T>::size()const
{
    return _size;
}
template <class T>
size_t Heap<T>::capacity()const
{
    return _capacity;
}
template <class T>
void Heap<T>::resize()
{
    T * org = pHeap;
    //~ 调整容量
    _capacity = 2*_capacity + 1;
    pHeap = new T[_capacity];
    //~ 复制堆
    for(int i = 0; i < _size; ++i)
    {
        pHeap[i] = org[i];
    }
    delete [] org;
}
template <class T>
void Heap<T>::adjust(int i)
{
    //~ 重建以i为根的最小堆，假定其左右子树已是最小堆
    size_t minpos;
    while(2 * i + 1 < _size)
    {
        minpos = i;
        if(2 * i + 2 < _size && pHeap[2*i+2] < pHeap[i])
            minpos = 2 * i + 2;
        if(pHeap[2*i+1] < pHeap[minpos])
            minpos = 2 * i + 1;
        if(minpos == i)
            break;
        swap(pHeap[i], pHeap[minpos]);
        i = minpos;
    }
}

#include <iostream>
#include <cassert>
using namespace std;
struct Node
{
	Node(int n = 0):data(n){}
	int data;
	Node* next;
}; 
void reverse(Node * T)
{
	assert(T); //~ 表头非空
	Node* p = T->next, *t;
	if(p)
	{	//~ 将第一个结点，即未来的表尾next域置空
		t = p->next;
		p->next = NULL;
		p = t;
	}
	while(p)
	{	//~ 将余下结点依次插入表头
		t = p->next;
		p->next = T->next;
		T->next = p;
		p = t;
	}
}
 
//~ 测试代码
int main()
{
	Node *head = new Node, *t = head;
	for(int i = 0; i < 10; ++i)
	{
		t->next = new Node(i);
		t = t->next;
	}
	t->next = NULL;
 
	Node * p = head->next;
	reverse(head);
	while(p)
	{
		cout<<p->data<<endl;
		p = p->next;
	}
 
	return 0;
}

#include <iostream>
#include <vector>
#include <cassert>
 
using namespace std;
 
template <class T>
class mstack: private vector<T>  //~ 私有继承自vector<T> :)
{
public:
	mstack(size_t = 0);
	//~ 接口声明 :)
	void push(const T &);
	void pop();
	T& top();
	void clear();
	size_t size() const;
	bool empty() const;
};
//~ 接口实现 :)
template <class T>
mstack<T>::mstack(size_t _size)
{
	if(_size)
		vector<T>::reserve(_size);
}
template <class T>
void mstack<T>::push(const T &t)
{
	vector<T>::push_back(t);
}
 
template <class T>
void mstack<T>::pop()
{
	assert(vector<T>::size() > 0);
	vector<T>::erase(vector<T>::end()-1);
}
 
template <class T>
T& mstack<T>::top()
{
	return *(vector<T>::end() - 1);
}
 
template <class T>
void mstack<T>::clear()
{
	vector<T>::clear();
}
 
template <class T>
size_t mstack<T>::size()const
{
	return vector<T>::size();
}
 
template <class T>
bool mstack<T>::empty()const
{
	return vector<T>::size() == 0;
}
//~ 测试代码 :)
int main()
{
	mstack<int> stk;
	for(int i = 0; i < 10; ++i)
		stk.push(i);
	stk.push(100);
	cout<<stk.top()<<endl;
	stk.pop();
	cout<<stk.top()<<endl;
	cout<<stk.size()<<endl;
	stk.clear();
	cout<<stk.size()<<endl;
	//~ cout<<stk.capacity()<<endl; private inherit from vector<T> :(
	return 0;
}

/*
 * pre存放先序序列，
 * in存放中序序列，
 * n为结点个数，
 * 返回二叉树根指针
 */
BTree CreateBT(Type * pre, Type * in, int n)
{
	if(n <= 0)
		return NULL;
	BTree bt = new BTNode;
	Type * p;
	int k;
	bt->data = *pre;
	for(p = in; p < in + n; ++p)
		if(*pre == *p)
			break;
	k = p - in;
	bt->lchild = CreateBT(pre+1, in, k);
	bt->rchild = CreateBT(pre+k+1, p+1, n-k-1);
        return bt;	
}

void R_Rotate (BSTree &p) 
{
    //~ 对以*p为根的二叉排序树作右旋转处理，处理之后p指向新的树根结点，即旋转
    //~ 处理之前的左子树的根结点
    lc=p->lchild ;            //~ lc指向的*p的左子树根结点
    p->lchild=lc->rchild ;    //~ lc的右子树挂接为*p的左子树
    lc->rchild=p ; p=lc ;    //~ p指向新的根结点
}//~ R_Rotate
 
void L_Rotate (BSTree &p)    
{
    //~ 对以*p为根的二叉排序树作左旋处理，处理之后p指向新的树根结点，即旋转
    //~ 处理之前的右子树的根结点
    rc=p->rchild ;            //~ rc指向的*p的右子树根结点
    p->rchild=rc->lchild ;  //~ rc左子树挂接为*p的右子树
    rc->lchild=p ; p=rc ;   //~ p指向新的根结点
}//~ L_Rotate