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

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

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

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

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. MongoDBTemplate多条件查询的问题
			
    问题: 在使用Spring Data MongoDB 进行条件查询数据时,发现条件判断不起作用,结果会返回所有的数据. Criteria criteria = new Criteria(); crit ...
    
			
    2. 
						
  2. csv文件的格式
			
    csv, comma separated values csv是一种纯文本文件. csv文件由任意数目的记录构成,记录间以换行符分割,每条记录由字段构成,字段间以逗号作为分隔符. 如果字段中有逗号,那 ...
    
			
    3. 
						
  3. Redis1 介绍和字典
			
    Redis介绍 redis是一个key-value存储系统.和Memcached类似,它支持存储的value类型相对更多,包括string(字符串).list(列表).set(集合).zset(sor ...
    
			
    4. 
						
  4. restful规范和restframework框架
			
    什么是接口? 接口可以理解为url就是接口. 那么在其他语言里面接口也可以是约束类 restful规范是什么? RESTful是目前最流行的一种互联网软件架构.它结构清晰.符合标准.易于理解.扩展方便 ...
    
			
    5. 
						
  5. Bootstrap 轮播图（Carousel）插件
			
    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
    
			
    6. 
						
  6. json遍历
			
    $.each(item.attributes,function (name,value) { });
    
			
    7. 
						
  7. 关于js中undefined的判断
			
    在开发中遇到一个情景,当添加用户的时候不需要传入用户id,如果是修改那么需要传入id,因为用的是angular框架,参数是早就定义好了的,那么在新增用户的时候就会出现undefined的情况,之前我一 ...
    
			
    8. 
						
  8. LeetCode：二叉树相关应用
			
    LeetCode:二叉树相关应用 基础知识 617.归并两个二叉树 题目 Given two binary trees and imagine that when you put one of the ...
    
			
    9. 
						
  9. Python list,tuple,dict and set
			
    list 有序可变的集合 查找和插入的时间随着元素的增加而增加 占用空间小,浪费内存很少 tuple 有序只读不可变.因为tuple不可变,所以代码更安全.如果可能,能用tuple代替list就尽量用 ...
    
			
    10. 
						
  10. 《程序员代码面试指南》第三章 二叉树问题 判断t1 树中是否有与t2 树拓扑结构完全相同的子树
			
    题目 判断t1 树中是否有与t2 树拓扑结构完全相同的子树 java代码 package com.lizhouwei.chapter3; /** * @Description: 判断t1 树中是否有与 ...
    
			
    11.