二叉搜索树

二叉搜索树的建立是通过递归方式来建立的，和普通的二叉树的区别是加上了约束， 它的左子树的所有元素都要比根节点要小， 而右子树的所有元素都要根节点要大，左右子树也符合这个条件。他的遍历方式和普通二叉树的遍历没有什么区别。

下面是关于二叉搜索树的添加节点和前序遍历，中序遍历， 后续遍历和层级遍历

//递归创建添加新节点
void insertNode(PNode *root, ItemType data)
{
    if(*root == NULL)
    {
        *root = (PNode)malloc(sizeof(Node));
        (*root)->data = data;
        (*root)->lchild = (*root)->rchild = NULL;
    }
    else
    {
        if(data < (*root)->data)
            insertNode(&(*root)->lchild, data);
        else
            insertNode(&(*root)->rchild, data);
    }
}
//递归前序遍历
void preOrder(PNode root)
{
    if(root == NULL)
        return;
    printf("%d ", root->data);
    preOrder(root->lchild);
    preOrder(root->rchild);
}
//递归中序遍历
void inOrder(PNode root)
{
    if(root == NULL)
        return;
    inOrder(root->lchild);
    printf("%d ", root->data);
    inOrder(root->rchild);
}
//递归后续遍历
void postOrder(PNode root)
{
    if(root == NULL)
        return;
    postOrder(root->lchild);
    postOrder(root->rchild);
    printf("%d ", root->data);
}


//层级遍历
void levelOrder(PNode root)
{
    queue<PNode> q;
    PNode p = root;
    if(p != NULL)
        q.push(p);
    while(!q.empty())
    {
        p = q.front();
        printf("%d ", p->data);
        if(p->lchild != NULL)
            q.push(p->lchild);
        if(p->rchild != NULL)
            q.push(p->rchild);
        q.pop();
    }
}

以上这些操作除了插入有点特殊之外和普通的二叉树没有什么区别，下面主要来说二叉树的非递归遍历方法， 其中包括前序，中序和后续。其中前序和中序差不多，比较好理解点。

前序主要就是打印出节点的值， 再将左子树入栈，出栈时再栈顶的遍历右子树。下面是代码的实现

void preOrder_NonRecursion(PNode root)
{
    stack<PNode> s;
    PNode p = root;
    while(p != NULL || !s.empty())
    {
        if(p != NULL)//如果存在，继续找他的左孩子
        {
            printf("%d ", p->data);
            s.push(p);
            p = p->lchild;
        }
        else//没有的话，将p指向栈顶的元素，出栈操作，继续找右孩子
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}

非递归的中序遍历和前序差不多，就改变输出的值，因为前序遍历是先根再左再右， 而中序是左根右， 所以只是输出顺序不同了而已

//非递归中序遍历
void inOrder_NonRecursion(PNode root)
{
    stack<PNode> s;
    PNode p = root;
    while(p != NULL || !s.empty())
    {
        if(p != NULL)//左孩子不为空就进栈，继续它的左孩子
        {
            s.push(p);
            p = p->lchild;
        }
        else//输出栈顶的元素，然后出栈，找它右兄弟(程序中是先找父亲，然后找父亲的右孩子)
        {
            p = s.top();
            printf("%d ", p->data);
            s.pop();
            p = p->rchild;
        }
    }
}

非递归的后续遍历稍微比前序和中序复杂了一点，但也不是很复杂，因为后续遍历是先左后右再根的， 所以根是最后的，所以加了一个布尔变量来标记他的右子树遍历了没有，其它的和前序和中序没什么大的区别， bool变量为true的时候说明他的右子树还没有遍历。false是已经遍历过了

void postOrder_NonRecursion(PNode root)
{
    stack<pair<PNode, bool> > s;//用pair使s 的类型为PNode和bool的复合类型
    PNode p = root;
    while(p != NULL || !s.empty())
    {
        if(p != NULL)//如果当前节点不为空的话，入栈， 继续找它的左孩子
        {
            s.push(make_pair(p, false));//初始的时候没有遍历他的右子树
            p = p->lchild;
        }
        else//否则去栈顶
        {
            if(s.top().second == false)//如果它的右子树没有没遍历
            {
                s.top().second = true;//标记已经遍历过
                p = s.top().first->rchild;//遍历右子树
            }
            else//遍历过了，直接输出， 因为此时节点为当前树的根节点
            {
                printf("%d ", s.top().first->data);
                s.pop();
            }
        }
    }
}

还有就是求树的高度， 一般是用递归来实现， 递归比价好理解， 代码也比较简洁， 但是有时候也需要非递归方式来求，下面是递归方式求的， 比较简单

//递归求树的深度
int getDepth(PNode root)
{
    int d1, d2;
    if(root == NULL)
        return 0;
    d1 = getDepth(root->lchild);
    d2 = getDepth(root->rchild);
    return (d1 > d2 ? d1 : d2) + 1;
}

非递归的方式求书的高度的思想是：一层一层的遍历， 当遍历一层的时候， 层数加一， 但是怎么确定这层是否遍历完呢， 这时就需要三个变量来合作记录了，一个last_level_number来记录以上层一共有多少个入队的， in_queue_number 来记录所有入队的了有几个， 还有一个是visit_number来记录当前已经出队了几个元素了， 也就是有多少个节点已经扩展了子节点， 也就是广搜的那个扩展， 主要还是利用层级遍历的思想， 需要一个队列

//非递归求数的深度
int getDepth_NonRecursion(PNode root)
{
    if(root == NULL)
        return 0;
    queue<PNode> q;
    PNode p = root;
    q.push(p);
    int last_level_number = 1;//用来标记一共有多少个曾经入过队
    int visit_number = 0;//记录已经扩展了的节点
    int in_queue_number = 1;//所有入队的有所少个
    int height = 0;
    while (!q.empty())
    {
        visit_number++;//出队一次加一个， 也就是扩展一次， 加一次
        p = q.front();
        q.pop();
        //分别扩展它的左孩子和右孩子
        if (p->lchild != NULL)
        {
            q.push(p->lchild);
            in_queue_number++;
        }
        if(p->rchild != NULL)
        {
            q.push(p->rchild);
            in_queue_number++;
        }
        //如果到一层的结尾
        if(visit_number == last_level_number)
        {
            height++;
            last_level_number = in_queue_number;//更新last_level_number
        }
    }
    return height;
}

还有就是求二叉搜索树中任意给定两个节点的最近的共同祖先， 这里是二叉搜索树比较简单， 如果不是二叉搜索树就比较麻烦了，暂时只说二叉搜索树的， 非二叉搜索树的后面补上。

主要思想是:利用二叉搜索树的性质， 任意的左孩子都比根节点小， 任意的右节点都比根节点大， 所以，直接拿着两个点和根节点进行比价， 如果都比根节点大的话， 就说明共同祖先肯定在根节点的右边， 如果都小的话， 就说明都在根节点的左边， 如果一小一大那就好办了， 直接就是根节点了， 继续找左子树或者右子树。下面是代码的实现'

//求两节点的最近的共同祖先
void getCommonAncestor(PNode root, ItemType n1, ItemType n2)
{
    if(root == NULL)
        return;
    while((n1 < root->data && n2 < root->data) || (n1 > root->data && n2 > root->data) )
    {
        if(n1 < root->data)
            root = root->lchild;
        else
            root = root->rchild;
    }
    printf("latest common ancestor: %d\n", root->data);
}

求二叉树的镜像，二叉树的镜像的意思就是将他的各个左右节点都反过来， 听着很麻烦， 其实递归很简单的， 只需要先把他的左右子树交换过来， 然后再继续递归他的左右子树就行了

代码如下：

//求二叉树的镜像
void mirror(PNode root)
{
    if(root != NULL)
    {
        //交换它的左右子树
        PNode p = root->lchild;
        root->lchild = root->rchild;
        root->rchild = p;
        //递归它的左右子树
        mirror(root->lchild);
        mirror(root->rchild);
    }
}

 

下面是所有的实现的完整代码

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stack>
#include <queue>

using namespace std;

typedef int ItemType;
typedef struct Node{
    ItemType data;
    struct Node *lchild, *rchild;
}Node, *PNode;
//递归创建添加新节点
void insertNode(PNode *root, ItemType data)
{
    if(*root == NULL)
    {
        *root = (PNode)malloc(sizeof(Node));
        (*root)->data = data;
        (*root)->lchild = (*root)->rchild = NULL;
    }
    else
    {
        if(data < (*root)->data)
            insertNode(&(*root)->lchild, data);
        else
            insertNode(&(*root)->rchild, data);
    }
}
//递归前序遍历
void preOrder(PNode root)
{
    if(root == NULL)
        return;
    printf("%d ", root->data);
    preOrder(root->lchild);
    preOrder(root->rchild);
}
//递归中序遍历
void inOrder(PNode root)
{
    if(root == NULL)
        return;
    inOrder(root->lchild);
    printf("%d ", root->data);
    inOrder(root->rchild);
}
//递归后续遍历
void postOrder(PNode root)
{
    if(root == NULL)
        return;
    postOrder(root->lchild);
    postOrder(root->rchild);
    printf("%d ", root->data);
}
//非递归前序遍历
void preOrder_NonRecursion(PNode root)
{
    stack<PNode> s;
    PNode p = root;
    while(p != NULL || !s.empty())
    {
        if(p != NULL)//如果存在，继续找他的左孩子
        {
            printf("%d ", p->data);
            s.push(p);
            p = p->lchild;
        }
        else//没有的话，将p指向栈顶的元素，出栈操作，继续找右孩子
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}
//非递归中序遍历
void inOrder_NonRecursion(PNode root)
{
    stack<PNode> s;
    PNode p = root;
    while(p != NULL || !s.empty())
    {
        if(p != NULL)//左孩子不为空就进栈，继续它的左孩子
        {
            s.push(p);
            p = p->lchild;
        }
        else//输出栈顶的元素，然后出栈，找它右兄弟(程序中是先找父亲，然后找父亲的右孩子)
        {
            p = s.top();
            printf("%d ", p->data);
            s.pop();
            p = p->rchild;
        }
    }
}
//非递归后续遍历
void postOrder_NonRecursion(PNode root)
{
    stack<pair<PNode, bool> > s;//用pair使s 的类型为PNode和bool的复合类型
    PNode p = root;
    while(p != NULL || !s.empty())
    {
        if(p != NULL)//如果当前节点不为空的话，入栈， 继续找它的左孩子
        {
            s.push(make_pair(p, false));//初始的时候没有遍历他的右子树
            p = p->lchild;
        }
        else//否则去栈顶
        {
            if(s.top().second == false)//如果它的右子树没有没遍历
            {
                s.top().second = true;//标记已经遍历过
                p = s.top().first->rchild;//遍历右子树
            }
            else//遍历过了，直接输出， 因为此时节点为当前树的根节点
            {
                printf("%d ", s.top().first->data);
                s.pop();
            }
        }
    }
}
//层级遍历
void levelOrder(PNode root)
{
    queue<PNode> q;
    PNode p = root;
    if(p != NULL)
        q.push(p);
    while(!q.empty())
    {
        p = q.front();
        printf("%d ", p->data);
        if(p->lchild != NULL)
            q.push(p->lchild);
        if(p->rchild != NULL)
            q.push(p->rchild);
        q.pop();
    }
}
//求一层的所有节点
void specifyLevelNode(PNode root, int h)//h是指定的高度
{
    if(root == NULL)
        return;
    queue<PNode> q;
    PNode p = root;
    q.push(p);
    int last_level_number = 1;//用来标记以上所有层多少个
    int visit_number = 0;
    int in_queue_number = 1;//入队的多少个
    int height = 0;
    while (!q.empty())
    {
        visit_number++;
        p = q.front();
        q.pop();

        if (p->lchild != NULL)
        {
            q.push(p->lchild);
            in_queue_number++;
            if (h - 2 == height)/*因为这个高度执行到后面才++， 所以h要减一，
            还有就是当前是p->lchild而不是p，所以在减一*/
                printf("%d ", p->lchild->data);
        }
        if(p->rchild != NULL)
        {
            q.push(p->rchild);
            in_queue_number++;
            if (h - 2== height)//同上
                printf("%d ", p->rchild->data);
        }

        if(visit_number == last_level_number)
        {
            height++;
            last_level_number = in_queue_number;
        }
    }
}
//递归求树的深度
int getDepth(PNode root)
{
    int d1, d2;
    if(root == NULL)
        return 0;
    d1 = getDepth(root->lchild);
    d2 = getDepth(root->rchild);
    return (d1 > d2 ? d1 : d2) + 1;
}
//非递归求数的深度
int getDepth_NonRecursion(PNode root)
{
    if(root == NULL)
        return 0;
    queue<PNode> q;
    PNode p = root;
    q.push(p);
    int last_level_number = 1;//用来标记一共有多少个曾经入过队
    int visit_number = 0;//记录已经扩展了的节点
    int in_queue_number = 1;//所有入队的有所少个
    int height = 0;
    while (!q.empty())
    {
        visit_number++;//出队一次加一个， 也就是扩展一次， 加一次
        p = q.front();
        q.pop();
        //分别扩展它的左孩子和右孩子
        if (p->lchild != NULL)
        {
            q.push(p->lchild);
            in_queue_number++;
        }
        if(p->rchild != NULL)
        {
            q.push(p->rchild);
            in_queue_number++;
        }
        //如果到一层的结尾
        if(visit_number == last_level_number)
        {
            height++;
            last_level_number = in_queue_number;//更新last_level_number
        }
    }
    return height;
}
//求二叉树中相距最远的两个节点之间的距离
int getMaxDistance(PNode root)
{
    if(root == NULL)
        return 0;
    return getDepth(root->lchild) + getDepth(root->rchild);
}
//求两节点的最近的共同祖先
void getCommonAncestor(PNode root, ItemType n1, ItemType n2)
{
    if(root == NULL)
        return;
    while((n1 < root->data && n2 < root->data) || (n1 > root->data && n2 > root->data) )
    {
        if(n1 < root->data)
            root = root->lchild;
        else
            root = root->rchild;
    }
    printf("latest common ancestor: %d\n", root->data);
}

//求路径和为指定值的所有路径

int main()
{

    PNode root = NULL;
    int test[8] = {8, 5, 16, 1, 4, 9, 24, 7};
    for(int i = 0; i < 8; i++)
    {
        insertNode(&root, test[i]);
    }
    printf("Previous Order Traverse:\n");
    preOrder(root);
    printf("\nIn Order Traverse:\n");
    inOrder(root);
    printf("\nPost Order Traverse:\n");
    postOrder(root);
    printf("\nNon-Recursion Previous Order Traverse:\n");
    preOrder_NonRecursion(root);
    printf("\nNon-Recursion In Order Traverse:\n");
    inOrder_NonRecursion(root);
    printf("\nNon-Recursion Post Order Traverse:\n");
    postOrder_NonRecursion(root);
    printf("\nLevel Order Traverse:\n");
    levelOrder(root);
    printf("\nThe depth of tree: %d\n", getDepth(root));
    printf("The depth of tree(Non-Recursion): %d\n", getDepth_NonRecursion(root));
    specifyLevelNode(root, 3);//求第三层的所有节点
    printf("\nThe max distance: %d\n", getMaxDistance(root));
    getCommonAncestor(root, 7, 4);//测试数据，得出7和4的最近祖先

    return 0;
}