左偏树

首先声明，我的代码基本是照着www.cnblogs.com/skywang12345/p/3638342.html打的，感谢分享。

不过我的疑问是在实现merge时提供的形参为何要加引用，一开始傻乎乎地觉得这样才能真正改动内部指针成员，知道去掉引用run了一把才知道不加引用也能实现合并，加引用除了减少拷贝指针的开销其实没有其他好处了，当然只是我个人的想法，望轻喷。传值调用也能改变内部指针指向的原因是这两条语句，mRoot=rhs->mRoot;x->right=merge(x->right,y);

虽然改变的是局部指针的指向，但由于又进行了一次赋值操作，所以实参pointer也被改变了指向。相当于创建两个局部指针作为实参的拷贝，merge后形成一颗新的左偏树再传给实参。虽然cppprimer还没看到后面，也通过上面的博客大概知道了用法，再表感激。下面贴自己搬运后略微修改的代码：

#include <iomanip>
#include <iostream>

using namespace std;

template <class T>
class LeftistNode {
public:
    T key;
    int npl;
    LeftistNode* left;
    LeftistNode* right;

    LeftistNode(T value = -1, LeftistNode* l = 0, LeftistNode* r = 0) ://key值默认为-1
        key(value), left(l), right(r), npl(0) {}
};

template <class T>
class LeftistHeap {
private:
    LeftistNode<T> *mRoot;
public:
    //构造函数
    LeftistHeap() :mRoot(0) {}
    ~LeftistHeap();//析构函数

    void preOrder();//前序遍历“左倾堆”

    void merge(LeftistHeap<T>* other);//将自己与other堆合并
    void insert(T key);
    void remove();//只支持删除堆顶
    void destroy();
    // 打印左倾堆
    void print();

private:
    void preOrder(LeftistNode<T>* heap)const;
    //如果不解引用指针与其他类型的swap无区别
    void swapNode(LeftistNode<T>* &x, LeftistNode<T>* &y);
    LeftistNode<T>* merge(LeftistNode<T>* x, LeftistNode<T>* y);
    LeftistNode<T>* insert(LeftistNode<T>* heap, T key);
    LeftistNode<T>* remove(LeftistNode<T>* heap);

    void destroy(LeftistNode<T>* heap);
    // 打印左倾堆
    void print(LeftistNode<T>* heap, T key, int direction);
};

template<class T>
LeftistHeap<T>::~LeftistHeap() { destroy(); }

template<class T>
void LeftistHeap<T>::preOrder(LeftistNode<T>* heap)const {
    if (heap) {
        cout << heap->key << endl;
        preOrder(heap->left);
        preOrder(heap->right);
    }
}

template<class T>
void LeftistHeap<T>::preOrder() {
    preOrder(mRoot);
}

template<class T>
void LeftistHeap<T>::swapNode(LeftistNode<T>* &x, LeftistNode<T>* &y) {
    LeftistNode<T>* tmp = x;
    x = y;
    y = tmp;
}

template <class T>
LeftistNode<T>* LeftistHeap<T>::merge(LeftistNode<T>* x, LeftistNode<T>* y) {
    if (x == NULL)return y;
    if (y == NULL)return x;

    if (x->key > y->key)swapNode(x, y);
    x->right = merge(x->right, y);

    if (x->left == 0 || x->left->npl < x->right->npl)swapNode(x->left, x->right);//保证左偏

    if (x->right == 0)x->npl = 0;
    else x->npl = x->right->npl + 1;

    return x;
}

template<class T>
void LeftistHeap<T>::merge(LeftistHeap<T>*rhs) {
    mRoot = merge(mRoot, rhs->mRoot);//
}

template<class T>
LeftistNode<T>* LeftistHeap<T>::insert(LeftistNode<T>* heap, T key) {
    LeftistNode<T>* node = new LeftistNode<T>(key, 0, 0);
    if (node == 0) {
        cout << "create node failed!" << endl;
        return heap;
    }

    return merge(heap, node);
}

template <class T>
void LeftistHeap<T>::insert(T key) {
    mRoot = insert(mRoot, key);
}

template<class T>
LeftistNode<T>* LeftistHeap<T>::remove(LeftistNode<T>* heap) {
    LeftistNode<T>* l = heap->left;
    LeftistNode<T>* r = heap->right;

    delete heap;
    //heap = 0;//置空
    return merge(l, r);
}

template<class T>
void LeftistHeap<T>::remove() { mRoot = remove(mRoot); }

template<class T>
void LeftistHeap<T>::destroy(LeftistNode<T>* heap) {
    if (heap == 0)return;

    destroy(heap->left);
    destroy(heap->right);

    delete heap;
}

template <class T>
void LeftistHeap<T>::print(LeftistNode<T>* heap, T key, int direction)
{
    if (heap != NULL)
    {
        if (direction == 0)    // heap是根节点
            cout << setw(2) << heap->key << "(" << heap->npl << ") is root" << endl;
        else                // heap是分支节点
            cout << setw(2) << heap->key << "(" << heap->npl << ") is " << setw(2) << key << "'s " << setw(12) << (direction == 1 ? "right child" : "left child") << endl;

        print(heap->left, heap->key, -1);
        print(heap->right, heap->key, 1);
    }
}

template <class T>
void LeftistHeap<T>::print()
{
    if (mRoot != NULL)
        print(mRoot, mRoot->key, 0);
}


template<class T>
void LeftistHeap<T>::destroy() { destroy(mRoot); }

int main(void) {
    int i;
    int a[] = { 10,40,24,30,36,20,12,16 };
    int b[] = { 17,13,11,15,19,21,23 };
    int alen = sizeof(a) / sizeof(a[0]);
    int blen = sizeof(b) / sizeof(b[0]);
    LeftistHeap<int>* ha = new LeftistHeap<int>();
    LeftistHeap<int>* hb = new LeftistHeap<int>();

    cout << "== 左倾堆(ha)中依次添加: ";
    for (i = 0; i<alen; i++)
    {
        cout << a[i] << " ";
        ha->insert(a[i]);
    }
    cout << "
== 左倾堆(ha)的详细信息: " << endl;
    ha->print();


    cout << "
== 左倾堆(hb)中依次添加: ";
    for (i = 0; i<blen; i++)
    {
        cout << b[i] << " ";
        hb->insert(b[i]);
    }
    cout << "
== 左倾堆(hb)的详细信息: " << endl;
    hb->print();


    // 将"左倾堆hb"合并到"左倾堆ha"中。
    ha->merge(hb);
    cout << "
== 合并ha和hb后的详细信息: " << endl;
    ha->print();


    // 销毁
    ha->destroy();

    return 0;

}