Adquira o hábito de escrever juntos! Este é o 9º dia da minha participação no "Nuggets Daily New Plan · April Update Challenge", clique para ver os detalhes do evento .
Olá a todos, eu sou o irmão melancia front-end. Hoje falaremos sobre um problema um tanto difícil de algoritmo de árvore binária: construir uma árvore binária a partir de uma sequência de travessia pré-ordem e in-ordem.
Dadas duas matrizes de inteiros preorder e inorder, onde preorder é uma travessia preorder de uma árvore binária e inorder é uma travessia inorder da mesma árvore, construa uma árvore binária e retorne seu nó raiz.
Exemplo 1:
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]
复制代码Exemplo 2:
输入: preorder = [-1], inorder = [-1]
输出: [-1]
复制代码Endereço do tópico LeetCode:
Ideias
O cerne deste problema é fazer bom uso das características de travessia de pré-ordem e travessia de in-ordem da árvore binária.
Vejamos esta árvore binária em nosso exemplo.
Sua travessia de pré-encomenda é:[3,9,20,15,7]
A travessia em ordem é:[9,3,15,20,7]
A característica da travessia de pré-ordem é visitar primeiro o nó raiz e depois visitar os nós esquerdo e direito. Assim , no array de travessia de pré-ordem, o primeiro elemento é o nó raiz de toda a árvore .
A travessia de pré-ordem remove os nós restantes após o primeiro elemento. Na verdade, é possível encontrar uma posição de índice e dividir esses nós. Após a divisão, o lado esquerdo é o conjunto de nós esquerdo e o lado direito é o conjunto de nós direito.
Vejamos a travessia em ordem, quais são as características da travessia em ordem. A travessia em ordem visita primeiro o nó esquerdo, depois o nó raiz e, finalmente, o nó direito.
Anteriormente, sabíamos o que era o nó raiz através do percurso pré-ordem, e então encontramos a posição do nó raiz no percurso inorder.
Neste momento, o lado esquerdo da posição do nó raiz são todos os nós da subárvore esquerda do nó raiz (devido 左->根->右às ), e também podemos calcular o número de subárvores esquerdas neste momento.
Depois de obter o número de subárvores esquerdas, podemos voltar ao percurso de pré-ordem para calcular o subarray da subárvore esquerda.
Aqui obtemos o array de travessia de pré-ordem e o vetor de travessia de inorder da subárvore esquerda.
Ei, isso não é uma boneca aninhada? Em seguida, passamos esses dois arrays para a função recursiva, e a recursão é formada.
O mesmo vale para a subárvore direita, então não entrarei em detalhes aqui.
Código
Deixe-me mostrar minha implementação de código.
function buildTree(preorder, inorder) {
if (preorder.length === 0) return null;
const first = preorder[0];
const root = new TreeNode(first);
// 根节点在中序遍历中的位置
const idx = inorder.indexOf(first);
root.left = buildTree(
preorder.slice(1, idx + 1),
inorder.slice(0, idx)
);
root.right = buildTree(
preorder.slice(idx + 1),
inorder.slice(idx + 1)
);
return root;
};
复制代码每次我们找到中序遍历中根节点的位置 idx，找到数组的切割位置。分别对 preorder 和 inorder 进行切割，找到左子树和右子树各自的前序遍历和中序遍历数组，然后接着递归。递归结束条件为数组为空。
这种实现的优点是可读性好，不容易写错。
但从效率上，它可以更好，有两个地方可以改进：
-
每次都要拷贝旧数组生成一个新数组，其实这里我们可以通过维护两对数组开头和结束索引来避免拷贝
-
每次都要遍历 inorder 数组，来找出根节点的位置，效率较低。这点可以用哈希表缓存值到索引的映射。
我并不喜欢这种极致的优化导致的可读性下降。不过我还是得和你们说说优化思路的。
用了这两个方案后，我就要用一个新的递归函数了，因为参数变了。在这里，你可以给递归函数_buildTree 或 MyBuildTree 或者 f（函数的意思）、r（递归的意思）。
这里的命名我都不满意，我还是想用 buildTree。要是 JavaScript 也支持 Java 的那种真正的多态写法就好。Java Script 你这个冒牌 Java。
function buildTree(preorder, inorder) {
const map = {};
for (let i = 0; i < inorder.length; i++) {
map[inorder[i]] = i;
}
return _buildTree(
preorder, inorder, map,
0, preorder.length,
0, inorder.length
);
};
function _buildTree(preorder, inorder, map, pL, pR, iL, iR) {
if (pL >= pR) return null;
const first = preorder[pL];
const root = new TreeNode(first);
const idx = map[first];
const leftSize = idx - iL;
root.left = _buildTree(
preorder, inorder, map,
pL + 1, pL + 1 + leftSize,
iL, iL + leftSize
);
root.right = _buildTree(
preorder, inorder, map,
pL + leftSize + 1, pR,
idx + 1, iR
);
return root;
};
复制代码这种实现的递归函数参数非常多，眼花缭乱，而且计算索引时也非常容易写错，但相比第一种实现确实运行效率更高。
结尾
代码是写给人看的，不是写给机器看的，只是顺便计算机可以执行而已。
在可读性和性能上，我们需要根据场景进行权衡。
如果是业务逻辑代码，对性能没有极致的要求，请写给人看的代码，可读性优先。
如果是底层的注重性能的非业务代码，比如像是 C++ 的 STL 库，那就写出极致性能的代码，可读性可以适当妥协。但这要求你花费更多时间去编写代码，且需要有足够的测试用例来保证正确性。
如果你去面试做算法题，不要强求自己一次写出完美的最佳实现。写出第一版后，再在原来的基础上一点点优化。面试官想要考察你的代码优化能力和思考。
我是前端西瓜哥，欢迎关注我。
本文首发于我的公众号：前端西瓜哥