- 将关键字(DEC, FEB, NOV, OCT, JUL, SEP, AUG, APR, MAR, MAY, JUN, JAN)按字母顺序依次插入到一棵初始为空的AVL树中,画出每插入一个关键字后的AVL树,并标明平衡旋转的类型。在所建立的AVL树中删除关键字MAY,为保持AVL树的特性,应如何进行删除和调整? 若接着删除关键字FEB,又应如何删除与调整?
// AVLTree.cpp: 定义控制台应用程序的入口点。
//平衡二叉树
//
#include<stdio.h>
#include<stdlib.h>
#include<stack>
#include<queue>
#include<string>
#include<iostream>
using namespace std;
typedef int dataType;
#define EH 0 //左右子树一样高
#define LH 1 //左子树比右子树高
#define RH -1 //右子树比左子树高
//定义节点结构
typedef struct Node {
dataType keyValue; //数据
int BalanceFactor; //平衡因子
struct Node *leftChild, *rightChild;
}*PNode;
//为新建一个节点
PNode createNode(dataType keyValue) {
PNode newNode = (PNode)malloc(sizeof(Node));
newNode->keyValue = keyValue;
newNode->BalanceFactor = EH;
newNode->leftChild = NULL;
newNode->rightChild = NULL;
return newNode;
}
//右旋 顺时针旋转
void R_Rotate(PNode* node) {
PNode tmp = (*node)->leftChild;
(*node)->leftChild = tmp->rightChild;
tmp->rightChild = (*node);
(*node) = tmp;
}
//左旋,逆时针旋转
void L_Rotate(PNode* node) {
PNode tmp = (*node)->rightChild;
(*node)->rightChild = tmp->leftChild;
tmp->leftChild = (*node);
(*node) = tmp;
}
//左边失衡调整
void leftBalance(PNode* node) {
PNode leftchild = (*node)->leftChild;
PNode tmpRightChild = NULL;
switch (leftchild->BalanceFactor)
{
case LH: //LL型失衡
(*node)->BalanceFactor = leftchild->BalanceFactor = EH;
R_Rotate(node);
break;
case RH: //LR型失衡
tmpRightChild = leftchild->rightChild;
switch (tmpRightChild->BalanceFactor)
{
case LH:
(*node)->BalanceFactor = RH;
leftchild->BalanceFactor = EH;
break;
case EH:
(*node)->BalanceFactor = leftchild->BalanceFactor = EH;
break;
case RH:
(*node)->BalanceFactor = EH;
leftchild->BalanceFactor = LH;
break;
}
tmpRightChild->BalanceFactor = EH;
L_Rotate(&(*node)->leftChild);
R_Rotate(node);
break;
}
}
//右边失衡调整
void rightBalance(PNode* node) {
PNode rightchild = (*node)->rightChild;
PNode tmpChild = NULL;
switch (rightchild->BalanceFactor)
{
case RH: //RR型失衡
(*node)->BalanceFactor = rightchild->BalanceFactor = EH;
L_Rotate(node);
break;
case LH: //RL型失衡
tmpChild = rightchild->leftChild;
switch (tmpChild->BalanceFactor)
{
case LH:
(*node)->BalanceFactor = EH;
rightchild->BalanceFactor = RH;
break;
case EH:
(*node)->BalanceFactor = rightchild->BalanceFactor = EH;
break;
case RH:
(*node)->BalanceFactor = EH;
rightchild->BalanceFactor = LH;
break;
}
tmpChild->BalanceFactor = EH;
R_Rotate(&(*node)->rightChild);
L_Rotate(node);
break;
}
}
//插入新值,higher用于判定是否需要调整平衡因子
int InsertKeyValue(PNode* node, dataType keyValue,bool* higher) {
if ((*node) == NULL) { //树中不包含此键值,则新建一个节点,
(*node) = createNode(keyValue);
*higher=true;
}
else if ((*node)->keyValue == keyValue) { //树中已经包含此键值,则不需要插入
*higher = false;
return 0;
}
else if (keyValue < (*node)->keyValue) { //插入到左子树中
if (!InsertKeyValue(&(*node)->leftChild, keyValue, higher)) //如果左子树中存在该节点
return 0;
if (*higher) {
switch ((*node)->BalanceFactor)
{
case LH:
leftBalance(node);
*higher = false;
break;
case RH:
(*node)->BalanceFactor = EH;
*higher = false;
break;
case EH:
(*node)->BalanceFactor = LH;
*higher = true;
break;
}
}
}
else {
if (!InsertKeyValue(&(*node)->rightChild, keyValue,higher)) //如果右子树中存在该节点
return 0;
if (*higher) {
switch ((*node)->BalanceFactor)
{
case LH:
(*node)->BalanceFactor = EH;
*higher = false;
break;
case RH:
rightBalance(node);
*higher = false;
break;
case EH:
(*node)->BalanceFactor = RH;
*higher = true;
break;
}
}
}
return 1;
}
//按关系输出,便于检验数的构造是否正确
void printfTree(PNode root) {
if (root) {
if (root->leftChild) {
printf("%d is %d's left child\n", root->leftChild->keyValue, root->keyValue);
printfTree(root->leftChild);
}
if (root->rightChild) {
printf("%d is %d's right child\n", root->rightChild->keyValue, root->keyValue);
printfTree(root->rightChild);
}
}
}
/*=================================遍历:递归和非递归=========================*/
//中序--递归
void InorderTra(PNode root) {
if (root) {
InorderTra(root->leftChild);
printf("%d\t", root->keyValue);
InorderTra(root->rightChild);
}
}
//中序--非递归
void InorderTra2(PNode root) {
if (!root) {
printf("树为空!\n");
}
stack<PNode> myStack;
while (root|| !myStack.empty()) { //找到最左边的节点,并将路径上的几点压入栈中
while (root)
{
myStack.push(root);
root = root->leftChild;
}
root = myStack.top(); //取栈顶的值
myStack.pop(); //从栈中删除
printf("%d\t", root->keyValue);
root=root->rightChild;
}
printf("\n");
}
//前序遍历
//前序--递归
void PreOrderTra(PNode root) {
if (root != NULL) {
printf("%d\t", root->keyValue);
PreOrderTra(root->leftChild);
PreOrderTra(root->rightChild);
}
}
//前序--非递归
void PreOrderTra2(PNode root) {
if (!root) {
printf("树为空!\n");
}
stack<PNode> myStack;
while (root || !myStack.empty()) {
while (root)
{
myStack.push(root);
printf("%d\t", root->keyValue);
root = root->leftChild;
}
root = myStack.top();
myStack.pop();
root = root->rightChild;
}
printf("\n");
}
//后序遍历
//后序--递归
void PostOrderTra(PNode root) {
if (root) {
PostOrderTra(root->leftChild);
PostOrderTra(root->rightChild);
printf("%d\t", root->keyValue);
}
}
//后序--非递归
void PostOrderTra2(PNode root) {
int flag[30]; //用一个标记,标记右子树是否访问过
stack<PNode> myStack;
if (!root) {
printf("树为空!\n");
return;
}
while (root !=NULL ) { //首先将所有的左子树入栈
myStack.push(root);
flag[myStack.size()] = 0;
root = root->leftChild;
}
while (!myStack.empty()) {
root = myStack.top();
if (root->rightChild&&flag[myStack.size()] == 0) { //如果是第一次访问,则还不能输出,需要找到其右子树,将右子树入栈
flag[myStack.size()] = 1;
root = root->rightChild;
while (root)
{
myStack.push(root);
flag[myStack.size()] = 0;
root = root->leftChild;
}
}
root = myStack.top(); //第二次出栈,可以输出了
printf("%d\t", root->keyValue);
myStack.pop();
}
printf("\n");
}
//按层次遍历
//辅助函数,求树的最大深度
int getDeep(PNode root) {
if (!root) {
return 0;
}
int leftDeep = getDeep(root->leftChild) + 1;
int rightDeep = getDeep(root->rightChild) + 1;
return leftDeep > rightDeep ? leftDeep : rightDeep;
}
//输出指定的层,将根节点视为0层
int LevelOrderTra(PNode root,int level) {
if (!root || level < 0) {
printf("%s\t", "NULL");
return 0;
}
if (level == 0) {
printf("%d\t", root->keyValue);
return 1;
}
return LevelOrderTra(root->leftChild, level - 1) + LevelOrderTra(root->rightChild, level - 1);
}
//从根节点开始打印出所有层
void printByLevel(PNode root, int deep) {
for (int i = 0; i < deep; i++) {
LevelOrderTra(root, i);
}
printf("\n");
}
//法2,利用队列,实现安层次遍历
void printByLevel2(PNode root) {
if (!root) {
printf("树为空!\n");
}
queue<PNode> myQueue;
myQueue.push(root);
while (!myQueue.empty()) {
root = myQueue.front();
myQueue.pop();
printf("%d\t", root->keyValue);
if (root->leftChild)myQueue.push(root->leftChild);
if (root->rightChild) myQueue.push(root->rightChild);
}
}
/*=====================查找===================*/
int SearchTree(PNode root, dataType key) {
if (root->keyValue == key) {
return 1;
}
else if (key > root->keyValue && root->rightChild) {
return SearchTree(root->rightChild, key);
}
else if(key < root->keyValue && root->leftChild) {
return SearchTree(root->leftChild, key);
}
else {
return 0;
}
}
/*=======================删除==================*/
bool delNode(PNode &root, dataType key,bool &shorter) {
if (root == NULL) {
return false;
}
else if (key == root->keyValue) {
PNode tmp = NULL;
if (root->leftChild == NULL) {
tmp = root;
root = root->rightChild;
delete tmp;
shorter = true;
}
else if (root->rightChild == NULL) {
tmp = root;
root = root->leftChild;
delete tmp;
shorter = true;
}
else {
tmp = root->leftChild;
while (tmp->rightChild) {
tmp = tmp->rightChild;
}
root->keyValue = tmp->keyValue;
delNode(root->leftChild, tmp->keyValue, shorter);
}
}
else if (key < root->keyValue) {
if (!delNode(root->leftChild, key, shorter)) {
return false;
}
if (shorter) {
switch (root->BalanceFactor)
{
case LH:
root->BalanceFactor = EH;
shorter = true;
break;
case RH:
rightBalance(&root);
if (root->rightChild->BalanceFactor == EH) {
shorter = false;
}
else {
shorter = true;
}
break;
case EH:
root->BalanceFactor = RH;
shorter = false;
break;
}
}
}
else {
if (!delNode(root->rightChild, key, shorter)) {
return false;
}
if (shorter) {
switch (root->BalanceFactor)
{
case LH:
leftBalance(&root);
if (root->leftChild->BalanceFactor == EH) {
shorter = false;
}
else {
shorter = true;
}
break;
case EH:
root->BalanceFactor = LH;
shorter = false;
break;
case RH:
root->BalanceFactor = EH;
shorter = true;
break;
}
}
}
return true;
}
//void delNode2(PNode &root, dataType key) {
// if (!root) {
// printf("树为空!\n");
// return;
// }
// else if (!SearchTree(root, key)) {
// printf("树中不存在值为%d的节点\n", key);
// }else{
// PNode current = root;
// while (current->keyValue != key) {
// if (key < current->keyValue) current = current->leftChild;
// else current = current->rightChild;
// }
// if (current->leftChild && current->rightChild) {
// PNode minNode = current->rightChild;
// while (minNode) {
// minNode = minNode->leftChild;
// }
// current->keyValue = minNode->keyValue;
// PNode tmp = minNode;
// minNode = minNode->rightChild;
// delete tmp;
// }
// else if (current->leftChild || current->rightChild) {
// PNode tmp=current;
// current = current->leftChild ? current->leftChild : current->rightChild;
// delete tmp;
// }
// else {
// PNode tmp=current;
// current =NULL;
// delete tmp;
// }
// }
//}
int main()
{
//将关键字(DEC, FEB, NOV, OCT, JUL, SEP, AUG, APR, MAR, MAY, JUN, JAN)按字
string ts[12]={"DEC", "FEB",
"NOV", "OCT",
"JUL","SEP",
"AUG","APR",
"MAR","MAY",
"JUN","JAN"};
sort(ts,ts+12);
for(int i=0;i<12;i++)
std::cout<<ts[i]<<std::endl;
int i, dataArr[] = { 3,4,10,11,6,12,2,1,8,9,7,5};
PNode treeRoot = NULL;
bool heigher;
for (i = 0; i < 12; i++) {
InsertKeyValue(&treeRoot, dataArr[i],&heigher);
printfTree(treeRoot);
printf("\n\n");
}
/*printf("中序遍历是:");
InorderTra(treeRoot);
printf("\n");
InorderTra2(treeRoot);*/
/*printf("前序遍历是:");
PreOrderTra(treeRoot);
printf("\n");
PreOrderTra2(treeRoot);*/
/*printf("后序遍历是:");
PostOrderTra(treeRoot);
printf("\n");
PostOrderTra2(treeRoot);*/
/*printf("deep:%d\n", getDeep(treeRoot));*/
printf("层次遍历是:");
printByLevel(treeRoot, getDeep(treeRoot));
printf("\n");
/*printByLevel2(treeRoot);*/
//测试查找
/*while (true)
{
printf("请输入要查找的值:");
int key;
scanf("%d", &key);
printf("\n查找结果:%d\n", SearchTree(treeRoot, key));
}*/
//测试删除
while (true)
{
printf("请输入要删除的值:");
int key;
scanf("%d", &key);
bool shoter = false;
delNode(treeRoot, key,shoter);
/*delNode2(treeRoot, key);*/
printByLevel(treeRoot,4);
}
return 0;
}