算法

二叉树的锯齿形层次遍历

package com.bhzt.algorithm;
/**
 * 树结构
 * @author puhome
 * 快速封装属性，点击空白处，Alert+s  选择Generate Getters and Setters
 */
public class TreeNode {
	TreeNode left;
	TreeNode right;
	int value;
	
	public TreeNode(int v) {
		this.value=v;
	}

	public TreeNode getLeft() {
		return left;
	}

	public void setLeft(TreeNode left) {
		this.left = left;
	}

	public TreeNode getRight() {
		return right;
	}

	public void setRight(TreeNode right) {
		this.right = right;
	}
	
	
	
	
}

package com.bhzt.algorithm;

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

/**
 * 树
 * @author puhome
 * ALT+/ 组合,window/preferences/java/设置自动补全
 */
public class Tree {
	
	public static List<Integer> scanTree(TreeNode treenode)
	{
		if(treenode==null)
		{
			return null;
		}
		
		List<Integer> list=new LinkedList<>();
		
		boolean isReverse=false;//是否反转
		Stack<TreeNode> stack=new Stack<TreeNode>();//从左到右存
		Stack<TreeNode> stacktwo=new Stack<TreeNode>();//从右到左存
		
		stack.push(treenode);
		
		while (!stack.isEmpty() || !stacktwo.isEmpty()) {
			
			if(!isReverse)
			{
				System.out.print("[");
				while (!stack.isEmpty()) {
					TreeNode scanNode=stack.pop();
					System.out.print(scanNode.value+" ");
					list.add(scanNode.value);
					
					if(scanNode.left!=null)
					{
						stacktwo.push(scanNode.left);
					}
					if(scanNode.right!=null)
					{
						stacktwo.push(scanNode.right);
					}
				}
				System.out.println("]");
				isReverse=true;
			}
			else {
				System.out.print("[");
				while (!stacktwo.isEmpty()) {
					TreeNode scanNode=stacktwo.pop();
					System.out.print(scanNode.value+" ");
					list.add(scanNode.value);
					
					if(scanNode.right!=null)
					{
						stack.push(scanNode.right);
					}
					if(scanNode.left!=null)
					{
						stack.push(scanNode.left);
					}
					
				}
				System.out.println("]");
				isReverse=false;
			}
		}
		
		return list;
	}
}

package com.bhzt.test;

import static org.junit.jupiter.api.Assertions.*;

import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import com.bhzt.algorithm.Tree;
import com.bhzt.algorithm.TreeNode;

/**
 * 单元测试较main测试，不用每次测试新的就把之前的注释掉
 * @author puhome
 *
 */
class TreeTest {

	private TreeNode treenode; 
	
	@BeforeEach
	public void before()
	{
		System.out.println("初始化");
		// 选中代码 Ctrl+/ 注释/取消注释
		TreeNode root=new TreeNode(3);
		TreeNode n1=new TreeNode(10);
		TreeNode n2=new TreeNode(20);
		
		root.setLeft(n1);
		root.setRight(n2);
		
		TreeNode n3=new TreeNode(30);
		TreeNode n4=new TreeNode(48);
		
		n2.setLeft(n3);
		n2.setRight(n4);
		
		treenode=root;
	}
	
	@AfterEach
	public void after()
	{
		System.out.println("运行结束，销毁");
	}

	@Test
	void scanTreeTest() {
		Tree.scanTree(treenode); //ctrl+鼠标左键 源码追踪
	}

}

最小子串覆盖