伸展树

数据结构与算法分析——c语言描述 第四章树 伸展树

看了书上的思路，全靠自己独立把代码写出来了，后来才发现书上给的代码实现是放到最后一章12章了。

写完我都为我的意志坚定而惊讶。花了一天和一个早上的一个小时。代码一定要靠自己写出来，很多时候代码一看就懂，但你是不知道怎么来的，架构思路方法怎么来的。不停debug不停修改代码就是一个创作思考的过程，don't be afraid.

说几点值得注意的

查找，插入，删除是会改变树的结构的。有时会把根节点也改变掉，所以调用的时候必须是t = findMax(t);，把返回值赋给t，当然也可以传入指针，但这样指针的地址更麻烦。旋转的时候不是每一个节点都旋转，所以返回的必须包含两个信息，要找的值和这一层的根节点，有时候相同（旋转的时候），有时候不同（不旋转的时候），所以返回一个结构体包含两个指针。

书上删除的思路假定了要找的节点必须有左子树的情况和findmax必须要最大值就是根节点。我考虑没有左子树和没有父亲的情况。

查找，找最大值，找最小值需要返回相应的节点的指针。但是树是自底向上旋转的，并且是有祖父的时候才旋转，那么再最上层的时候一定要把节点转到根节点上，不然你就会忽略上一层的节点。（t = findMax(t);）这是使用方法，也就是说必须要找的值放到第一个。插入则不需要放到根节点上。

SplayTree.h

typedef int ElementType;

#ifndef _SplayTree_H
#define _SplayTree_H

struct SplayNode;
typedef struct SplayNode *Position;
typedef struct SplayNode *SplayTree;

SplayTree createSplayTree();
SplayTree MakeEmpty(SplayTree T);
Position find(ElementType X, SplayTree t);
Position findMin(SplayTree t);
Position findMax(SplayTree t);
SplayTree insert(ElementType X, SplayTree t);
SplayTree Delete(ElementType X, SplayTree t);
ElementType retrieve(Position p);
void listDirectory(SplayTree t);
#endif

SplayTree.c

#include"SplayTree.h"
#include<stdlib.h>
#include"fatal.h"

struct SplayNode {
ElementType element;
SplayTree left;
SplayTree right;
};

struct Pair {//用于返回的结构体
Position pToX;
Position pToNextLevelRootNode;
};

static Position singleRotateWithLeft(Position k2) {
Position k1 = k2->left;
Position y = k1->right;
k2->left = y;
k1->right = k2;
return k1;
}

static Position singleRotateWithRight(Position k1) {
Position k2 = k1->right;
Position y = k2->left;
k1->right = y;
k2->left = k1;
return k2;
}

static Position doubleRotateWithLeft(Position k3) {
Position k1 = k3->left;
k3->left = singleRotateWithRight(k1);
return singleRotateWithLeft(k3);
}

static Position doubleRotateWithRight(Position k1) {
Position k3 = k1->right;
k1->right = singleRotateWithLeft(k3);
return singleRotateWithRight(k1);
}

static Position zig_ZigRotateWithLeft(Position G) {
Position P = G->left;
Position X = P->left;
Position B = X->right;
Position C = P->right;
X->right = P;
P->left = B;
P->right = G;
G->left = C;
return X;
}

static Position zig_ZigRotateWithRight(Position G) {
Position P = G->right;
Position X = P->right;
Position B = P->left;
Position C = X->left;
X->left = P;
P->left = G;
P->right = C;
G->right = B;
return X;
}

SplayTree createSplayTree() {
return NULL;
}

SplayTree MakeEmpty(SplayTree T) {
if (T != NULL) {
MakeEmpty(T->left);
MakeEmpty(T->right);
free(T);
}
return NULL;
}

static struct Pair find_internal(ElementType X, SplayTree t) {
struct Pair ret;//返回上一层的包含指向X和旋转后的这层树根节点的指针的结构
struct Pair receive;//下一层返回来的，指向X和旋转后的下一层树的根节点的指针的结构
if (t == NULL) {//空树，空指针

ret.pToNextLevelRootNode = NULL;
ret.pToX = NULL;
}
else if (X < t->element) {
receive = find_internal(X, t->left);
t->left = receive.pToNextLevelRootNode;
if (receive.pToX == NULL) {//没找到X
ret.pToNextLevelRootNode = t;
ret.pToX = NULL;
}
else {
if (t->left->left == receive.pToX) {

t = zig_ZigRotateWithLeft(t);
ret.pToX = ret.pToNextLevelRootNode = t;
printf("%d test\n", t->element);
}
else if (t->left->right == receive.pToX) {
t = doubleRotateWithLeft(t);
ret.pToX = ret.pToNextLevelRootNode = t;
}
else {
ret.pToX = receive.pToX;
ret.pToNextLevelRootNode = t;
}
}

}
else if (X > t->element) {
receive = find_internal(X, t->right);
t->right = receive.pToNextLevelRootNode;
if (receive.pToX == NULL) {//没找到X
ret.pToNextLevelRootNode = t;
ret.pToX = NULL;
}
else {
if (t->right->right == receive.pToX) {
t = zig_ZigRotateWithRight(t);
ret.pToX = ret.pToNextLevelRootNode = t;
}
else if (t->right->left == receive.pToX) {
t = doubleRotateWithRight(t);
ret.pToX = ret.pToNextLevelRootNode = t;
}
else {
ret.pToX = receive.pToX;
ret.pToNextLevelRootNode = t;
}
}

}
else {//相等的情况，就是要寻找的
ret.pToX = t;
ret.pToNextLevelRootNode = t;
}
return ret;
}

Position find(ElementType X, SplayTree t) {
struct Pair receive;
receive = find_internal(X,t);
if (receive.pToNextLevelRootNode != receive.pToX)//要找的点不在根节点上,转换到根节点,在第二层
if (receive.pToX->element < receive.pToNextLevelRootNode->element)
return singleRotateWithLeft(receive.pToNextLevelRootNode);
else
return singleRotateWithRight(receive.pToNextLevelRootNode);

return receive.pToNextLevelRootNode;
}

struct Pair findMin_internal(SplayTree t) {
struct Pair receive, ret;
if (t->left) {//存在左节点
receive = findMin_internal(t->left);
t->left = receive.pToNextLevelRootNode;
if (t->left->left == receive.pToX) {//pToX为最小节点的指针
t = zig_ZigRotateWithLeft(t);
ret.pToNextLevelRootNode = t;
ret.pToX = t;
}
else {
ret.pToX = receive.pToX;
ret.pToNextLevelRootNode = t;
}

}
else {
ret.pToX = t;
ret.pToNextLevelRootNode = t;
}
return ret;
}

Position findMin(SplayTree t) {
struct Pair receive;
receive = findMin_internal(t);
if (receive.pToNextLevelRootNode != receive.pToX)//最大的在第二层
return singleRotateWithLeft(receive.pToNextLevelRootNode);
return receive.pToNextLevelRootNode;
}

struct Pair findMax_internal(SplayTree t) {
struct Pair receive, ret;
if (t->right) {//存在左节点
receive = findMax_internal(t->right);
t->right = receive.pToNextLevelRootNode;
if (t->right->right == receive.pToX) {//pToX为最小节点的指针
t = zig_ZigRotateWithRight(t);
ret.pToNextLevelRootNode = t;
ret.pToX = t;
}
else {
ret.pToX = receive.pToX;
ret.pToNextLevelRootNode = t;
}
}
else {
ret.pToX = t;
ret.pToNextLevelRootNode = t;
}
return ret;
}

Position findMax(SplayTree t) {
struct Pair receive;
receive = findMax_internal(t);
if (receive.pToNextLevelRootNode != receive.pToX)//最大的在第二层
return singleRotateWithRight(receive.pToNextLevelRootNode);
return receive.pToNextLevelRootNode;
}

static Position makeNode(ElementType X) {
Position t = malloc(sizeof(struct SplayNode));
if (t == NULL)
Error("OUT OF MEMORY");
t->element = X;
t->left = NULL;
t->right = NULL;
return t;
}

struct Pair insert_internal(ElementType X, SplayTree t) {
struct Pair ret, receive;
if (t == NULL) {//找到最底层
t = makeNode(X);
ret.pToX = t;
ret.pToNextLevelRootNode = t;
}

else if (X < t->element) {//小于
receive = insert_internal(X, t->left);
t->left = receive.pToNextLevelRootNode;
if (t->left->left == receive.pToX) {//一字型
t = zig_ZigRotateWithLeft(t);
ret.pToX = ret.pToNextLevelRootNode = t;//旋转了之后插入的节点编程这一层的根节点，下同
}
else if (t->left->right == receive.pToX) {//之子型
t = doubleRotateWithLeft(t);
ret.pToX = ret.pToNextLevelRootNode = t;
}
else {//这一层的下一个节点就是X，没必要旋转
ret.pToX = receive.pToX;
ret.pToNextLevelRootNode = t;
}
}
else if (X > t->element) {
receive = insert_internal(X, t->right);
t->right = receive.pToNextLevelRootNode;
if (t->right->right == receive.pToX) {
t = zig_ZigRotateWithRight(t);
ret.pToX = ret.pToNextLevelRootNode = t;
}
else if (t->right->left == receive.pToX) {
t = doubleRotateWithRight(t);
ret.pToX = ret.pToNextLevelRootNode = t;
}
else {
ret.pToX = receive.pToX;
ret.pToNextLevelRootNode = t;
}
}
else {
ret.pToNextLevelRootNode = t;
ret.pToX = t;
}
return ret;
}

SplayTree insert(ElementType X, SplayTree t) {
return insert_internal(X, t).pToNextLevelRootNode;
}

SplayTree Delete(ElementType X, SplayTree t) {
Position father = NULL;
Position p = t;
while (p) {
if (X < p->element) {
father = p;
p = p->left;
}
else if (X > p->element) {
father = p;
p = p->right;
}
else//相等，找到了
break;
}
if (p) {//找到了
Position MaxOf_T_Left;
if (p->left) {//存在左子树的情况下
MaxOf_T_Left = findMax(p->left);//把最大的放到左子树根节点上
MaxOf_T_Left->right = p->right;//连接起来
if (father) {//有父节点
if (MaxOf_T_Left->element < father->element)
father->left = MaxOf_T_Left;
else//大于，不存在等于
father->right = MaxOf_T_Left;
}
else//有左子树，没父节点
t = MaxOf_T_Left;
}
else {//没有左子树
if (father) {//有父节点
if (p->element < father->element)
father->left = p->right;//right可能空或者不空
else//大于，不存在等于
father->right = p->right;
}
else//没有父节点，没有左子树
t = p->right;
}
free(p);
}
return t;
}

ElementType retrieve(Position p) {
return p->element;
}

static void listDir(SplayTree t, int depth) {
if (t) {
int d = depth;
while (d--)
printf("	");
printf("%d\n", t->element);
if (t->left)
listDir(t->left, depth + 1);
if (t->right)
listDir(t->right, depth + 1);

}
}

void listDirectory(SplayTree t) {
listDir(t, 0);
}

main.c

#include"SplayTree.h"
#include<stdio.h>
#include<stdlib.h>

struct SplayNode {
ElementType element;
SplayTree left;
SplayTree right;
};

int main() {
SplayTree t = createSplayTree();

for (int i = 0; i < 15; i++)
t = insert(rand(), t);
listDirectory(t);

}