开一个指针数组，中序遍历这个二叉搜索树，将节点的指针依次保存在数组里，

然后寻找两处逆序的位置，

中序便利里BST得到的是升序序列

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

二叉搜索树(BST)中的两个节点不小心被交换了下。

不改变其结构的情况下恢复这个树。

笔记：

用O(n)的空间复杂度的方法很直接。你能否设计一个常量空间的解决法方案？

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure.

Note:
A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
test.cpp：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
  
#include <iostream>
#include <cstdio>
#include <stack>
#include <vector>
#include "BinaryTree.h"

using namespace std;

/**
 * Definition for binary tree
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
vector<TreeNode *> inorderTraversal(TreeNode *root)
{
    stack<TreeNode *> s;
    vector<TreeNode *> path;
    TreeNode *p = root;
    while(p != NULL || !s.empty())
    {
        while(p != NULL)
        {
            s.push(p);
            p = p->left;
        }
        if(!s.empty())
        {
            p = s.top();
            path.push_back(p);
            s.pop();
            p = p->right;
        }
    }
    return path;
}

void recoverTree(TreeNode *root)
{
    vector<TreeNode *> inTrav = inorderTraversal(root);
    TreeNode *left, *right;
    int tmp;
    for (int i = 0; i < inTrav.size() - 1; ++i)
    {
        if (inTrav[i]->val > inTrav[i + 1]->val)
        {
            left = inTrav[i];
            break;
        }
    }
    for (int i = inTrav.size() - 1; i > 0; --i)
    {
        if (inTrav[i]->val < inTrav[i - 1]->val)
        {
            right = inTrav[i];
            break;
        }
    }
    tmp = left->val;
    left->val = right->val;
    right->val = tmp;
    return ;
}

// 树中结点含有分叉，
//                  6
//              /       \
//             7         2
//           /   \
//          1     4
//               / \
//              3   5
int main()
{
    TreeNode *pNodeA1 = CreateBinaryTreeNode(6);
    TreeNode *pNodeA2 = CreateBinaryTreeNode(7);
    TreeNode *pNodeA3 = CreateBinaryTreeNode(2);
    TreeNode *pNodeA4 = CreateBinaryTreeNode(1);
    TreeNode *pNodeA5 = CreateBinaryTreeNode(4);
    TreeNode *pNodeA6 = CreateBinaryTreeNode(3);
    TreeNode *pNodeA7 = CreateBinaryTreeNode(5);

ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3);
    ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5);
    ConnectTreeNodes(pNodeA5, pNodeA6, pNodeA7);

PrintTree(pNodeA1);

cout << "before recover" << endl;
    vector<TreeNode *> ans = inorderTraversal(pNodeA1);

for (int i = 0; i < ans.size(); ++i)
    {
        cout << ans[i]->val << " ";
    }
    cout << endl;

recoverTree(pNodeA1);

cout << "after recover" << endl;
    ans.clear();
    ans = inorderTraversal(pNodeA1);

for (int i = 0; i < ans.size(); ++i)
    {
        cout << ans[i]->val << " ";
    }
    cout << endl;

DestroyTree(pNodeA1);
    return 0;
}

 
输出结果：
before recover

1 7 3 4 5 6 2

after recover

1 2 3 4 5 6 7
BinaryTree.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  
#ifndef _BINARY_TREE_H_
#define _BINARY_TREE_H_

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode *CreateBinaryTreeNode(int value);
void ConnectTreeNodes(TreeNode *pParent,
                      TreeNode *pLeft, TreeNode *pRight);
void PrintTreeNode(TreeNode *pNode);
void PrintTree(TreeNode *pRoot);
void DestroyTree(TreeNode *pRoot);

#endif /*_BINARY_TREE_H_*/
BinaryTree.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
  
#include <iostream>
#include <cstdio>
#include "BinaryTree.h"

using namespace std;

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

//创建结点
TreeNode *CreateBinaryTreeNode(int value)
{
    TreeNode *pNode = new TreeNode(value);

return pNode;
}

//连接结点
void ConnectTreeNodes(TreeNode *pParent, TreeNode *pLeft, TreeNode *pRight)
{
    if(pParent != NULL)
    {
        pParent->left = pLeft;
        pParent->right = pRight;
    }
}

//打印节点内容以及左右子结点内容
void PrintTreeNode(TreeNode *pNode)
{
    if(pNode != NULL)
    {
        printf("value of this node is: %d\n", pNode->val);

if(pNode->left != NULL)
            printf("value of its left child is: %d.\n", pNode->left->val);
        else
            printf("left child is null.\n");

if(pNode->right != NULL)
            printf("value of its right child is: %d.\n", pNode->right->val);
        else
            printf("right child is null.\n");
    }
    else
    {
        printf("this node is null.\n");
    }

printf("\n");
}

//前序遍历递归方法打印结点内容
void PrintTree(TreeNode *pRoot)
{
    PrintTreeNode(pRoot);

if(pRoot != NULL)
    {
        if(pRoot->left != NULL)
            PrintTree(pRoot->left);

if(pRoot->right != NULL)
            PrintTree(pRoot->right);
    }
}

void DestroyTree(TreeNode *pRoot)
{
    if(pRoot != NULL)
    {
        TreeNode *pLeft = pRoot->left;
        TreeNode *pRight = pRoot->right;

delete pRoot;
        pRoot = NULL;

DestroyTree(pLeft);
        DestroyTree(pRight);
    }
}

 






 


 


 


 


 


 


 


 
												


											
【遍历二叉树】07恢复二叉搜索树【Recover Binary Search Tree】的更多相关文章
	

    
						
  1. [Swift]LeetCode99. 恢复二叉搜索树 | Recover Binary Search Tree
		
    Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing ...
    
		
    2. 
						
  2. [数据结构]——二叉树（Binary Tree）、二叉搜索树（Binary Search Tree）及其衍生算法
		
    二叉树(Binary Tree)是最简单的树形数据结构,然而却十分精妙.其衍生出各种算法,以致于占据了数据结构的半壁江山.STL中大名顶顶的关联容器--集合(set).映射(map)便是使用二叉树实现 ...
    
		
    3. 
						
  3. 二叉搜索树BST(Binary Search Tree)
		
    二叉搜索树(Binary Search Tree)也叫二叉排序树或二叉查找树.它满足以下性质: 1.非空左子树的所有键值小于其根结点的键值: 2.非空右子树的所有键值大于其根结点的键值: 3.左右子树 ...
    
		
    4. 
						
  4. 二叉搜索树（Binary Search Tree）--C语言描述(转)
		
    图解二叉搜索树概念 二叉树呢,其实就是链表的一个二维形式,而二叉搜索树,就是一种特殊的二叉树,这种二叉树有个特点:对任意节点而言,左孩子(当然了,存在的话)的值总是小于本身,而右孩子(存在的话)的值总 ...
    
		
    5. 
						
  5. 数据结构-二叉搜索树(BST binary search tree)
		
    本文由@呆代待殆原创,转载请注明出处:http://www.cnblogs.com/coffeeSS/ 二叉搜索树简介 顾名思义,二叉搜索树是以一棵二叉树来组织的,这样的一棵树可以用一个链表数据结构来 ...
    
		
    6. 
						
  6. 原生JS实现二叉搜索树（Binary Search Tree）
		
    1.简述 二叉搜索树树(Binary Search Tree),它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值: 若它的右子树不空,则右子 ...
    
		
    7. 
						
  7. 【数据结构05】红-黑树基础----二叉搜索树（Binary Search Tree）
		
    目录 1.二分法引言 2.二叉搜索树定义 3.二叉搜索树的CRUD 4.二叉搜索树的两种极端情况 5.二叉搜索树总结 前言 在[算法04]树与二叉树中,已经介绍过了关于树的一些基本概念以及二叉树的前中 ...
    
		
    8. 
						
  8. 二叉搜索树（Binary Search Tree）
		
    二叉搜索树(BST,Binary Search Tree),也称二叉排序树或二叉查找树. 二叉搜索树:一棵二叉树,可以为空:如果不为空,满足以下性质: 非空左子树的所有键值小于其根结点的键值: 非空右 ...
    
		
    9. 
						
  9. [Swift]LeetCode98. 验证二叉搜索树 | Validate Binary Search Tree
		
    Given a binary tree, determine if it is a valid binary search tree (BST). Assume a BST is defined as ...
    
		
    10. 
						
  10. [Swift]LeetCode173. 二叉搜索树迭代器 | Binary Search Tree Iterator
		
    Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the ro ...
    
		
    11. 
		

	


随机推荐
	

    
									
  1. （一）unity4.6Ugui中文教程文档-------概要
			
    大家好,我是孙广东.   转载请注明出处:http://write.blog.csdn.net/postedit/38922399 更全的内容请看我的游戏蛮牛地址:http://www.unityma ...
    
			
    2. 
						
  2. 第三方苹果开发库之ASIHTTPRequest（翻译版）
			
    本文转载至 http://www.cnblogs.com/daguo/archive/2012/08/03/2622090.html   来自:http://www.dreamingwish.com/ ...
    
			
    3. 
						
  3. OKR与KPI管理的区别与联系
			
    OKR是一种新兴的管理体系,最近几年被引进中国.由于在IT.互联网.金融.游戏等知识密集型企业中有着显著的效果,得到中国企业的认可. OKR是英文Objectives & Key Result ...
    
			
    4. 
						
  4. 九度OJ 1205：N阶楼梯上楼问题 （斐波那契数列）
			
    时间限制:1 秒 内存限制:128 兆 特殊判题:否 提交:3739 解决:1470 题目描述: N阶楼梯上楼问题:一次可以走两阶或一阶,问有多少种上楼方式.(要求采用非递归) 输入: 输入包括一个整 ...
    
			
    5. 
						
  5. Ax=λx=λIx
			
    
			
    6. 
						
  6. 为什么要对url进行encode
			
    发现现在几乎所有的网站都对url中的汉字和特殊的字符,进行了urlencode操作,也就是: http://hi.baidu.com/%BE%B2%D0%C4%C0%CF%C8%CB/creat/bl ...
    
			
    7. 
						
  7. Django之stark组件2
			
    action批量处理功能 用户可以自定义批量处理功能,但是默认的有批量删除功能. ***思路*** 1,定义一个列表用来装action的类名并extend用户自定义列表 2.循环该列表获取到函数名(用 ...
    
			
    8. 
						
  8. greenlet和gevent模块的区别？
			
    协程是一中多任务实现方式,它不需要多个进程或线程就可以实现多任务. yield能实现协程,不过实现过程不易于理解,greenlet是在这方面做了改进,通过switch. greenlet可以实现协程, ...
    
			
    9. 
						
  9. git入门篇-----本地操作
			
    一 ,git的简介 1 ,git的历史 概念性的知识,大家百度一下,就会出现好多优秀的文章供参考,这里我就不多说了. 如果不是当年BitMover公司威胁Linux社区,可能现在我们就没有免费而超级好 ...
    
			
    10. 
						
  10. sublime-text 键绑定
			
    vim 和 emacs 是牛人们的两大神器,sublime-text则是每个人的编程利器. 先说一下本人的感受,vim用了一段时间,emacs也小试了一下,两大神器尽是各种命令,另人眼花缭乱. 但是有 ...
    
			
    11.