二叉排序数（创建，插入，删除，查找及前序、中序、后序遍历）

// erchapaixushu.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include <iostream>

#include "stdlib.h"

#include <stack>

using namespace std;

class Node

{

public:
int data;
Node *parent;
Node*left;
Node *right;
int tag;//标志位，用于后序遍历中找左子树，还是右子树

public:
Node() :data(-1), parent(NULL), left(NULL), right(NULL), tag(0)
{
};
Node(int num) :data(num), parent(NULL), left(NULL), right(NULL), tag(0)
{
};

};

class Tree

{

public:
Tree(int num[], int len);
void insertNode1(int data);//非递归
void insertNode(int data);//递归
Node * searchNode(int data);
void deleteNode(int data);

void inOrderThee();//中序遍历递归方法
void inOrderFeiDiGuiThee(); //中序遍历非递归方法

void preOrderThee();//前序遍历递归方法
void preOrderFeiDiGuiThee(); //前序遍历非递归方法

void lastOrderThee();//后序遍历递归方法
void lastOrderFeiDiGuiThee(); //后序遍历非递归方法

~Tree();

private:
void insertNode(Node*current, int data);
Node * searchNode(Node*current, int data);
void delteNode(Node*current);
void inOrderThee(Node * current);
void preOrderThee(Node * current);
void lastOrderThee(Node * current);

private:
Node * root;

};

//构造函数

Tree::Tree(int num[], int len)

{
root = new Node(num[0]);
for (int i = 0; i < len; i++)
{
//insertNode1(num[i]);
insertNode(num[i]);
}

}

void Tree::insertNode1(int data)//fei递归

{
Node*p, *par;
Node*newNode = new Node(data);
p = par = root;
while (p != NULL)
{
par = p;
if (data > p->data)
{
p = p->right;
}
else if (data < p->data)
{
p = p->left;
}
else
{
delete newNode;
return;
}
}

newNode->parent = par;

if (par->data > newNode->data)
{
par->left = newNode;
}
else
{
par->right = newNode;
}

}

void Tree::insertNode(int data)//递归

{
if (root != NULL)
{
insertNode(root, data);
}

}

Node * Tree::searchNode(int data)

{
Node *current = NULL;
if (root != NULL)
{
current = searchNode(root, data);
}
return current;

}

void Tree::deleteNode(int data)

{
Node * current = NULL;
current = searchNode(data);
if (current != NULL)
{
delteNode(current);
}

}

void Tree::insertNode(Node*current, int data)

{
if (data < current->data)
{
if (current->left ==NULL)
{
current->left = new Node(data);
current->left->parent = current;
}
else
{
insertNode(current->left, data);
}
}
else if(data > current->data)
{
if (current->right == NULL)
{
current->right = new Node(data);
current->right->parent = current;
}
else
{
insertNode(current->right, data);
}
}
return;

}

Node * Tree::searchNode(Node*current, int data)

{
if (data < current->data)
{
if (current->left == NULL)
{
return NULL;
}
return  searchNode(current->left, data);
}
else if (data > current->data)
{
if (current->right == NULL)
{
return NULL;
}
return  searchNode(current->right, data);
} 

return current;

}

void Tree::delteNode(Node*current)

{
if (current->left !
4000
= NULL)
{
delteNode(current->left);
}
if (current->right!=NULL)
{
delteNode(current->right);
}
if (current->parent == NULL)
{
delete current;
root = NULL;
return;
}
if (current->parent->data > current->data)
{
current->parent->left = NULL;
}
else
{
current->parent->right = NULL;
}

delete current;

}

void Tree::inOrderThee()

{
if (root == NULL)
{
return;
}
inOrderThee(root);

}

void Tree::inOrderThee(Node * current)

{
if (current!=NULL)
{
inOrderThee(current->left);
cout << current->data << "   ";
inOrderThee(current->right);
}

}

void Tree::inOrderFeiDiGuiThee()

{
stack<Node*>s;
Node *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
s.push(p);
p = p->left;
}
if (!s.empty())
{
p = s.top();
s.pop();
cout << p->data << "  ";
p = p->right;

}
}

}

void  Tree::preOrderThee()//前序遍历递归方法

{
if (root == NULL)
{
return;
}
preOrderThee(root);

}

void  Tree::preOrderFeiDiGuiThee() //前序遍历非递归方法

{
stack<Node*>s;
Node *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
cout << p->data << "  ";
s.push(p);
p = p->left;
}
if (!s.empty())
{
p = s.top();
s.pop();
p = p->right;
}
}

}

void  Tree::lastOrderThee()//前序遍历递归方法

{
if (root == NULL)
{
return;
}
lastOrderThee(root);

}

void  Tree::lastOrderFeiDiGuiThee() //前序遍历非递归方法

{
stack<Node*>s;
Node *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)
{
s.push(p);
p = p->left;
}
if (!s.empty())
{
p = s.top();
if (p->tag)
{
cout << p->data << "  ";
s.pop();
p = NULL;
}
else
{
p->tag = 1;
p = p->right;
}
}
}

}

void Tree::preOrderThee(Node * current)

{
if (current != NULL)
{
cout << current->data << "   ";
preOrderThee(current->left);

preOrderThee(current->right);
}

}

void Tree::lastOrderThee(Node * current)

{
if (current != NULL)
{
lastOrderThee(current->left);
lastOrderThee(current->right);
cout << current->data << "   ";
}

}

Tree::~Tree()

{

}

int main()

{
int num[] = { 5,3,7,2,4,6,8,1 };
Tree tree(num, 8);

cout << "inorder";
tree.inOrderThee();
cout << "\ninorder:";
tree.inOrderFeiDiGuiThee();

cout << "\npreorder";
tree.preOrderThee();
cout << "\npreorder:";
tree.preOrderFeiDiGuiThee();

cout << "\nlastorder";
tree.lastOrderThee();
cout << "\nlastorder:";
tree.lastOrderFeiDiGuiThee();

system("pause");
return 0;

}