利用递归，构造二叉查找树，

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

给一个升序的单向链表，把他转换成一个二叉查找树

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

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
  
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <stack>
#include <vector>
#include "BinaryTree.h"
#include "List.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) {}
 * };
 */
void findmid(ListNode *head, ListNode *end, ListNode *&mid)
{

if(head == NULL)
    {
        mid = NULL;
        return;
    }
    if(head->next == end)
    {
        mid = head;
        return;
    }
    /*pre就是传说中的快马*/
    ListNode *pre = head;
    mid = head;
    while(pre->next != end)
    {
        pre = pre->next;
        if(pre->next != end)
        {
            pre = pre->next;
        }
        else
        {
            break;
        }
        mid = mid->next;
    }

}

TreeNode *tobst(ListNode *head, ListNode *tail)
{

if(head == tail)
    {
        return NULL;
    }
    if(head->next == tail)
    {
        int val = head->val;
        delete head;
        return new TreeNode(val);
    }
    ListNode *mid;
    findmid(head, tail, mid);
    TreeNode *tmp = new TreeNode(mid->val);
    tmp->left = tobst(head, mid);
    if(mid->next)
    {
        tmp->right = tobst(mid->next, tail);
    }
    delete mid;
    return tmp;
}

TreeNode *sortedListToBST(ListNode *head)
{

if(head == NULL)
    {
        return NULL;
    }
    return tobst(head, NULL);

}

vector<vector<int> > levelOrder(TreeNode *root)
{

vector<vector<int> > matrix;
    if(root == NULL)
    {
        return matrix;
    }
    vector<int> temp;
    temp.push_back(root->val);
    matrix.push_back(temp);

vector<TreeNode *> path;
    path.push_back(root);

int count = 1;
    while(!path.empty())
    {
        TreeNode *tn = path.front();
        if(tn->left)
        {
            path.push_back(tn->left);
        }
        if(tn->right)
        {
            path.push_back(tn->right);
        }
        path.erase(path.begin());
        count--;

if(count == 0)
        {
            vector<int> tmp;
            vector<TreeNode *>::iterator it = path.begin();
            for(; it != path.end(); ++it)
            {
                tmp.push_back((*it)->val);
            }
            if(tmp.size() > 0)
            {
                matrix.push_back(tmp);
            }
            count = path.size();
        }
    }
    return matrix;
}

// 树中结点含有分叉，
//                  4
//              /       \
//             2         6
//           /   \      /  \
//          1     3    5    7
int main()
{

ListNode *pListNode1 = CreateListNode(1);
    ListNode *pListNode2 = CreateListNode(2);
    ListNode *pListNode3 = CreateListNode(3);
    ListNode *pListNode4 = CreateListNode(4);
    ListNode *pListNode5 = CreateListNode(5);
    ListNode *pListNode6 = CreateListNode(6);
    ListNode *pListNode7 = CreateListNode(7);

ConnectListNodes(pListNode1, pListNode2);
    ConnectListNodes(pListNode2, pListNode3);
    ConnectListNodes(pListNode3, pListNode4);
    ConnectListNodes(pListNode4, pListNode5);
    ConnectListNodes(pListNode5, pListNode6);
    ConnectListNodes(pListNode6, pListNode7);

TreeNode *root = sortedListToBST(pListNode1);

vector<vector<int> > ans = levelOrder(root);

for (int i = 0; i < ans.size(); ++i)
    {
        for (int j = 0; j < ans[i].size(); ++j)
        {
            cout << ans[i][j] << " ";
        }
    }
    cout << endl;
    DestroyTree(root);
    return 0;
}

 
输出结果：
4 2 6 1 3 5 7

List.h：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  
#ifndef _LIST_H_
#define _LIST_H_

#include <cstdlib>

struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode *CreateListNode(int value);
void ConnectListNodes(ListNode *pCurrent, ListNode *pNext);
void PrintListNode(ListNode *pNode);
void PrintList(ListNode *pHead);
void DestroyList(ListNode *pHead);
void AddToTail(ListNode **pHead, int value);
void RemoveNode(ListNode **pHead, int value);

#endif //_LIST_H_

 
List.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
  
#include "List.h"
#include <cstdio>
#include <cstdlib>

ListNode *CreateListNode(int value)
{
    ListNode *pNode = new ListNode(0);
    pNode->val = value;
    pNode->next = NULL;

return pNode;
}

void ConnectListNodes(ListNode *pCurrent, ListNode *pNext)
{
    if(pCurrent == NULL)
    {
        printf("Error to connect two nodes.\n");
        exit(1);
    }

pCurrent->next = pNext;
}

void PrintListNode(ListNode *pNode)
{
    if(pNode == NULL)
    {
        printf("The node is NULL\n");
    }
    else
    {
        printf("The key in node is %d.\n", pNode->val);
    }
}

void PrintList(ListNode *pHead)
{
    printf("PrintList starts.\n");

ListNode *pNode = pHead;
    while(pNode != NULL)
    {
        printf("%d\t", pNode->val);
        pNode = pNode->next;
    }

printf("\nPrintList ends.\n");
}

void DestroyList(ListNode *pHead)
{
    ListNode *pNode = pHead;
    while(pNode != NULL)
    {
        pHead = pHead->next;
        delete pNode;
        pNode = pHead;
    }
}

void AddToTail(ListNode **pHead, int value)
{
    ListNode *pNew = new ListNode(0);
    pNew->val = value;
    pNew->next = NULL;

if(*pHead == NULL)
    {
        *pHead = pNew;
    }
    else
    {
        ListNode *pNode = *pHead;
        while(pNode->next != NULL)
            pNode = pNode->next;

pNode->next = pNew;
    }
}

void RemoveNode(ListNode **pHead, int value)
{
    if(pHead == NULL || *pHead == NULL)
        return;

ListNode *pToBeDeleted = NULL;
    if((*pHead)->val == value)
    {
        pToBeDeleted = *pHead;
        *pHead = (*pHead)->next;
    }
    else
    {
        ListNode *pNode = *pHead;
        while(pNode->next != NULL && pNode->next->val != value)
            pNode = pNode->next;

if(pNode->next != NULL && pNode->next->val == value)
        {
            pToBeDeleted = pNode->next;
            pNode->next = pNode->next->next;
        }
    }

if(pToBeDeleted != NULL)
    {
        delete pToBeDeleted;
        pToBeDeleted = NULL;
    }
}
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);
    }
}
 
 
 


 


 
												


											
【二叉查找树】05根据升序的链表构造二叉查找树【Convert Sorted List to Binary Search Tree】的更多相关文章
	

    
						
  1. [LeetCode]  Convert Sorted List to Binary Search Tree 将有序链表转为二叉搜索树
		
    Given a singly linked list where elements are sorted in ascending order, convert it to a height bala ...
    
		
    2. 
						
  2. [LeetCode] 108. Convert Sorted Array to Binary Search Tree ☆(升序数组转换成一个平衡二叉树)
		
    108. Convert Sorted Array to Binary Search Tree 描述 Given an array where elements are sorted in ascen ...
    
		
    3. 
						
  3. Convert Sorted List to Binary Search Tree——将链表转换为平衡二叉搜索树  &&convert-sorted-array-to-binary-search-tree——将数列转换为bst
		
    Convert Sorted List to Binary Search Tree Given a singly linked list where elements are sorted in as ...
    
		
    4. 
						
  4. [LeetCode] 109. Convert Sorted List to Binary Search Tree 把有序链表转成二叉搜索树
		
    Given a singly linked list where elements are sorted in ascending order, convert it to a height bala ...
    
		
    5. 
								
  5. 【二叉查找树】04根据升序数组构造二叉查找树【Convert Sorted Array to Binary Search Tree】
		
    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 给定一个升序的数组,把他转换成一个 ...
    
		
    6. 
						
  6. Convert Sorted List to Binary Search Tree ------C++  递归创建平衡二叉查找树
		
    有序链表 0->1->2->3->4->5 转换为一个二叉排序树.我们在此创建一个平衡二叉排序树 1.先找链表到中间的节点 2.中间节点的val创建一个新的树节点Tree ...
    
		
    7. 
						
  7. [Leetcode] Convert sorted list to binary search tree 将排好的链表转成二叉搜索树
		
    ---恢复内容开始--- Given a singly linked list where elements are sorted in ascending order, convert it to  ...
    
		
    8. 
						
  8. LeetCode 109. 有序链表转换二叉搜索树（Convert Sorted List to Binary Search Tree）
		
    题目描述 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. 示例: 给定的有序链表: ...
    
		
    9. 
						
  9. [Swift]LeetCode109. 有序链表转换二叉搜索树 | Convert Sorted List to Binary Search Tree
		
    Given a singly linked list where elements are sorted in ascending order, convert it to a height bala ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. 将PHP 5.3.3 (cli)升级到PHP 5.6.31 (cli)
			
    centos默认系统安装的是php5.3 [root@sz-local1 scripts]# rpm -qa |grep phpphp-pdo-5.3.3-47.el6.x86_64php-mysql ...
    
			
    2. 
						
  2. Linux下SVN安装与权限管理
			
    cat /etc/redhat-release //查看系统版本号 CentOS release 7.1 (Final) 这里我们採用yum源安装方式: 1.安装svn yum install sub ...
    
			
    3. 
						
  3. hdu 5285 wyh2000 and pupil（二染色）
			
    第一次用vector解得题.值得纪念,这道题是二染色问题,我用bfs解得.就是染色,推断,计数问题,其 实挺简单的,就是得判一下特殊情况,当n<2的时候就不能有解,由于题目要求每一个组至少有一个 ...
    
			
    4. 
						
  4. EasyPlayer播放器浏览器ActiveX/OCX插件RTSP播放/抓拍/录像功能调用说明
			
    EasyPlayerPro与EasyPlayer-RTSP新增ocx多窗口播放功能 这里以EasyPlayerPro为例,使用方法如下: 打开播放器文件夹,进入Bin/C++目录,可以看到reg.ba ...
    
			
    5. 
						
  5. How to avoid Over-fitting using Regularization?
			
    http://www.mit.edu/~9.520/scribe-notes/cl7.pdf https://en.wikipedia.org/wiki/Bayesian_interpretation ...
    
			
    6. 
						
  6. 记一次bash脚本报错原因
			
    准备部署上次写的 爬虫的定时任务,发现sh脚本 写为最简单的cd ,也报错 后来网上一波了解,原因竟是 : 额,格式问题,我为了图方便是在window里用notepad++写的,然后我再linux 系 ...
    
			
    7. 
						
  7. easyui的 一些经验
			
    1. 渲染网络表格时,行操作 <th field="sort_num" width="10" data-options="field:'id', ...
    
			
    8. 
						
  8. Example 1 - XY plots
			
    http://www.ncl.ucar.edu/Document/Manuals/Getting_Started/Examples/gsun01n.shtml Frame 1 Frame 2 Fram ...
    
			
    9. 
						
  9. [原创]java WEB学习笔记25：MVC案例完整实践(part 6)---新增操作的设计与实现
			
    本博客为原创:综合 尚硅谷(http://www.atguigu.com)的系统教程(深表感谢)和 网络上的现有资源(博客,文档,图书等),资源的出处我会标明 本博客的目的:①总结自己的学习过程,相当 ...
    
			
    10. 
						
  10. 【leetcode刷题笔记】Subsets II
			
    Given a collection of integers that might contain duplicates, S, return all possible subsets. Note:  ...
    
			
    11.