将搜索二叉树转换成双向链表

【说明】：

　　本文是左程云老师所著的《程序员面试代码指南》第二章中“将搜索二叉树转换成双向链表”这一题目的C++复现。

　　本文只包含问题描述、C++代码的实现以及简单的思路，不包含解析说明，具体的问题解析请参考原书。

　　感谢左程云老师的支持。

【题目】：

　　对于二叉树的节点来说，有本身的值域，有指向左孩子和右孩子的两个指针；对双向链表的节点来说，有本身的值域，有指向上一个节点和下一个节点的指针。在结构上，两种结构有相似性，现有一棵搜索二叉树，请将其转为成一个有序的双向链表。

　　例如，节点定义为：

 class Node
  8 {
  9 public:
 10     Node(int data)
 11     {
 12         value = data;
 13         left = NULL;
 14         right = NULL;
 15     }
 16 public: 
 17     int value;
 18     Node *left;
 19     Node *right;
 20 };

　　一棵搜索二叉树如图所示。

　　

　　这棵二查搜索树转换后的双向链表从头到尾依次是 1～9。对于每一个节点来说，原来的 right 指针等价于转换后的 next 指针，原来的 left 指针等价于转换后的 last 指针，最后返回转换后的双向链表的头节点。

　　注：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。　　

 【思路】：

　　解法一：利用队列和二叉树的中序遍历；

　　解法二：递归实现，递归的返回值为链表的尾部节点，并且将尾部节点的 right 指向头节点；

【编译环境】：

　　CentOS6.7（x86_64）

　　gcc 4.4.7

 【实现】：

　　头文件声明代码：

/*
 *文件名：bt_convert_list.h
 *作者：
 *摘要：声明文件
 */
#include <iostream>
#include <queue>

using namespace std;

class Node
{
public:
    Node(int data)
    {
        value = data;
        left = NULL;
        right = NULL;
    }
public:
    int value;
    Node *left;
    Node *right;
};

void bt_insert(Node **head,int data);    //搜索二叉树之插入节点
void preOrderRecur(Node *head);    //先序遍历输出二叉树节点值

//第一种转换方法
void inOrderToQueue(Node *head,queue<Node*> &q);
Node* convert1(Node *head);
//第二种转换方法
Node* process(Node *head);
Node* convert2(Node *head);

void printList(Node *head);    //打印链表值

　　实现代码：

/*
 *文件名：bt_convert_list.cpp
 *作者
 *摘要：将搜索二叉树转换成双向链表
 */

#include "bt_convert_list.h"

//搜索二叉树之插入节点
void bt_insert(Node **head,int data)
{
    if(NULL == *head)    //根节点为空
    {
        *head = new Node(data);
        return ;
    }

    if(NULL == (*head)->left && data < (*head)->value)    //插入左孩子
    {
        (*head)->left = new Node(data);
        return ;
    }

    if(NULL == (*head)->right && data > (*head)->value)    //插入右孩子
    {
        (*head)->right = new Node(data);
        return ;
    }
    
    if(data < (*head)->value)
        bt_insert(&((*head)->left),data);
    else if(data > (*head)->value)
        bt_insert(&((*head)->right),data);
    else
        return ;
}

//先序遍历
void preOrderRecur(Node *head)
{
    if(NULL == head)
        return ;
    cout << head->value << " ";
    preOrderRecur(head->left);
    preOrderRecur(head->right);
}

//利用中序遍历将二叉树节点插入队列中
void inOrderToQueue(Node *head,queue<Node*> &q)
{
    if(NULL == head)
        return ;
    inOrderToQueue(head->left,q);
    q.push(head);
    inOrderToQueue(head->right,q);
    return ;
}

Node* convert1(Node *head)
{
    queue<Node*> q;
    inOrderToQueue(head,q);
    //处理头节点
    head = q.front();
    q.pop();
    Node *pre = head;
    pre->left = NULL;
    
    Node *cur = NULL;
    while(!q.empty())
    {
        cur = q.front();
        q.pop();
        pre->right = cur;
        cur->left = pre;
        pre = cur;
    }
    cur->right = NULL;
    return head;
}

//第二种方法
Node* process(Node *head)
{
    if(NULL == head)
        return NULL;
    Node *leftE = process(head->left);
    Node *rightE = process(head->right);

    Node *leftS = NULL != leftE ? leftE->right : NULL ;
    Node *rightS = NULL != rightE ? rightE->right : NULL ;

    if(NULL != leftE && NULL != rightE)
    {
        leftE->right = head;
        head->left = leftE;
        head->right = rightS;
        rightS->left = head;
        rightE->right = leftS;        //尾指向头
        return rightE;        //返回尾部指针
    }
    else if(NULL != leftE)
    {
        leftE->right = head;
        head->left = leftE;
        head->right = leftS;    //尾指向头
        return head;    //返回尾部指针
    }
    else if(NULL != rightE)
    {
        head->right = rightS;
        rightS->left = head;
        rightE->right = head;    //尾指向头
        return rightE;            //返回尾
    }
    else
    {
        head->right = head;        //尾指向头
        return head;            //返回尾
    }
}

Node* convert2(Node *head)
{
    if(NULL == head)
        return NULL;
    Node *last = process(head);
    head = last->right;
    last->right = NULL;
    return head;

}

//打印链表
void printList(Node *head)
{
    while(NULL != head)
    {
        cout << head->value << " ";
        head = head->right;
    }
    cout << endl;
}

　　测试代码：

/*
 *文件名：mian.cpp
 *作者：
 *摘要：测试代码
 */

#include "bt_convert_list.h"

int main()
{
    int arr[] = {6,4,7,2,5,9,1,3,8};
    //创建搜索二叉树
    Node *head = NULL;
    for(int i = 0;i < 9; i++)
    {
        bt_insert(&head,arr[i]);
    }
    cout << "The nodes of Binary Tree are:" << endl;
    preOrderRecur(head);
    cout << endl;

    //head = convert1(head);
    head = convert2(head);
    cout << "The nodes of list are:" << endl;
    printList(head);


    return 0;
}

注：

　　转载请注明出处；

　　转载请注明源思路来自于左程云老师的《程序员代码面试指南》。