Grabe y revise algunos tipos de preguntas de la oferta de Jianzhi ~
Directorio de artículos
Reconstruir el árbol binario
Descripción del título
Ingrese los resultados del recorrido de preorden y recorrido de orden medio de un árbol binario, y reconstruya el árbol binario. Suponga que el resultado de entrada del recorrido de pedido anticipado y recorrido de orden medio no contiene números duplicados. Por ejemplo, ingrese la secuencia transversal de preorden {1,2,4,7,3,5,6,8} y la secuencia transversal de orden medio {4,7,2,1,5,3,8,6}, luego reconstruya el árbol binario y regreso.
La primera condición que se nos da es una matriz transversal de preorden y una matriz transversal en orden. Cabe señalar que para la matriz atravesada en el orden medio , el primer valor del recorrido de preorden es el valor medio del recorrido de orden medio . Por lo tanto, podemos dividir el recorrido de orden medio en pequeños rangos según el orden del recorrido de preorden y luego buscar a través de la recursividad.
Tome una castaña : Recorrido de pedido anticipado: {1,2,4,7,3,5,6,8}, el primer valor en 1 , recorrido en orden medio (4,7,2,1,5,3 , 8,6) es el valor medio exacto, por lo que el recorrido en orden se puede dividir en dos matrices {4,7,2} y {5,3,8,6}. La matriz {4,7,2} es el lado izquierdo de 1 nodo, la matriz {5,3,8,6} es el lado derecho de 1 nodo, luego solo es necesario atravesar el recorrido de preorden de la matriz, atravesará el primer valor Colóquelo en el rango de recorrido de orden medio. Esto no quiere decir que realmente desee cortar la matriz, simplemente registre el subíndice de la matriz de corte.
Por supuesto, hay muchas mejores formas de ser más rápido ... Mira el código para más detalles ~
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
//int [] pre 前序数组
//int [] in 中序数组
//获得前序比那里第一个元素
TreeNode treeNode = new TreeNode(pre[0]);
//设置下标为 0
int index = 0;
//遍历中序数组
for (int i = 0; i < in.length; i++) {
//找到对应的数字后退出 index记录下标
if (pre[0] == in[i]){
index = i;
break;
}
}
//调用方法，表示第一个元素的左子树在这个方法中返回
treeNode.left = ConstructProcess(pre, in, 0, index);
treeNode.right = ConstructProcess(pre, in, index + 1, pre.length);
//返回头结点
return treeNode;
}
public static TreeNode ConstructProcess(int[] pre, int[]in, int begin, int end){
//当输入的开始下标小于结束下标时继续
if (begin < end){
int index = 0;
//设置外围循环的名字为outer
outer:
//遍历前序遍历数组
for(int i:pre){
//设置一个j下标作为是否在限定范围里的判断
for (int j = 0; j < pre.length; j++) {
//如果j在范围里并且i的值正好能在中序数组中找到
if (j>= begin && j <end && i == in[j]){
、
//设置下标为j
index = j;
//退出外循环
break outer;
}
}
}
//设置当前节点为中序遍历找到的节点
TreeNode treeNode= new TreeNode(in[index]);
//递归获取左子树和右子树
treeNode.left = ConstructProcess(pre, in, begin, index);
treeNode.right = ConstructProcess(pre, in, index + 1, end);
//返回当前节点
return treeNode;
}
//不然返回null
return null;
}
}
Implementar la cola con dos pilas
Descripción del título
Utilice dos pilas para implementar una cola para completar las operaciones Push y Pop de la cola. Los elementos de la cola son de tipo int.
Se utilizan dos pilas para implementar las operaciones de adición y extracción de una cola. Luego, podemos crear dos pilas, la pila 1 como la pila de elementos de empuje, la pila 2 como la pila de elementos emergentes y, cuando la pila 2 esté vacía, colocar los elementos de la pila 1 en la pila 2.
Suplemento de conocimientos : ¿cómo implementar una cola con dos pilas? Simplemente agregue los elementos que deben pasarse a la primera pila, luego salga de la primera pila y luego añádalos a la segunda pila, de modo que los elementos que salieron de la segunda pila tengan la forma de una cola. Haz esta pregunta sobre esta base.
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
//第一个栈中添加元素
stack1.add(node);
}
public int pop() {
//当第二个栈为空时
if (stack2.size() == 0){
while (stack1.size() != 0){
//只要第一个栈不为空，就将剩余元素都放到二号栈中
stack2.push(stack1.pop());
}
}
//进行二号栈的pop()
return stack2.pop();
}
}
Rotar el número más pequeño de la matriz
Descripción del título
Mover los primeros elementos de una matriz al final de la matriz se denomina rotación de la matriz.
Ingrese una rotación de una matriz ordenada no decreciente y genere el elemento más pequeño de la matriz rotada.
Por ejemplo, la matriz {3,4,5,1,2} es una rotación de {1,2,3,4,5} y el valor mínimo de la matriz es 1.
NOTA: Todos los elementos dados son mayores que 0. Si el tamaño de la matriz es 0, devuelva 0.
… El tema parece muy complicado, y lo pensé un rato mientras lo hacía. La intención original debería ser dar una matriz ordenada, luego reemplazar los siguientes n números al frente y luego generar el valor mínimo. Después de pensar en registrar el primer valor máximo, la respuesta es recorrer para encontrar el primer valor menor que máximo.
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
//当数组为0，则返回
if(array.length == 0) return 0;
//设置第一个值为max
int max = array[0];
//从第二个值开始遍历
for(int i=1;i<array.length;i++){
//当max大于这个值时，说明这个值就是最小值，因为这是有序数组
if(max > array[i]){
return array[i];
}
}
return max;
}
}