JavaSE——树

一、了解：

1.深度优先遍历（栈）：不撞南墙不回头

2.广度优先遍历（队列）：一层一层遍历

二、面试题

1.实现循环队列（array、size、front、rear）

//循环队列
public class MyCircularQueue {
    private int[] array;
    private int front = 0;
    private int rear = 0;
    private int size = 0;
    /**
     * Initialize  your data structure here.Set the size of the queue to be k.
     * */
    public MyCircularQueue(int k){
        array = new int[k];
    }

    public boolean enQueue(int value){
        if(array.length == size){
            return false;
        }

        array[rear] = value;
        rear = (rear + 1)%array.length;
        size ++;
        return true;
    }

    public boolean deQueue(){
        if(size == 0){
            return false;
        }

        front = (front +1)%array.length;
        size --;
        return true;
    }

    public int Front(){
        if(size == 0){
            return -1;
        }
        return array[front];
    }

    public int Rear(){
        if(size == 0){
            return -1;
        }

        int index = (rear -1 +array.length)%array.length;
        return array[index];
    }

    public boolean isEmpty(){
        return size == 0;
    }

    public boolean isFull(){
        return size == array.length;
    }
}

三、树状结构

1.一对多的关系

2.树的应用：电脑的文件管理、家族关系等

3.有序树和无序树：孩子节点的循环不重要的树为无序树，反之有序。

四、二叉树的简介：

1.度最大为2，是一颗有序树（递归思想+递归方法）

2.五种形式的树：空树、

3.二叉树的表示形式：（链式表示）

class Node{ 
int value; //值域 
Node left; //指向自己的左孩子，也可以代表以左孩子为根的整棵左子树 
Node right; //指向自己的右孩子，也可以代表以右孩子为根的整棵右子树 
} 

Node node = null; //空树 
//一个结点的树 
Node node; 
node!=null;node.left == null;node.right == null;

4.重点学习二叉树的遍历方式

（1）深度优先遍历：前序、中序、后序

（2）广度优先遍历：层序遍历

5.前/中/后遍历

二叉树看三部分组成：根、左子树、右子树

（1）前序遍历：根+左子树的前序+右子树的前序

（2）中序遍历：左子树的中序+根+右子树的中序

（3）后序遍历:左子树的后序+右子树的后序+根

例子1：树的遍历（时间复杂度：O(n) ）

（1）前：ABDGKHLEIMNPCFJO

（2）中：GKDLHBEMINPACFOJ

（3）后：KGLHDMPNIEBOJFCA

6.写递归的诀窍

（1）不要过早的做递归展开过程。想清楚自己到底是谁

（2）递推公式

（3）多考虑终止条件的问题（终止条件和形参有关）

  写完之后要理解过程，做递归展开理解

例题1：前序遍历

法一：递归

public static Node preOrderTraversal(Node root){     //递归方法
    if(root == null){
        return null;
    }
    //根+左子树+右子树
    System.out.println(root.value);
    preOrderTraversal(root.left);
    preOrderTraversal(root.right);
}

法二：非递归

public static List<Charater>preOrder(Node root){ 
 //创建多个链表，最后合并为一个值返回
     if(root == null){
        // return null;    //错误 
         return new ArrayList<>();  //正确写法，返回的是空的新链表
     }
     //根+左子树+右子树
     List<Charater>list = new ArrayList<>();
     List<Charater>leftPreOrder = preOrder(root.left);
    List<Charater>rightPreOrder = preOrder(root.right);
     list.add(root.value);
     list.addAll(root.left);
     list.addAll(root.right);
     return list;
}

 法三：

public class Solution{                        
    private List<Integer>list;    //全局变量
    
    private void preOrder(TreeNode root){
        if(root == null){
            return null;
        }
        //根+左子树+右子树
        list.add(root.val);
        preOrder(root.left);
        preOrder(root.right);
    }
    //创建一个List进行遍历，最后返回一个链表
    public static List<Inteter>preOderTeaversal(TreeNode root){
        list = new ArrayList<>();
        preOrder(root);
        return list;
    }
}