8. árboles
Una estructura de árbol generalmente consta de un nodo principal y varios nodos secundarios. Su eficiencia de consulta y adición y eliminación es muy alta. Cualquier árbol de múltiples bifurcaciones se puede convertir a la forma de un árbol binario, por lo que el estudio de los árboles binarios no pierde generalidad.
-
Árbol binario : cada nodo solo puede tener como máximo 2 nodos;
-
Árbol binario completo : todos los nodos hoja están al mismo nivel;
-
Árbol binario completo : todos los nodos hoja se corresponden uno a uno con los nodos numerados 1-n en el árbol binario completo correspondiente;
El método transversal del árbol binario: (el orden de salida del nodo principal puede determinar el método transversal)
-
Recorrido de preorden: primero imprima el nodo principal y luego preordene el recorrido del subárbol izquierdo y el subárbol derecho;
-
Recorrido en orden: recorra primero el subárbol izquierdo en orden, luego genere el nodo principal y luego recorra el subárbol derecho en orden;
-
Recorrido posterior al pedido: recorre el subárbol derecho en secuencia, luego recorre el subárbol izquierdo en orden posterior y luego genera el nodo principal;
Entre ellos, hay dos formas de recorrido: recursividad e iteración. El algoritmo DFS se usa para implementar el recorrido pre-medio-posterior al orden; el algoritmo BFS se usa para implementar el recorrido a través del orden de las capas.
8.1, árbol binario y operaciones relacionadas
Composición del nodo: solo hay un nodo raíz:MyNode root
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {
}
TreeNode(int val) {
this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
La implementación del recorrido : introduzca el recorrido previo al pedido y el recorrido posterior al pedido es similar.
/**
* 结点方法:先序遍历
*/
public void preTraverse(){
//先输出当前结点
System.out.println(this);
//递归遍历左子树
if(this.getLeft()!=null){
this.left.preTraverse();
}
//递归遍历右子树
if(this.getRight()!=null){
this.right.preTraverse();
}
}
/**
* 二叉树方法:先序遍历
*/
public void preTraverse(){
if(root!=null){
root.preTraverse();
}else {
System.out.println("二叉树为空!无法遍历!");
}
}
Recorrido iterativo:
/**
* 统一一下
* @param root
* @return
*/
//前序
public static List<Integer> preOrder(TreeNode root){
List<Integer> list = new ArrayList();
Stack<TreeNode> stack = new Stack();
TreeNode cur = root;
while(cur!=null || !stack.isEmpty()){
//一直往左压入栈
while(cur!=null){
list.add(cur.val);
stack.push(cur);
cur = cur.left;
}
//弹一个出来从
cur = stack.pop();
cur = cur.right;
}
return list;
}
//中序
public List<Integer> inorderTraversal(TreeNode root) {
if(root == null){
return new ArrayList();
}
List<Integer> list = new ArrayList();
Stack<TreeNode> stack = new Stack();
TreeNode cur = root;
while(cur != null || !stack.isEmpty()){
while(cur!=null){
stack.push(cur);
cur = cur.left;
}
cur = stack.pop();
list.add(cur.val);
cur = cur.right;
}
return list;
}
//后序遍历,非递归
public static List<Integer> postOrder(TreeNode root){
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
TreeNode cur = root;
TreeNode p = null;//用来记录上一节点
while(!stack.isEmpty() || cur != null){
while(cur != null){
stack.push(cur);
cur = cur.left;
}
cur = stack.peek();
// 后序遍历的过程中在遍历完左子树跟右子树cur都会回到根结点。所以当前不管是从左子树还是右子树回到根结点都不应该再操作了,应该退回上层。
// 如果是从右边再返回根结点,应该回到上层。
//主要就是判断出来的是不是右子树,是的话就可以把根节点=加入到list了
if(cur.right == null || cur.right == p){
list.add(cur.val);
stack.pop();
p = cur;
cur = null;
}else{
cur = cur.right;
}
}
return list;
}
Recorrido de orden de nivel de un árbol binario:
public List<List<Integer>> levelOrder(TreeNode root) {
// BFS算法
List<List<Integer>> res = new ArrayList();
if(root == null) return res;
Queue<TreeNode> queue = new LinkedList();
// 队列中存放节点
queue.offer(root);
// 控制纵向
while(!queue.isEmpty()){
int size = queue.size();
List<Integer> list = new ArrayList();
for(int i=0;i<size;i++){
TreeNode curr = queue.poll();
list.add(curr.val);
if(curr.left!=null){
queue.add(curr.left);
}
if(curr.right!=null){
queue.add(curr.right);
}
}
res.add(list);
}
return res;
}
Implementación de búsqueda:
/**
* 中序查找指定结点
* @param no
* @return
*/
public MyNode inOrderFind(int no){
MyNode node = null;
//递归遍历左子树
if(this.left!=null){
node = this.left.inOrderFind(no);
}
//左遍历结束后,查看是否找到,不为空即找到
if(node!=null){
return node;
}
if(this.no==no){
return this;
}
//否则右序遍历
if(this.right!=null){
node = this.right.inOrderFind(no);
}
return node;
}
/**
* 中序查找
* @param no
* @return
*/
public MyNode inOrderFind(int no){
if(root!=null){
return root.inOrderFind(no);
}else {
return null;
}
}
La implementación de eliminar nodo:
Convención: si el nodo eliminado es un nodo hoja, se eliminará directamente, y si no es un nodo hoja, se eliminarán el nodo y todos sus nodos secundarios.
/**
* 删除结点
* @param no
*/
public void deleteNode(int no) {
if (root != null) {
//如果当前结点为待删除结点,直接删除
if (root.getNo() == no) {
root=null;
return;
}
root.deleteNode(no);
}else {
System.out.println("二叉树为空!不能删除!");
}
}
/**
* 删除结点
* 思路:找到当前结点的子结点是否为需要删除结点,是,直接置空,否则,向左递归删除,然后向右递归
* @param no
*/
public void deleteNode(int no){
if(this.left!=null && this.left.no==no){
this.left=null;
return;
}
if(this.right!=null&& this.right.no==no){
this.right=null;
return;
}
if(this.left!= null){
this.left.deleteNode(no);
}
if(this.right!= null){
this.right.deleteNode(no);
}
}