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

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

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

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

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. 脑法之中的一个 --- DEBUG与搜索算法
			
    前年闲的蛋疼的时候,看过天津卫视的一档节目<非你莫属>,就来一堆面试者,上面几个壕.选人.记得有一期是给程序猿做的.当中有一个程序猿(好像是媛)傻不啦叽的说,哎呀,我每次DEBUG找到程序 ...
    
			
    2. 
						
  2. Aeroplane chess(简单概率dp)
			
    Hzz loves aeroplane chess very much. The chess map contains N+1 grids labeled from 0 to N. Hzz start ...
    
			
    3. 
						
  3. 反应器模式 vs 观察者模式
			
    反应器模式(Reactor pattern)与观察者模式(Observer pattern) 反应器模式 是一种为处理服务请求并发提交到一个或者多个服务处理程序的事件设计模式.当请求抵达后,服务处理程 ...
    
			
    4. 
						
  4. 从内存中加载并启动一个exe
			
    windows似乎只提供了一种启动进程的方法:即必须从一个可执行文件中加载并启动.而下面这段代码就是提供一种可以直接从内存中启动一个exe的变通办法.用途嘛, 也许可以用来保护你的exe,你可以对要保 ...
    
			
    5. 
						
  5. 页游手游服务器（三）lua网络层
			
    在(一)中,介绍了c对lua层的拓展,这边主要写lua层的网络部分,目标是实现RPC调用,实现主要是三部分: 1通信协议(消息的序列化和反序列化) rpc调用主要信息包括方法名,方法参数,设计的通信协 ...
    
			
    6. 
						
  6. delete 和 truncate 的 区别
			
    如果要清空表中的所有记录,可以使用下面的两种方法: DELETE FROM table1     TRUNCATE TABLE table1 以下 为之区别: 1)执行速度和灵活性    trunca ...
    
			
    7. 
						
  7. Android TextView文字过多时通过滚动条显示多余内容
			
    方法一: TextView文字过多,显示不全,怎么办?我们可以为Textview添加滚动条. <TextView android:id="@+id/bus_detail_content ...
    
			
    8. 
						
  8. NeurIPS2018: DropBlock: A regularization method for convolutional networks
			
    NIPS 改名了!改成了neurips了... 深度神经网络在过参数化和使用大量噪声和正则化(如权重衰减和 dropout)进行训练时往往性能很好.dropout 广泛用于全连接层的正则化,但它对卷积 ...
    
			
    9. 
						
  9. php面向对象加载类
			
    php加载类: 新建php文件用驼峰法命名类名: 每个单词首字母大写,后面加.class.php表示这是php类文件.例如: ClubMember.class.php 若为纯php页面,<?ph ...
    
			
    10. 
						
  10. 模块化（CommonJs、AMD、CMD、UMD）发展历史与优缺点
			
    全文主要整理自摘自<Webpack中文指南>(好文,建议直接去看,以下仅对该系列文章中的<历史发展>篇幅进行备份——也整理了点其他内容) 模块化 模块化是老生常谈了,这里不做阐 ...
    
			
    11.