数组化为二叉树

【剑指Offer】**序列化二叉树（二叉树的层序遍历输出用队列bfs；根据数组构建二叉树：队列）

2020-08-11 22:03:49

目录题目根据数组构建二叉树：用队列，依次取一个结点然后按数组顺序构建左右孩子题目请实现两个函数，分别用来序列化和反序列化二叉树。示例: 你可以将以下二叉树： 1 / \ 2 3 / \ 4 5 序列化为 "[1,2,...


目录
题目
根据数组构建二叉树：用队列，依次取一个结点然后按数组顺序构建左右孩子

题目
请实现两个函数，分别用来序列化和反序列化二叉树。
示例: 

你可以将以下二叉树：

    1
   / \
  2   3
     / \
    4   5

序列化为 "[1,2,3,null,null,4,5]"

根据数组构建二叉树：用队列，依次取一个结点然后按数组顺序构建左右孩子
根据数组nums[i]构建二叉树：

将根结点放入队列，同时记录已构造结点个数cnt=1;
然后每次从队列中取出一个结点，构建其左、右孩子，再给放进队列。
左右孩子的取值就是nums[cnt]
最后返回根结点

注意字符串转数字stoi(str)
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        //二叉树层序遍历。输出格式：[1,2,3,null,null,4,5]。
        //注意数字转字符串 to_string(i)
        if( root==NULL ){
            return "null";
        }
        queue<TreeNode*> que;
        //根结点
        que.push(root);
        string output = "";
        while( !que.empty() ){
            int size = que.size();
            for(int i=0; i<size; i++){
                TreeNode* node = que.front();
                que.pop();
                if( node == NULL ){//当前结点为空
                    output += "null,";
                }else{
                    output += to_string(node->val) + ",";
                    //不管左右子树是否为空，都要放进队列
                    que.push( node->left );
                    que.push( node->right );
                }
            }
        }
        //从0开始的out.length()-1个字符
        output = "[" + output.substr(0,output.length()-1) + "]"; 
        return output;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        //字符串分割，输入格式为：[1,2,3,null,null,4,5]
        if( data=="" || data=="[]" || data=="null"){ //注意这里判断字符串为null！！调试了好久！
            return NULL;
        }
        //按逗号分割
        vector<string> words;
        string temp = "";
        for(int i=1; i<=data.length()-2; i++){//去除了格式首尾的[]
            if(data[i]==','){
                words.push_back(temp);
                temp = "";
            }else{
                temp += data[i];
            }
        }
        words.push_back(temp);
        //开始构建二叉树：将根结点放入队列，同时记录已构造结点个数cnt=1;然后每次从队列中取出一个结点，它的左孩子是arr[cnt]构建的结点，它的右孩子是arr[cnt+1]构建的结点
        //注意字符串转数字stoi(str)
        if( words[0]=="" || words[0]=="null" ){
            return NULL;
        }
        queue<TreeNode *> que;
        int cnt = 0;
        //根结点
        TreeNode *root = new TreeNode(stoi(words[0]));
        que.push(root);
        cnt++; //已构造结点的个数
        //每次从队列中取出一个结点，创建其左右孩子，然后把左右孩子放入队列
        while( cnt<words.size() && !que.empty() ){
            TreeNode *node = que.front();
            que.pop();
            //左孩子
            if( cnt<words.size() && words[cnt]!="null" ){
                node->left = new TreeNode(stoi(words[cnt])); //左右孩子的取值跟已构造结点的个数有关
                que.push(node->left);
            }
            cnt++; 
            //右孩子
            if( cnt<words.size() && words[cnt]!="null"){
                node->right = new TreeNode(stoi(words[cnt])); //左右孩子的取值跟已构造结点的个数有关
                que.push(node->right);
            }
            cnt++; 
        }
        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));

收起

展开全文

※面试题37 序列化二叉树(java)(二叉树转数组，数组转二叉树)

2020-03-03 16:35:16

请实现两个函数，分别用来序列化和反序列化二叉树。示例: ...序列化为 "[1,2,3,null,null,4,5]" 注意：本题与主站 297 题相同：https://leetcode-cn.com/problems/serialize-and-deserialize-binar...

请实现两个函数，分别用来序列化和反序列化二叉树。

示例: 

你可以将以下二叉树：

    1
   / \
  2   3
     / \
    4   5

序列化为 "[1,2,3,null,null,4,5]"
注意：本题与主站 297 题相同：https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    public StringBuilder rserialize(TreeNode root, StringBuilder sb){
        if(root == null) sb.append("null,");
        else {
            sb.append(root.val);
            sb.append(",");

            rserialize(root.left, sb);
            rserialize(root.right, sb);
        }
        return sb;
    }
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        return rserialize(root, new StringBuilder()).toString();
    }

    public TreeNode rdeserialize(ArrayList<String> list) {
        String s = list.remove(0);
        TreeNode root = null;
        if(!s.equals("null")){
            root = new TreeNode(Integer.parseInt(s));
            root.left = rdeserialize(list);
            root.right = rdeserialize(list);
        }
        return root;
    }
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] parts = data.split(",");
        ArrayList<String> list = new ArrayList<>(Arrays.asList(parts));
        return rdeserialize(list);
    }
}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.deserialize(codec.serialize(root));

收起

展开全文

二叉树数组实现[C/C++]代码

2014-06-11 16:49:48

二叉树数组表示 1. [代码][C/C++]代码 01 #include 02 03 /* 04 *使用数组创建二叉树 05 * 1 初始化二叉树，btree[level] 初始化为...


                                        
                                            二叉树数组表示
1. [代码][C/C++]代码     
01
#include 
02

03
/*
04
*  使用数组创建二叉树
05
*    1 初始化二叉树，btree[level] 初始化为0
06
     2 level 标识二叉树的坐标
07
          左子树的坐标 level*2
08
          右子树的坐标 level*2+1
09
          从根节点开始，找到合适的位置，插入二叉树
10

11

12
*/
13
create_tree(int *btree,int *data, int len)
14
{
15
    int i;
16
    int level;
17

18
    btree[1]  = data[1];
19
    for(i=2;i<=len;i++)
20
    {
21
        level = 1;
22
        while(btree[level] != 0)
23
        {
24
            if(data > btree[level])
25
            {
26
                level = level*2+1;
27
            }else{
28
                level = level*2;
29
            }
30
        }
31
        btree[level] = data;
32
    }
33
}
34

35
//打印二叉树
36
void print_btree(int *btree,int len)
37
{
38
    int i,j;
39
    for(i=1;i
40
    {
41
        printf("%2d,{%d}\n",i,btree);
42
    }
43
    j = 1;
44
    printf("\t%d\n",btree[j]);
45
    while(j*2 < len){
46
        if(j*2 < len){
47
            printf("%d\t\t",btree[j*2]);
48
            printf("%d\t\t",btree[j*2+1]);
49
            printf("\n");
50
        }
51
        j++;
52
    }
53
}
54

55

56

57
void main()
58
{
59
    int btree[16];
60
    int data[10] = {0,5,6,4,8,2,3,7,1,9};
61
    //create a bree
62
    int i;
63
    for(i<=1;i<16;i++) btree = 0;
64

65
    create_tree(btree,data,9);
66
    print_btree(btree,16);
67

68
}
css3圆角
文章来源：http://www.huiyi8.com/css3/yuanjiao/
                                                            
                    
                                                    来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29691626/viewspace-1180696/，如需转载，请注明出处，否则将追究法律责任。
                                            

                
转载于:http://blog.itpub.net/29691626/viewspace-1180696/

收起

展开全文

二叉树序列化

千次阅读 2011-12-05 21:17:23

问题:如何将二叉树序列化为一个文本文件，使得文件的大小尽可能的小。想了四种方法：第一种方法：把二叉树按前序和中序遍历一遍，存两次二叉树。第二种方法：将二叉树按左枝为0，右枝为1进行路径编码，...

    问题:如何将二叉树序列化为一个文本文件，使得文件的大小尽可能的小。
     想了四种方法：
     第一种方法：把二叉树按前序和中序遍历一遍，存两次二叉树。
     第二种方法：将二叉树按左枝为0，右枝为1进行路径编码，那么每个节点都可以表示成，节点信息和路径信息进行永久化。 

     第三种方法：将二叉树变成满二叉树，采用数组存储满二叉树，那么数据index和根据二叉树的节点信息进行永久化。

0
1
2
3
4
5
6
7
8
9
ROOT
L
R
LL
LR
RL
RR
LLL
LLR
LRL


     第四种方法：采用一个位图和所有节点信息进行存储，位图上的0代表着相应满二叉树的节点没有节点，1代表有节点信息。

     四种方法比较：第一种方法，冗余信息量刚好是原有数据的两倍。

                                 第二种方法存储的是节点信息和路径信息，冗余信息量是（路径信息*节点数）

                                 第三种方法：冗余信息为，sizeof(unsigned int) * 节点数

                                 第四种方法：冗余信息为树的层数K，（2^k -1）bit 

      因此第四种方法在二叉树是满二叉树或者二叉树的层数比较小的情况下，信息量比较小，但是在树的层比较丰富的情况下，冗余信息非常大。我觉得也不是什么特别好的方法。貌似我还是没有得到正确答案。
#include<iostream>
#include <fstream>
#include<math.h>

#define  max(a,b) ((a)>(b)?(a):(b))

using namespace std;
//随机数大小
const int NUMBER = 9;
//修改树的深度
const int DEPTH = 6;

//文件流
ofstream fout3("serialize3.txt");
ofstream fout4("serialize4.txt");
ofstream fout("tree.txt");

//树节点信息
typedef struct Node
{
	int data;
	Node * left;
	Node * right;
} BinaryTree;


//随机生成二叉树
void generate(Node ** tree, int d)
{
	*tree = (Node *)malloc(sizeof(Node));
	(*tree)->data = rand()%NUMBER + 1;

	int isleft = rand()%DEPTH;
	if(d+isleft < DEPTH)
		generate(&((*tree)->left), d+1);
	else
		(*tree)->left = NULL;
	
	int isright = rand()%DEPTH;
	if (d+isright < DEPTH)
	{
		generate(&((*tree)->right), d+1);
	}
	else
		(*tree)->right = NULL;
}

//获取树的深度
int getTreeDepth(Node * tree)
{
	if (tree == NULL)
	{
		return 0;
	}
	int left = getTreeDepth(tree->left);
	int right = getTreeDepth(tree->right);
	
	return (max( left, right ) + 1);
}

//打印第i层树
void printTreeLevel(Node * tree, int index, int level,int depth)
{
	if(tree == NULL)
	{
		int length = pow(2.0,(depth-index))-1;
		for (int i=1; i <= length; i ++)
		{
			fout << "  ";
			cout <<" ";
		}
		return;
	}
	if(index == level)
	{
		//左子树宽度
		int length = pow(2.0,(depth-level-1))-1;
		for (int j=1; j <= length; j ++)
		{
			fout <<"  ";
			cout <<" ";
		}
		fout << tree->data;
		cout << tree->data;
		//右子树宽度
		for (int j=1; j <= length; j ++)
		{
			fout <<"  ";
			cout <<" ";
		}
		return;
	}

	printTreeLevel(tree->left, index +1,level, depth);
	fout <<"  ";
	cout <<" ";
	printTreeLevel(tree->right, index+1, level, depth);
}

//逐层遍历二叉树
//两种思路，一种采用广度遍历的方法，利用链表空间逐层存储，逐层打印
//一种使用递归的方法逐层打印
void printTree(Node * tree)
{
	int depth = getTreeDepth(tree);

	for (int i=0; i < depth; i ++)
	{
		printTreeLevel(tree, 0, i,depth);
		fout << endl;
		cout <<endl;
	}
}

//序列化，四种方法
//第一种方法：把二叉树按前序和中序遍历一遍，存两次二叉树。
//第二种方法：将二叉树按左枝为0，右枝为1进行路径编码，那么每个节点都可以表示成，节点信息和路径信息进行永久化。
//第三种方法：将二叉树变成满二叉树，采用数组存储满二叉树，那么数据index和根据二叉树的节点信息进行永久化。
//第四种方法：采用一个位图和所有节点信息进行存储，位图上的0代表着相应满二叉树的节点没有节点，1代表有节点信息。
//四种方法比较：第一种方法，冗余信息量刚好是原有数据的两倍。
//第二种方法存储的是节点信息和路径信息，冗余信息量是（路径信息*节点数）
//第三种方法：冗余信息为，sizeof(unsigned int) * 节点数
//第四种方法：冗余信息为树的层数K，（2^k -1）bit 
//因此第四种方法在二叉树是满二叉树或者二叉树的层数比较小的情况下，信息量比较小，但是在树的层比较丰富的情况下，
//冗余信息非常大。我觉得也不是什么特别好的方法。貌似我还是没有得到正确答案。

//第三种方法序列化
void serialize_3(Node *tree, unsigned int index)
{
	if (tree == NULL)
	{
		return;
	}
	
	fout3 << tree->data << " " << index << endl;
	serialize_3(tree->left, index*2);
	serialize_3(tree->right, index*2 +1);
}

//设置bitmap
void setbitmap(Node * tree, int * map,unsigned int bit, int level)
{
	if (tree == NULL)
	{
		return;
	}
	
	unsigned int index = bit / 32;
	unsigned int b = bit%32;
	map[index] = map[index] | (1<<b);
	fout4 << tree->data << " ";
	setbitmap(tree->left, map,  bit * 2+1, level+1);
	setbitmap(tree->right, map, bit * 2 +2 , level+1);
}

//第四种方法永久化
void seralize_4(Node* tree)
{
	int depth = getTreeDepth(tree);
	
	int len = (depth-5)>0? (depth-5) : 0;
	len = (1<<len);
	int* map = new int[len];
	memset(map, 0, sizeof(int) * len);
	setbitmap(tree, map, 0, 1);

	fout4<<endl;

	for (int i=0; i <len; i ++)
	{
		fout4 <<hex << map[i];
	}
	fout4 <<endl;
	delete [] map;
}

//释放内存
void deleteTree(Node * tree)
{
	if (tree == NULL)
	{
		return;
	}
	deleteTree(tree->left);
	deleteTree(tree->right);
	free(tree);
}

int main()
{
	BinaryTree * tree=NULL;

	//随机生成二叉树
	cout << "随机生成二叉树，并保存到tree.txt"<<endl;
	generate(&tree, 0);

	//树层比较低的，打印出二叉树
	if (DEPTH <= 15)
	{
		printTree(tree);
	}

	//第三种序列化方法
	cout << "用第三种方法持久化到serialize3.txt" <<endl;
	serialize_3(tree, 1);

	//第四种序列化方法
	cout <<"用第四种方法持久化到serialize4.txt" <<endl;
	seralize_4(tree);

	//回收空间
	deleteTree(tree);
	system("pause");
	return 0;
}


    运行效果：
    第一步，随机生成一个二叉树，并逐层打印，然后采用两种序列化方法进行序列化。



     第三种序列化文件为：

6 1
8 2
9 4
8 5
3 11
7 22
9 23
7 3
1 6
8 12
6 24
3 49
9 7
4 15
3 31
    第四种序列化方法为：


6 8 9 8 3 7 9 7 1 8 6 3 9 4 3       --数据
40e04c7f10000                       --位图，用16进制表示
   如上面分析的一样，第四种方法在二叉树是满二叉树或者二叉树的层数比较小的情况下，信息量比较小，但是在树的层比较丰富的情况下，冗余信息非常大。如在15层的二叉树中：
6 8 9 4 8 3 7 6 4 1 1 6 3 7 9 8 3 7 3 6 3 8 3 7 2 5 6 4 3 1 8 4 2 2 4 3 4 1 9 6 7 4 7 9 5 8 8 7 3 7 9 3 6 3 9 3 3 2 3 5 1 7 5 1 3 9 2 1 3 1 3 3 6 6 2 7 9 4 6 2 7 9 3 2 1 7 4 3 3 1 9 3 1 9 7 6 1 8 8 7 3 2 6 6 8 5 2 3 8 2 5 5 9 4 6 9 2 3 1 2 2 5 2 1 9 9 4 7 6 4 8 5 9 4 8 9 9 9 6 9 5 8 3 9 9 8 3 9 3 5 6 9 6 2 2 6 2 2 5 1 2 1 1 5 6 9 9 5 8 9 5 4 3 8 6 2 3 4 9 9 2 7 7 8 7 6 7 2 2 9 8 1 3 1 3 3 4 3 3 7 3 5 7 9 7 2 4 3 5 2 1 5 3 9 2 8 3 6 3 2 2 1 2 9 3 1 5 5 8 2 4 6 3 4 2 5 5 5 7 6 4 6 5 8 6 2 5 9 6 3 6 3 1 8 1 9 4 6 9 2 4 1 1 5 3 7 2 2 7 1 8 3 4 9 2 6 9 3 8 
3e8ffbff1f7901eb3d9867fe6004a7860038b380000606daf48130098068070189048001e8000009022418079e361e000007000838000794808400040800000001f1800018000820008006605401300580650004600000002e82801d8000802120000000018000000002c000118000008000000060000404105800000000400000100000000001928001000800001a21100000000000000008000000020000000000860000000020030000004000000020042000000000000000000000000000000200400098000005000000020000000000000000000000000000000000080000000000000000000000400000000000000000000002000000020180000100000000000000000000000000000000000000000000000000000000000000020000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000002000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000


    信息量随着层数的增加，信息量成几何级扩大。但是，研究16进制字符串位图数据可以发现里面的数据0出现的特别多，因此下一步可以采用huffman编码等压缩编码方式对字符串数据进行数据压缩。
    下一步：采用二进制编码对位图数据进行数据压缩。

收起

展开全文

tree 存储 null struct hex

数据结构 - 二叉树 - 遍历算法代码
2019-04-21 17:30:45
说明： 二叉树的常见遍历有四种：前、中、后、层序遍历。它们是最基本的，学会这些遍历后才能使用二叉树来做一些任务。下面是遍历的代码部分。...（2）将数组初始化全为-1（其实初始化为0最好，就是后面保存二叉...
收起
数据结构遍历 c++
二叉树的序列化与反序列化
千次阅读 2015-01-04 19:15:28
一个二叉树被序列化为数组，如何反序列化，也就是如何从序列化好的一个数组恢复成二叉树？在上一篇文章中讲述了如何将一个有序数组创建成一个二叉搜索树，那么如果将将一个儿茶搜索树序列化为一个有序数组，然后...
收起
C++ 算法
剑指offer第37题序列化二叉树
2020-10-16 09:00:58
文章目录问题描述：解题思路：代码实现：复杂度分析： ...需要注意的是：将字符串转换为二叉树的时候，首先将字符串转换为字符串数组。将二叉树转换为字符串时需要注意对节点是null的情况处理，不要忽略了nul
收起
树（6）二叉树层序遍历
2020-08-04 17:01:09
原料：大结果集（二维数组=每层的结果集+深度/数组元素下标）、层数（初始化为0）、给定的二叉树，每层的结果集（每层的值）临界点：给定的为NULL，返回空数组；（使用一个变量level来标记当前的深度，初始化带入...
收起
实现js的二叉树
2016-08-20 16:45:00
二叉树实现原理：把数组的第一个数据当作根节点，每个节点都有根节点，左孩子和右孩子，初始化为null。 1 function tree() { 2 this.value = null; 3 this.left = null; 4 this.right =...
收起
二叉树——实现堆结构
2015-11-23 09:46:00
定义一个数组，初始化为空。在数组上执行两种操作： 1、增添1个元素，把1个新的元素放入数组。 2、输出并删除数组中最小的数。使用堆结构实现上述功能的高效算法。输入第一行输入一个整数t，代表测试数据的组数。...
收起
剑指 Offer 37. 序列化二叉树 java
2020-11-06 17:25:53
序列化为 “[1,2,3,null,null,4,5]” 来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof 解题： /** * 序列法，反序列化树 * 序列化，树转为数组 * 反序列化，数组转为...
收起
java
剑指Offer.37 序列化二叉树
2020-09-27 23:41:20
请实现两个函数，分别用来序列化和反序列...反序列化: 将字符串去头去尾, 以","分割成字符串数组, 借助队列, 扫描数组, 如果元素不是"null"则添加子节点代码 /** * Definition for a binary tree node. * public cla
收起
队列字符串
剑指 Offer 37. 序列化二叉树
2021-01-18 15:23:44
剑指 Offer 37. 序列化二叉树 请实现两个函数，分别用来序列化和反序列化二叉树。...数组尾有多余的null也没有关系，最后序列化和反序列是一对相反的操作。 public class Codec { public String serialize(TreeNode
收起
剑指offer之序列化二叉树（Java实现）
2018-12-27 16:31:27
序列化二叉树 NowCoder 题目描述: 请实现两个函数，分别用来...1.序列化是指通过前序遍历把二叉树变成数组 2.反序列化是指重建二叉树 public class Solution { public int index = -1; String Serialize(TreeNo...
收起
剑指offer
[wikioi]二叉树最大宽度和高度
2013-08-22 00:17:00
简单的DFS，用数组w记录...还有二叉树的数组表示时，从1开始计数会比较好。还有后来学会了数组这样的初始化为0的方法：int l[100] = {0},r[100] = {0}; #include <iostream> using namespace std; int l...
收起
数据结构与算法（三）二叉树
千次阅读 2018-08-09 21:38:54
定义一个数组，初始化为空。在数组上执行两种操作： 1、增添1个元素，把1个新的元素放入数组。 2、输出并删除数组中最小的数。使用堆结构实现上述功能的高效算法。输入第一行输入一个整数t，代表测试数据的...
收起
【知识整理|树(一)】二叉树的构建、深度、宽度
2019-03-21 20:55:28
二叉树 节点的定义和创建当我们对动态内存的申请和释放的写法没有把握时，可以利用静态数组，将数组元素分配给相应节点。...//静态数组中已经分配的节点数，在创建一棵树前记得初始化为0 Node *...
收起
数据结构
图形化打印二叉树
千次阅读 2016-03-06 13:36:39
首先，需要一个数组来作为显示的缓存，我们选取buffer[6][128]这样一个缓存，因此最大只能显示6层的树。将buffer中的元素全部初始化为INF 统计出树的高度，从1开始计数。采用中序遍历的方法在缓存中打印树。采用一个...
收起
剑指offer--（20）序列化二叉树--Java描述
2018-02-25 15:46:16
写在前面： 二叉树的序列化：在前序遍历的基础上，将二叉树的结点遍历成一个字符串 二叉树的反序列化：...来分割出一个数组（3）定义一个index，初始化为-1，在反序列化时，记录数组的索引。代码实现： public cla...
收起
剑指Offer Java
[leetCode]剑指 Offer 37. 序列化二叉树
2020-08-31 10:13:00
可以使用前序遍历将二叉树序列化为字符串，遇到null用字符串“null,”代替。反序列化时将序列化的结果转化为String数组，每次读取一个字符串，如果是数字则按照前序遍历继续递归。 /** * Definition for a binary ...
收起
输入N组父子对，求父子对所组成的二叉树的高度----17年某公司的笔试题
2019-09-27 04:45:43
题目的大致意思如下：输入N组数，一组数代表一个父子对（如，0 1,0代表父节点，1代表子节点），求这...解题思路：动态规划法，使用一个数组hight[N]记录每组数所能组成的二叉树的高度,初始化为全1数组，使用一个数...
收起
剑指offer0514：1、序列化二叉树;2、二叉搜索树的第k个节点；3、数据流中的中位数
2019-05-14 19:23:18
1.序列化是指通过前序遍历把二叉树变成数组 2.反序列化是指重建二叉树 前序遍历序列化，null序列化为‘#’,index 为全局变量链接：https://www.nowcoder.com/questionTerminal/cf7e25aa97c04cc1a6...
收起
堆排序的实现
2019-03-11 20:15:39
* 堆排序本质是将数组视为完全二叉树进行操作 * 如果是进行升序排序，那么需要将堆初始化为大根堆（所有的节点的值均大于左右孩子节点的值） * 反之，初始化为小根堆 * 堆排序主要分为两个过程：将数组初始...
收起
堆排序
STL 之 heap
2014-03-05 18:46:28
heap是一个满二叉树，实际运用中可以化为一个数组。把数组ans[]化为heap之后，其第i个元素的父节点（假如存在）是i/2，其左儿子为2*i，右儿子为2*i+1。 heap默认是最大堆。下图是从STL-源码剖析中copy出来的： ...
收起
CC++ STL
Python剑指offer打卡-8
2021-02-18 09:38:28
文章目录Python剑指offer打卡-8序列化二叉树连续子数组的最大和二叉树的深度二叉搜索树与双向链表矩形覆盖序列化二叉树 问题描述请实现两个函数，分别用来序列化和反序列化二叉树。你可以将以下二叉树： 1 ...
收起
链表指针 leetcode 算法
常见排序算法:堆排序算法
2019-05-06 16:20:48
基本思想：先将待排序数据化为完全二叉树，从length/2+1处开始寻找他的左/右子节点，将较大值与父节点进行交换，最后遍历到根节点处，此时根节点为所有数中的最大值，将该值与最后一个元素进行交换，length=length-1...
收起
堆排序
2010-05-04 21:35:00
我想说的不是内存中的堆空间，这里的堆只是一种组织方式，采用的是用完全二叉树的形式来表示一维数组，就是说如果是一个大顶堆的话，根部的数是最大的，从根部开始，一层一层对应数组，例如数组int a[6]={6,5,4,3,2,...
收起
算法 c

【剑指Offer】**序列化二叉树（二叉树的层序遍历输出用队列bfs；根据数组构建二叉树：队列）

目录

题目

根据数组构建二叉树：用队列，依次取一个结点然后按数组顺序构建左右孩子

※面试题37 序列化二叉树(java)(二叉树转数组，数组转二叉树)

二叉树数组实现[C/C++]代码

二叉树序列化

数据结构 - 二叉树 - 遍历算法代码

二叉树的序列化与反序列化

剑指offer第37题序列化二叉树

树（6）二叉树层序遍历

实现js的二叉树

二叉树——实现堆结构

剑指 Offer 37. 序列化二叉树 java

剑指Offer.37 序列化二叉树

剑指 Offer 37. 序列化二叉树

剑指offer之序列化二叉树（Java实现）

[wikioi]二叉树最大宽度和高度

数据结构与算法（三）二叉树

【知识整理|树(一)】二叉树的构建、深度、宽度

图形化打印二叉树

剑指offer--（20）序列化二叉树--Java描述

[leetCode]剑指 Offer 37. 序列化二叉树

输入N组父子对，求父子对所组成的二叉树的高度----17年某公司的笔试题

剑指offer0514：1、序列化二叉树;2、二叉搜索树的第k个节点；3、数据流中的中位数

堆排序的实现

STL 之 heap

Python剑指offer打卡-8

常见排序算法:堆排序算法

堆排序

数组化为二叉树

【剑指Offer】**序列化二叉树（二叉树的层序遍历输出用队列bfs；根据数组构建二叉树：队列）

目录

题目

根据数组构建二叉树：用队列，依次取一个结点然后按数组顺序构建左右孩子

※面试题37 序列化二叉树(java)(二叉树转数组，数组转二叉树)

二叉树数组实现[C/C++]代码

二叉树序列化

数据结构 - 二叉树 - 遍历算法代码

二叉树的序列化与反序列化

剑指offer第37题 序列化二叉树

树（6）二叉树层序遍历

实现js的二叉树

二叉树——实现堆结构

剑指 Offer 37. 序列化二叉树 java

剑指Offer.37 序列化二叉树

剑指 Offer 37. 序列化二叉树

剑指offer之序列化二叉树（Java实现）

[wikioi]二叉树最大宽度和高度

数据结构与算法（三）二叉树

【知识整理|树(一)】二叉树的构建、深度、宽度

图形化打印二叉树

剑指offer--（20）序列化二叉树--Java描述

[leetCode]剑指 Offer 37. 序列化二叉树

输入N组父子对，求父子对所组成的二叉树的高度----17年某公司的笔试题

剑指offer0514：1、序列化二叉树;2、二叉搜索树的第k个节点；3、数据流中的中位数

堆排序的实现

STL 之 heap

Python剑指offer打卡-8

常见排序算法:堆排序算法

堆排序

数组化为二叉树

剑指offer第37题序列化二叉树