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

最新推荐文章于 2021-03-02 16:13:45 发布
最新推荐文章于 2021-03-02 16:13:45 发布
阅读量98 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/codemylife/p/3652371.html
版权

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

 

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

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

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

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);
    }
}
 
 
  

 
 

转载于:https://www.cnblogs.com/codemylife/p/3652371.html

A201241302241
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
升序链表转换成二叉搜索树（BST）
小肥羊快快跑
07-05 509
题目描述给定一个按升序排序的单链列表，将其转换为高度平衡的BST。解题思路关键点：二叉搜索树的中序遍历是升序的（1）快慢指针找到链表中点，作为根节点（2）递归链表的左半部分为左子树（3）递归链表的右半部分为右子树代码示例class Solution {public:    TreeNode *sortedListToBST(ListNode *head) {        return sorte...
【数据结构与算法】二叉排序树C实现（含完整源码）
兰亭风雨的专栏
02-25 3万+
二叉排序树（Binary Sort Tree，简称BST），又称二叉查找树，是红黑树、AVL树等的基础。它或是一棵空树，或者是具有下列性质的一棵二叉树： 1、若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 2、若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 3、它的左右子树也分别为二叉排序树。 二叉排序树通常有查找、插入、删除等操作。查找操作很简单，无非就是递归查找，有点类似二叉树遍历的过程。插入操作也不难，一般是先在二叉排序树pTree中查找，看是
二叉排序树的插入,创建
越过山丘
03-02 160
typedef struct node { int data; struct node *lc, *rc; } LNode, *BiTree; int *InsertValue(BiTree b, int x) { if (b == NULL) { LNode *p = (LNode *)malloc(sizeof(LNode)); p->data = x; p->lc = p->rc = NULL;
C语言 递归实现二叉排序树的插入
阳光大男孩！！！的博客
12-03 1840
前言 二叉排序树，是用于方便查找的一种树。 特征为，左子树的值小于根节点的值，右子树的值大于根节点的值。 插入思路 当树为空时，新建节点，并让其成为根节点。 如果值相同，那么代表插入失败。 如果值大于当前结点，应该插入到右子树。 如果值小于当前结点，应该插入到左子树。 整体是一个递归的思想。 二叉排序法 int insertNodeBinarySortedTree(BinarySortedTree T,int value) { // 空树则当根节点 if(T==NULL) {
二叉排序树的建立、插入、查找和删除
08-04
代码里有二叉排序树插入操作递归算法，二叉排序树插入操作非递归算法，二叉排序树删除操作，创建二叉排序树，二叉排序树查找递归算法，二叉排序树查找非递归算法
BST.rar_binary search tree_二叉搜索树
09-19
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
三元组、循环链表以及二叉查找树.zip_三元_三元组_二叉查找树_循环链表
09-21
最后，二叉查找树（Binary Search Tree, BST）是一种自平衡的二叉树，每个节点的左子树只包含小于当前节点的元素，右子树只包含大于当前节点的元素。这种特性使得二叉查找树在搜索、插入和删除操作上具有较高的效率...
二叉查找树详细介绍.docx
最新发布
06-27
二叉查找树（BST，Binary Search Tree）是一种特殊类型的二叉树，它的每个节点都遵循以下规则： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点的值都大于该节点的值。 3. 左右子树也...
二分搜索树-二叉查找树 .docx
03-13
二分搜索树，又称二叉查找树或有序二叉树，是一种特殊类型的二叉树，其每个节点都遵循以下规则： 1. 节点的左子树仅包含键值小于该节点的节点。 2. 节点的右子树仅包含键值大于该节点的节点。 3. 左右子树同样也是...
ABR.zip_abr_二叉查找树
09-21
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树上的所有节点的值都小于该节点的值，而右子树上所有节点的值都大于该节点的值。这个特性使得二叉...
有序链表转换二叉搜索树（快慢指针+递归实现）
weixin_43857345的博客
10-09 134
题目 给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序链表： [-10, -3, 0, 5, 9], 一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树： 注意点 1、利用慢指针（一次走一步）和快指针（一次走两步）的特点（当快指针到达尾节点或下一节点为尾节点时，慢指针刚好到达中间节点），得到中间节点； 2、将中间节点作
将排序链表转换成二叉搜索树
ZCC的专栏
07-23 491
//链表的节点 class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } } //树的节点 class TreeNode { int val; TreeNode left; TreeNode right...
#109 有序链表转换二叉搜索树
weixin_40340397的博客
12-07 94
给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 方法一：递归算法+二分法 用快慢指针找到链表中间节点，再分别对中间节点左右两边进行递归建树。 class Solution { public TreeNode sortedListToBST(ListNode head) { if (head == null) { return null;
由后序遍历结果构造二叉查找树 && 二叉查找树链表化
weixin_34313182的博客
08-27 128
　　二叉查找树通俗说就是左孩子比父亲小，右孩子比父亲大。构造这么一个树，树嘛，递归即可。 　　例如一棵树后序遍历是这样（下图的树）：2 9 8 16 15 10 25 38 45 42 30 20。最后的20肯定是树根，这里要抓住一个规律：20是树根，那么2 9 8 16 15 10都是左子树，25 38 42 45 30在右子树，因为左边都小于根、右边都大于根嘛。然后递归即可。 　　...
二叉查找树(二叉排序树)的详细实现
热门推荐
Touch_2011的专栏
09-28 6万+
1、序      详细实现了二叉查找树的各种操作：插入结点、构造二叉树、删除结点、查找、  查找最大值、查找最小值、查找指定结点的前驱和后继 2、二叉查找树简介      它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根
有序链表转换二叉搜索树
w903414的博客
12-13 128
题目描述： 给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序链表： [-10, -3, 0, 5, 9], 一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树： 链接：https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tre
根据单链表构造二叉查找树 Convert Sorted List to Binary Search Tree
LUCKYOJ
03-07 1345
问题：Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST. 思路：二叉查找树的构造往往伴随着二分查找的过程。这是一个单链表而不是数组。二分查找不好用。就用递归吧。每次找到链表的最中间结点， 作为树根节点，左右两侧作为左右孩子。 代
二叉排序树总结（插入，搜索，排序，中序遍地，递归，非递归）
woods2001的专栏
05-19 2816
#include #include #include "stack.h" using std::cout; using std::endl; //#define TEST_STACK #define TREE_NODE_SIZE 50 //定义树结点类型 class Node { public: int data;//数据 Node *parent;//父结点 Node *left;//左子结点 Node *right;//右子结点 //构造函数 Nod
"详解二叉查找树：结构、性质与操作
二叉查找树（BST，Binary Search Tree）是一种数据结构，它支持多种动态集合操作，包括search，minimum，maximum，predecessor，successor，insert以及delete。在二叉查找树上执行的基本操作时间与树的高度成正比。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值