面试算法题

二叉树遍历

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}
 
public class BinaryTreeTraversal {
 
    // 前序遍历
    public void preorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val + " ");
        preorderTraversal(root.left);
        preorderTraversal(root.right);
    }
 
    // 中序遍历
    public void inorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        inorderTraversal(root.left);
        System.out.print(root.val + " ");
        inorderTraversal(root.right);
    }
 
    // 后序遍历
    public void postorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        System.out.print(root.val + " ");
    }
 
    public static void main(String[] args) {
        // 构建二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
 
        BinaryTreeTraversal traversal = new BinaryTreeTraversal();
 
        System.out.println("前序遍历:");
        traversal.preorderTraversal(root);
 
        System.out.println("\n中序遍历:");
        traversal.inorderTraversal(root);
 
        System.out.println("\n后序遍历:");
        traversal.postorderTraversal(root);
    }
}

package test;

import javax.swing.tree.TreeNode;

public class TreeNodeTest {
	

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
 
    public TreeNode(){
    }
 
    public TreeNode(int val) {
        this.val = val;
    }
 
    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public static void main(String[] args) {

}


	

    /**
     * 递归实现前序遍历
     * @param treeNode  树的根节点
     */
    public static void preOrder1(TreeNode treeNode){
        // 若根节点为空，直接返回
        if(treeNode == null){
            return;
        }
        //打印根节点
        System.out.print(treeNode.val + "\t");
        // 遍历根节点的左子树
        preOrder1(treeNode.left);
        // 遍历根节点的右子树
        preOrder1(treeNode.right);
    }

//————————————————
//版权声明：本文为CSDN博主「给你两窝窝」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
//原文链接：https://blog.csdn.net/weixin_47382783/article/details/123821339

}

二叉树按层级打印

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>(); //用一个队列来存储每一层的节点
        if(root!=null) queue.offer(root);
        while(queue.size()>0){
            List<Integer> list = new ArrayList<Integer>();
            int length = queue.size();
            for(int i=0;i<length;i++){
                TreeNode t = queue.poll();
                list.add(t.val);
                if(t.left!=null) queue.offer(t.left);
                if(t.right!=null) queue.offer(t.right);
            }
            res.add(list);
        }
        return res;
    }
}
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/DLC990319/article/details/105277854

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}
 
public class BinaryTreeLevelOrderTraversal {
 
    public static void printTreeLevelOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
 
        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            List<Integer> levelList = new ArrayList<>();
 
            for (int i = 0; i < levelSize; i++) {
                TreeNode currentNode = queue.poll();
                levelList.add(currentNode.val);
 
                if (currentNode.left != null) {
                    queue.offer(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.offer(currentNode.right);
                }
            }
            System.out.println(levelList);
        }
    }
 
    public static void main(String[] args) {
        // 示例二叉树:
        //      1
        //     / \
        //    2   3
        //   / \   \
        //  4   5   6
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.right = new TreeNode(6);
 
        printTreeLevelOrder(root);
        // 输出:
        // [1]
        // [2, 3]
        // [4, 5, 6]
    }
}

tecent

  public static boolean isStringOk(String a){

        // boolean isOk = true;
        int end = a.length()/2;
        char b = a.charAt(0);
        char c = a.charAt(a.length()-1);

        if((b=='(' && c==')') ||(b=='[' && c==']') || (b=='{' && c=='}') ){
            if(a.length() == 2){
                return true;
            }
            a = a.substring(1, a.length()-1);
           System.out.println("递归后字符串：" + a);
           isStringOk(a);
        } else {
            return false;
        }
        return true;



}

二叉树按层级打印