【编程题目】把二元查找树转变成排序的双向链表(树)

最新推荐文章于 2018-11-02 13:56:22 发布

weixin_34192993

最新推荐文章于 2018-11-02 13:56:22 发布

阅读量104

点赞数

文章标签：数据结构与算法

1.把二元查找树转变成排序的双向链表（树）
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ \
6 14
/ \ / \
4 8 12 16
转换成双向链表
4=6=8=10=12=14=16。
首先我们定义的二元查找树节点的数据结构如下：
struct BSTreeNode
{
int m_nValue; // value of node
BSTreeNode *m_pLeft; // left child of node
BSTreeNode *m_pRight; // right child of node
};

我的思路：找到最小元素做头结点，不断的找其后继，调整指针的指向。写了一个半小时！

  1 /*
  2 1.把二元查找树转变成排序的双向链表（树）
  3 题目：
  4 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
  5 要求不能创建任何新的结点，只调整指针的指向。
  6      10
  7     / \
  8    6   14
  9   / \  / \
 10   4 8 12 16
 11 转换成双向链表
 12 4=6=8=10=12=14=16。
 13 首先我们定义的二元查找树  节点的数据结构如下：
 14 struct BSTreeNode
 15 {
 16 int m_nValue; // value of node
 17 BSTreeNode *m_pLeft; // left child of node
 18 BSTreeNode *m_pRight; // right child of node
 19 };
 20 start time = 14:31
 21 end time = 16:04
 22 */
 23 #include <iostream>
 24 #include <stdlib.h>
 25 using namespace std;
 26 
 27 typedef struct BSTreeNode
 28 {
 29 int m_nValue; // value of node
 30 BSTreeNode *m_pLeft; // left child of node
 31 BSTreeNode *m_pRight; // right child of node
 32 }BSTreeNode;
 33 
 34 int addBSTreeNode(BSTreeNode * &T, int data)  //把data加入的以T为根的树中
 35 {
 36     if(T == NULL) //根节点单独处理
 37     {
 38         T = (BSTreeNode *)malloc(sizeof(BSTreeNode));
 39         T->m_nValue = data;
 40         T->m_pLeft = NULL;
 41         T->m_pRight = NULL;
 42     }
 43     else
 44     {
 45         BSTreeNode * x = T;
 46         BSTreeNode * px = NULL;
 47         while(x != NULL)
 48         {
 49             if(data >= x->m_nValue)
 50             {
 51                 px = x;
 52                 x = x->m_pRight;
 53             }
 54             else
 55             {
 56                 px = x;
 57                 x = x->m_pLeft;
 58             }
 59         }
 60 
 61         if(data >= px->m_nValue)
 62         {
 63             px->m_pRight = (BSTreeNode *)malloc(sizeof(BSTreeNode));
 64             px->m_pRight->m_nValue = data;
 65             px->m_pRight->m_pLeft = NULL;
 66             px->m_pRight->m_pRight = NULL;
 67         }
 68         else
 69         {
 70             px->m_pLeft = (BSTreeNode *)malloc(sizeof(BSTreeNode));
 71             px->m_pLeft->m_nValue = data;
 72             px->m_pLeft->m_pLeft = NULL;
 73             px->m_pLeft->m_pRight = NULL;
 74         }
 75     }
 76     return 1;
 77 }
 78 
 79 BSTreeNode * findMin(BSTreeNode * z)
 80 {
 81     BSTreeNode * x = z;
 82     while(x->m_pLeft != NULL)
 83     {
 84         x = x->m_pLeft;
 85     }
 86     return x;
 87 }
 88 
 89 BSTreeNode * findMax(BSTreeNode * z)
 90 {
 91     BSTreeNode * x = z;
 92     while(x->m_pRight != NULL)
 93     {
 94         x = x->m_pRight;
 95     }
 96     return x;
 97 }
 98 
 99 BSTreeNode * findparent(BSTreeNode * T,BSTreeNode * z)
100 {
101     BSTreeNode * x = T;
102     BSTreeNode * px = NULL;
103     while(x != NULL)
104     {
105         if(z->m_nValue > x->m_nValue)
106         {
107             px = x;
108             x = x->m_pRight;
109         }
110         else if(z->m_nValue < x->m_nValue)
111         {
112             px = x;
113             x = x->m_pLeft;
114         }
115         else
116         {
117             if(z == x) //对数值相同的情况做判断 
118             {
119                 return px;
120             }
121             else
122             {
123                 px = x;
124                 x = x->m_pRight;
125             }
126         }
127     }
128     return NULL;
129 }
130 
131 BSTreeNode * BSTreefindSuccessor(BSTreeNode * T, BSTreeNode * z) //找二元查找树某个节点的后继
132 {
133     if(z->m_pRight != NULL)
134     {
135         return  findMin(z->m_pRight);
136     }
137     else
138     {
139         BSTreeNode * y = findparent(T, z);
140         while(y != NULL && z == y->m_pRight)
141         {
142             z = y;
143             y = findparent(T, z);
144         }
145         return y;
146     }
147 }
148 
149 BSTreeNode * BSTree2OrderedList(BSTreeNode * T) //把二元查找树转换为排序的双向链表
150 {
151     BSTreeNode * start = findMin(T);
152     BSTreeNode * end = findMax(T);
153     BSTreeNode * x = start;
154     BSTreeNode * root = T;
155     while(x != NULL)
156     {
157         BSTreeNode * xs = BSTreefindSuccessor(root, x);
158         if(xs == root && root != NULL) //当root 左右子树的指向改变的时候 要更新找后继的树根 否则根的右子树变化了 用找后继会出错
159         {
160             root = root->m_pRight;
161         }
162         if(xs != NULL)
163         {
164             x->m_pRight = xs;  //向右指向下一个比它大的值
165             xs->m_pLeft = x;   //向左指向下一个比它小的值
166         }
167         x = xs;
168     }
169     return start;
170 }
171 
172 
173 int main()
174 {
175     BSTreeNode * T = NULL;
176     addBSTreeNode(T, 10);
177     addBSTreeNode(T, 6);
178     addBSTreeNode(T, 6);
179     addBSTreeNode(T, 4);
180     addBSTreeNode(T, 8);
181     addBSTreeNode(T, 12);
182     addBSTreeNode(T, 16);
183 
184     BSTreeNode * ans = BSTree2OrderedList(T);
185 
186     return 0;
187 
188 }

View Code

之后上网看看别人的结果人家一个中序遍历就搞定了啊！

来源：http://blog.csdn.net/wcyoot/article/details/6428297

 1 template<typename T>
 2 struct TreeNode
 3 {
 4     T data;
 5     TreeNode* pLChild;
 6     TreeNode* pRChild;
 7 };
 8 
 9 // 要求两个输出参数要初始化为NULL
10 template<typename T>
11 void ConvertBSTree2List(TreeNode<T>* pTreeRoot/*树的根节点*/, TreeNode<T>*& pListHead/*双向链表的头指针*/, TreeNode<T>*& pListLast/*双向链表的尾指针*/)
12 {
13     if(pTreeRoot == NULL)
14     {
15         return;
16     }
17 
18     // 中序遍历左子树
19     ConvertBSTree2List(pTreeRoot->pLChild, pListHead, pListLast);
20 
21     // 处理当前节点，把节点链到双向链表尾部
22 
23     // 修改当前节点左指针，指向双向链表尾部
24     pTreeRoot->pLChild = pListLast;
25     if(pListLast)        // 非第一个节点
26     {
27         pListLast->pRChild = pTreeRoot;
28     }
29     else                // 第一个节点
30     {
31         pListHead = pTreeRoot;    
32     }
33 
34     pListLast = pTreeRoot;
35 
36     // 中序遍历右子树
37     ConvertBSTree2List(pTreeRoot->pRChild, pListHead, pListLast);
38 }