前序遍历:
public class PreOder {
static List<Integer> preOder1 = new ArrayList<>();
static List<Integer> preOder2 = new ArrayList<>();
private void recurrent(TreeNode node){//前序递归
preOder1.add(node.val);
if (node.left!=null) recurrent(node.left);
if (node.right!=null) recurrent(node.right);
}
private List<Integer> unRecurrent(TreeNode node){//前序非递归
Stack<TreeNode> stack = new Stack<>();
while (node!=null || !stack.isEmpty()){
while (node!=null){
preOder2.add(node.val);
stack.add(node.right);
node = node.left;
}
if (!stack.isEmpty()) {
node = stack.pop();
}
}
return preOder2;
}
}
中序遍历:
public class InOder {
static List<Integer> inOder1 = new ArrayList<>();
static List<Integer> inOder2 = new ArrayList<>();
private void recurrent(TreeNode node){//前序递归
if (node.left!=null) recurrent(node.left);
inOder1.add(node.val);
if (node.right!=null) recurrent(node.right);
}
private List<Integer> unRecurrent(TreeNode node){//前序非递归
Stack<TreeNode> stack = new Stack<>();
while (node!=null || !stack.isEmpty()){
while (node!=null){
stack.add(node);
node = node.left;
}
if (!stack.isEmpty()) {
node = stack.pop();
inOder2.add(node.val);//先找到最左边的值
node = node.right;//然后获得右边值,在获得中间值
}
}
return inOder2;
}
}
后序遍历
非递归需要用到两个栈;
public class PostOder {
static List<Integer> postOder1 = new ArrayList<>();
static List<Integer> postOder2 = new ArrayList<>();
private void recurrent(TreeNode node){//后序递归遍历
if (node.left!=null) recurrent(node.left);
if (node.right!=null) recurrent(node.right);
postOder1.add(node.val);
}
//双栈法,目的是在stack2从后序的反向输入;
private List<Integer> unRecurrent(TreeNode node){//后序非递归
Stack<TreeNode> stack1 = new Stack<>();
Stack<TreeNode> stack2 = new Stack<>();
stack1.add(node);
while (!stack1.isEmpty()) {
TreeNode head = stack1.pop();
stack2.push(head);
if (node.left!=null) stack1.push(head.left);
if (node.right!=null) stack1.push(head.right);
}
while (!stack2.isEmpty()){
postOder2.add(stack2.pop().val);
}
return postOder2;
}
}
层序遍历
分层进行输入;
public class LevelOder {//递归遍历
List<List<Integer>> reses = new ArrayList<>();//里面嵌套的是LinkedList<>();
List<List<Integer>> levelOder = new ArrayList<>();
public List<List<Integer>> levelOrder_3(TreeNode root) {
recurrent(root,0);
return levelOder;
}
/* 递归层序遍历,输出半存在levelOder里面 */
private void recurrent(TreeNode root,int level){
if (root == null) return;
if (levelOder.size()<level) levelOder.add(new ArrayList<Integer>());
List<Integer> temp = levelOder.get(level);
temp.add(root.val);//
recurrent(root.left,level+1);
recurrent(root.right,level+1);
}
/* 非递归层序遍历二叉树,输出int[]类型 */
public int[] levelOrder_2(TreeNode root) {
if (root == null) {
return new int[0];
}
ArrayList<TreeNode> queue = new ArrayList<TreeNode>();
queue.add(root);
for (int i = 0; i < queue.size(); i++) {//先把数据按顺序放在队列内
TreeNode node = queue.get(i);
if (node.left != null) {
queue.add(node.left);//先入先出
}
if (node.right != null) {
queue.add(node.right);
}
}
int[] res = new int[queue.size()];
for (int i = 0; i < queue.size(); i++) {
res[i] = queue.get(i).val;
}
return res;
}
/* 层序遍历二叉树,一排往左一排往右 */
public List<List<Integer>> levelOrder_1(TreeNode root) {
recur(root, 0);
return reses;
}
//递归函数,增加是那层的判断
void recur(TreeNode root, int level) {
if (root == null) return;
if (reses.size() == level) reses.add(new LinkedList<Integer>());//强制向下转型
LinkedList<Integer> res = (LinkedList<Integer>) reses.get(level);
if ((level & 1) == 0) res.addLast(root.val);//若层数level为偶数层,将当前值放在前面<--
else res.addFirst(root.val);//若level为奇数-->将当前值放在最后
recur(root.left, level+1);//添加使用一样的方式
recur(root.right, level+1);
}
}