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

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

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

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

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

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：

#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:

#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】的更多相关文章

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

随机推荐

Linux中crontab下scp文件传输的两种方式
Linux下文件传输一般有两个命令scp.ftp(工具需要下载安装) 本文主要讲讲scp的文件传输脚本 1.scp ssh-keygen -t rsa免输入密码,传输这里假设主机A 用来获到主机B的 ...
圆环自带动画进度条ColorfulRingProgressView
这是项目中遇到了,我也是借鉴大神的, 下载地址:https://github.com/oooohuhu/ColorfulRingProgressView 我把它导入了github中了,里面有详细的使用 ...
Xshell连接不上行Linux系统
之前出现了.我的Linux系统上的主机可以ping通windows的一台电脑, windows也可以ping的通Linux.但是Xshell不能连接. 第一,我感觉是不是我Linux系统的端口被防火墙 ...
linux下查找指定时间内修改过的或新建的文件
1.简单命令 # find -type f \( -newermt '2017-04-19 00:00' -a -not -newermt '2017-04-27 23:59' \) 2.简单实现(参 ...
MySQL存储过程-通过数据库里已存在的IP查询城市
CREATE DEFINER=`mazey`@`%` PROCEDURE `sp_find_city_by_ip`(IN `in_visitor_ip` varchar(20),OUT `out_vi ...
遇到IIS configuration error错误的可以看看，不一定是权限问题
最近接手了别人的一个 DOT NET项目,编译.调试一切都OK(心里暗暗高兴),发布吧,结果放到服务器上一运行出现Configuration Error错误,提示:“Access to the pat ...
常见数据挖掘算法的Map-Reduce策略(2)
接着上一篇文章常见算法的mapreduce案例(1)继续挖坑,本文涉及到算法的基本原理,文中会大概讲讲,但具体有关公式的推导还请大家去查阅相关的文献文章.下面涉及到的数据挖掘算法会有:L ...
fedora25 安装sublime text3
fedora 25安装使用 sublime text 3 安装 sublime text 3 fedora 需要选择 tarball 版本.下载后将 sublime text 3 解压后放到 opt ...
putty screen
http://www.cnblogs.com/xupeizhi/archive/2013/05/20/3088779.html screen 会创建一个跑着shell的单一窗口 Ctrl+a d退出刚 ...
3.06课·········C#语言基础
Main函数: static void Main(string [] args){ }程序代码需要写在Main函数的花括号内. 一.输出:Console.WriteLine("这是我的第一个 ...

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

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

随机推荐

热门专题