上一篇里把源代码贴出来了！这里就一点点来分析！

首先第一步建树：

1.  #define INF ~0u>>1 
2.  #define NIL SPLAY 
3.  #define MN 200005 
4.  using namespace std; 
5.  int n,m,l,r,x,pos; 
6.  char s[10]; 
7.  struct SPLAYTREE{ 
8.      struct NODE{ 
9.          int key,minv,size,add; 
10.          bool rev; 
11.          NODE *left,*right,*father; 
12.          NODE (){} 
13.          NODE(int _key):key(_key){minv=_key,size=1,add=0,rev=false;} 
14.      }SPLAY[MN],*SP,*root,*head,*tail; 
15. }tree; 

这句宏定义：

1. #define INF ~0u>>1 

的意思等同于：

1. #define INF 0x7FFFFFFF 

"u"是表示unsigned int，这里呢就是先把无符号整型0取反，然后右移一位。

第二点很难理解的就是: NODE(int _key):key(_key)

这句代码主要是理解C++中new关键字的应用：(http://sbp810050504.blog.51cto.com/2799422/1026483)这里面讲得挺好的！

head指针与tail指针在《运用伸展树解决数列维护问题》中讲到了，就是在提取一段区间时，为了更方便操作，人为了增加两个结点，这两个结点不能影响树的结构。

接着就是树的初始化了：

1. //对伸展树进行初始化，也就是把head和tail加入到树中， 
2.     void init(){ 
3.         SP=NIL; 
4.         NIL->key=NIL->minv=INF; 
5.         NIL->size=0; 
6.         NIL->rev=false;NIL->add=0;//用于懒操作的 
7.         NIL->left=NIL->right=NIL->father=NIL; 
8.         head=new(++SP)Node(INF); 
9.         head->left=head->right=head->father=NIL; 
10.         tail=new(++SP)Node(INF); 
11.         tail->left=tail->right=tail->father=NIL; 
12.         head->right=tail;tail->father=head; 
13.         head->size++; 
14.         root=head; 
15.     } 

把初始化与前面的关键字new的用法结合起来，就能体会到作者C++语言的功底了：西漂亮，优雅！也能理解到SP指针是干嘛的了！

   为了更好的理解，我把树打印出来：即先插入一段数据，然后按下标的顺序把数据打印出来！

1. #include <iostream> 
2.  
3. #define INF ~0u>>1 
4. #define MN 200005 
5. #define NIL SPLAY 
6. using namespace std; 
7. struct SplayTree{ 
8.          struct Node{ 
9.              int key,minv,size,add; 
10.              bool rev; 
11.              Node *left,*right,*father; 
12.              Node(){} 
13.              Node(int _key):key(_key){minv=_key,size=1,add=0,rev=false;} 
14.          }SPLAY[MN],*SP,*root,*head,*tail; 
15. // 
16. //  //对伸展树进行初始化，也就是把head和tail加入到树中， 
17.     void init(){ 
18.         SP=NIL; 
19.         NIL->key=NIL->minv=INF; 
20.         NIL->size=0; 
21.         NIL->rev=false;NIL->add=0;//用于懒操作的 
22.         NIL->left=NIL->right=NIL->father=NIL; 
23.         head=new(++SP)Node(INF); 
24.         head->left=head->right=head->father=NIL; 
25.         tail=new(++SP)Node(INF); 
26.         tail->left=tail->right=tail->father=NIL; 
27.         head->right=tail;tail->father=head; 
28.         head->size++; 
29.         root=head; 
30.     } 
31.     //暂时只维护区间，不作伸展操作 
32.     void splay(Node *&root,Node *&t){ 
33.  
34.     } 
35.     //往第pos位后插入key 
36.     void insert(int key,int pos){ 
37.         Node *t;t=new(++SP)Node(key); 
38.         t->left=t->right=t->father=NIL; 
39.  
40.         Node *r,*p;r=root; 
41.         bool flag=false;//默认朝左边走 
42.         while(r!=NIL){ 
43.             p=r;r->size++; 
44.             if(r->left->size+1>pos)r=r->left,flag=false; 
45.             else pos-=r->left->size+1,r=r->right,flag=true; 
46.         } 
47.         if(flag)p->right=t; 
48.         else p->left=t; 
49.         t->father=p; 
50.         splay(root,t); 
51.     } 
52.     void inorder(Node *t){ 
53.         if(t->left!=NIL) 
54.             inorder(t->left); 
55.         printf("%d ",t->key); 
56.         if(t->right!=NIL) 
57.             inorder(t->right); 
58.  
59.     } 
60. }tree; 
61. //这里需要注意的是，SplayTree一定要定义成全局变量，不然会因为栈溢出而报内存错误 
62. int main(){ 
63.     int a[10]={0,9,8,7,6,5,4,3,2,1};//a[0]位置的数据不用 
64.     int i; 
65.     //初始化 
66.     tree.init(); 
67.     //插入数据 
68.     for(i=1;i<10;i++){ 
69.         tree.insert(a[i],i); 
70.     } 
71.     //按下标的顺序输出 
72.     tree.inorder(tree.head); 
73.     return 0; 
74. } 

 这里的伸展树退化成了一棵维护区间的二叉查找树！记住是维护区间，像线段树一样，不会数据进行排序，只会维护区间。由于伸展树跟线段树很像，所以有的代码写法很像线段树！其本质我觉得是一样的，只是代码组织的方式不同罢了。当然上面这样我更容易理解！

    而实际上，如果不做伸展操作，加入的数据在树中就会变成如下的形式：链式的数据其性能的很低的，所以必须做伸展操作：

这恰恰与《运用伸展树解决数列维护问题》中描述的“在伸展树中对区间进行操作”是一样的！而根结点的右孩子的左子树就是要维护的区间。