SplayTree伸展树的非递归实现（自底向上）

Splay Tree 是二叉查找树的一种，它与平衡二叉树、红黑树不同的是，Splay Tree从不强制地保持自身的平衡，每当查找到某个节点n的时候，在返回节点n的同时，Splay Tree会将节点n旋转到树根的位置，这样就使得Splay Tree天生有着一种类似缓存的能力，因为每次被查找到的节点都会被搬到树根的位置，所以当80%的情况下我们需要查找的元素都是某个固定的节点，或者是一部分特定的节点时，那么在很多时候，查找的效率会是O(1)的效率！当然如果查找的节点是很均匀地分布在不同的地方时，Splay Tree的性能就会变得很差了，但Splay Tree的期望的时间复杂度还是O（nlogn）的。

下图是对伸展树查询节点1和删除节点6的结果，利用我的伸展树来实现

头文件————————————————————————————
#ifndef _SPLAY_TREE_H_
#define _SPLAY_TREE_H_

#include <iostream>
#include <iomanip>
#include <cassert>
#include <stack>

typedef struct splay_tree_node_t
{
     int data;
     struct splay_tree_node_t *left;
     struct splay_tree_node_t *right;
} splay_tree_node, *position, *splay_tree;

void print_splay_tree(splay_tree st, int depth, int ctrl);//ctrl:0=root 1=left 2=right
position find_max(splay_tree st);
void insert_splay_tree(splay_tree *pst, int x);
void delete_splay_tree(splay_tree *pst, int x);
int find_splay_tree(splay_tree *pst, int x);

splay_tree rotate3(position child, position parent, position grand_parent, int *type);
splay_tree rotate2(position child, position parent);

inline void fcn(int type, position cur, position parent, position grand_parent);
#endif

源文件——————————————————————————————
#include "./SplayTree.h"

splay_tree rotate3(position child, position parent, position grand_parent, int *type)
{
     assert(child != NULL && parent != NULL && grand_parent != NULL);

     if(parent->left == child && grand_parent->left == parent)//child, parent, grand_parent一字形东北方向 0
     {
          *type = 0;
          grand_parent->left = parent->right;
          parent->right = grand_parent;

          parent->left = child->right;
          child->right = parent;
     }
     else if(parent->right == child && grand_parent->right == parent)//child, parent, grand_parent一字形西北方向 1
     {
          *type = 1;
          grand_parent->right = parent->left;
          parent->left = grand_parent;

          parent->right = child->left;
          child->left = parent;
     }
     else if(parent->right == child && grand_parent->left == parent)//child, parent, grand_parent之字形<
     {
          *type = 2;
          grand_parent->left = child->right;
          parent->right = child->left;
          child->left = parent;
          child->right = grand_parent;
     }
     else if(parent->left == child && grand_parent->right == parent)//child, parent, grand_parent之字形>
     {
          *type = 3;
          grand_parent->right = child->left;
          parent->left = child->right;
          child->right = parent;
          child->left - grand_parent;
     }

     return child;
}
splay_tree rotate2(position child, position parent)
{
     assert(child != NULL && parent != NULL);
     if(parent->left == child)
     {
          parent->left = child->right;
          child->right = parent;
     }
     else//parent->right == child
     {
          parent->right = child->left;
          child->left = parent;
     }
     return child;
}

position find_max(splay_tree st)
{
     while(NULL != st && NULL != st->right)
          st = st->right;
     return st;
}

void print_splay_tree(splay_tree st, int depth, int ctrl)
{
     if(NULL != st)
     {
          std::cout<<std::setw(depth);
          if(0 == ctrl)
               std::cout<<"root:";
          else if(1 == ctrl)
               std::cout<<"left";
          else if(2 == ctrl)
               std::cout<<"right";
          std::cout<<st->data<<std::endl;
          print_splay_tree(st->left, depth+6, 1);
          print_splay_tree(st->right, depth+6, 2);
     }
}
void insert_splay_tree(splay_tree *pst, int x)
{
     if(NULL == *pst)
     {
          position tmp = new splay_tree_node;
          if(NULL == tmp)
               return ;
          tmp->data = x;
          tmp->left = tmp->right = NULL;
          *pst = tmp;
     }
     else if(x < (*pst)->data)
          insert_splay_tree(&((*pst)->left), x);
     else if(x > (*pst)->data)
          insert_splay_tree(&((*pst)->right), x);
     else
          return ;
}
void delete_splay_tree(splay_tree *pst, int x)
{
     assert(NULL != pst);
     int res = find_splay_tree(pst, x);
     if(res == 0)//not found
          return ;
     //此时root指向的就是要删除的节点，因为find_splay_tree操作将节点推至向根
     position root = *pst;
     splay_tree splay_left = root->left;
     splay_tree splay_right = root->right;
     position tmp = find_max(splay_left);
     if(NULL == tmp)//无左子树
          *pst = splay_right;//将右子树为新树
     else
     {
          find_splay_tree(&splay_left, tmp->data);
          splay_left->right = splay_right;//将右子树为左子树的新右子树
          *pst = splay_left;//将左子树为新树
     }
}
int find_splay_tree(splay_tree *pst, int x)
{
     assert(NULL != pst);
     position cur = *pst;
     std::stack<position> s;

     while(cur != NULL && cur->data != x)//沿着查找路径将树节点以此压入栈中
     {
          if(x < cur->data)
          {
               s.push(cur);
               cur = cur->left;
          }
          else
          {
               s.push(cur);
               cur = cur->right;
          }
     }

     if(NULL == cur)//not found
          return false;

     position parent, grand_parent;
     int type = -1;//0一字形东北方向; 1一字形西北方向; 2之字形<; 3之字形<
     //每次取父节点和祖父节点和当前节点进行伸展调节
     while(s.size() >= 2)
     {
          parent = s.top();
          s.pop();
          //fcn判断伸展的类型以便重新调整原来的树指针，调整好了才可以再次伸展
          fcn(type, cur, parent, grand_parent);
          grand_parent = s.top();
          s.pop();
          cur = rotate3(cur, parent, grand_parent, &type);//after rotate, cur is the new "root"
     }
     if(s.empty())
          *pst = cur;
     else //rotate cur and the old root
     {
          parent = s.top();
          s.pop();
          fcn(type, cur, parent, grand_parent);
          //此时只对cur和根节点进行伸展，完成后find_splay_tree函数结束
          *pst = rotate2(cur, parent);
     }

     return true;
}

//fcn判断伸展的类型以便重新调整原来的树指针，调整好了才可以再次伸展
inline void fcn(int type, position cur, position parent, position grand_parent)
{
     if(type == 0)
          {
               if(grand_parent == parent->left)
                    parent->left = cur;
               else if(grand_parent == parent->right)
                    parent->right = cur;
          }
          else if(type == 1)
          {
               if(grand_parent == parent->left)
                    parent->left = cur;
               else if(grand_parent == parent->right)
                    parent->right = cur;
          }
          else if(type == 2)
          {
               if(grand_parent == parent->left)
                    parent->left = cur;
               else if(grand_parent == parent->right)
                    parent->right = cur;
          }
          else if(type == 3)
          {
               if(grand_parent == parent->left)
                    parent->left = cur;
               else if(grand_parent == parent->right)
                    parent->right = cur;
          }
}