如何将一个排序二叉树转换为循环双向链表

方法一：1.递归处理左子树，得到一个链表
2.递归处理右子树，得到一个链表
最终链表=左子树链表+根节点+右子树链表
方法二：新建双向循环链表，通过中序遍历排序二叉树，依次获得所有节点，并将节点存入新建的链表，得到最终的双向循环链表。

#include<iostream>
#include<stack>
using namespace std;
struct TreeNode
{
    int data;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int value):data(value),left(NULL),right(NULL){};
};

TreeNode* createTree(TreeNode* root,TreeNode* node)
{
    if(!root)
    {
        root=node;  
        //printf("root=%d ",root->data);
    }
    else
    {
        if(node->data>root->data)
        {
            root->right=createTree(root->right,node);

            //printf("r=%d ",node->data);
        }
        else if(node->data<root->data)
        {
            root->left=createTree(root->left,node);

            //printf("l=%d ",node->data);
        }
    }
    return root;

}

void print(TreeNode* root)
{
    if(root==NULL)
        return;

    if(root->left)
        print(root->left);
    printf("%d ",root->data);
    if(root->right)
        print(root->right);

}


typedef struct TrNode
{
    int data;
    TrNode* left;
    TrNode* right;
}trnode;

trnode* listTree(trnode* list,TreeNode* node)
{
    trnode* lnode=(trnode*)malloc(sizeof(trnode));
    lnode->left=lnode->right=NULL;
    lnode->data=node->data;

    if(!list)
    {
        lnode->left=lnode;
        lnode->right=lnode;
    }
    else
    {
        list->right->left=lnode;
        lnode->right=list->right;
        list->right=lnode;
        lnode->left=list;

    }

    list=lnode;
    return list;
}

void printlist(trnode* list)
{
        trnode* head=NULL;  
        head=list->right;
        while(head)
        {
            printf("%d ",head->data);
            head=head->right;
            if(head==list->right)
                break;
        }


}


void printl(TreeNode* list)
{
    TreeNode* head=list;    
    while(head)
    {
        printf("%d ",head->data);
        head=head->right;
        if(head==list)
            break;
    }


}

void join(TreeNode* node1,TreeNode* node2)
{


        node1->right=node2;
        node2->left=node1;


}

TreeNode* appendlist(TreeNode* list1,TreeNode* list2)
{
    TreeNode * temp;

    if(!list1)
        return list2;
    if(!list2)
        return list1;
    else
    {
        temp=list2->left;
        join(list1->left,list2);
        join(temp,list1);
        return list1;
    }

}

TreeNode* linklist(TreeNode* root)
{
    TreeNode* alist,*blist;
    if(!root)
        return NULL;
    alist=linklist(root->left);
    blist=linklist(root->right);

    root->left=root;
    root->right=root;

    alist=appendlist(alist,root);
    alist=appendlist(alist,blist);
    return alist;

}
trnode* convertTree(TreeNode* root)
{
    stack<TreeNode*> Treestack;
    trnode* list=NULL;
    if(root)
        Treestack.push(root);
    while(Treestack.size())
    {
        TreeNode* topnode=Treestack.top();

        if(topnode->left)
        {
            Treestack.push(topnode->left);
            topnode->left=NULL;
        }
        else
        {       
            list=listTree(list,topnode);
            Treestack.pop();

            if(topnode->right)
                Treestack.push(topnode->right);
        }
    }
    return list;
}


void main()
{
    TreeNode* node1=new TreeNode(4);
    TreeNode* node2=new TreeNode(2);
    TreeNode* node3=new TreeNode(1);
    TreeNode* node4=new TreeNode(3);
    TreeNode* node5=new TreeNode(5);
    TreeNode* root=NULL;
    root=createTree(root,node1);        
    root=createTree(root,node2);    
    root=createTree(root,node3);        
    root=createTree(root,node4);
    root=createTree(root,node5);

    print(root);   //打印搜索二叉树

    /******运用中序遍历的思想另外建立循环双向链表*/
    cout<<endl;
    trnode* listtree=NULL;
    listtree=convertTree(root);
    printlist(listtree);



    cout<<endl;
    /***递归方法求解循环双向链表
    TreeNode* temp;
    printl(linklist(root));
    */
}