Li Kou brush question diary /day7/6.30

Novice Village

When the Modify the string When , Need to use StringBuffer and StringBuilder class .

and String Class is different from ,StringBuffer and StringBuilder Class can be modified many times , And don't generate new unused objects .

because java The string cannot be modified , String splicing operation , A temporary copy of the string will be generated , And destroy it after use

 

In the use of StringBuffer Class time , Every time I was right about StringBuffer The object itself operates , Instead of generating new objects , So if The string needs to be modified. It is recommended to use StringBuffer.

StringBuilder Class in Java 5 It was proposed that , It and StringBuffer The biggest difference between them is StringBuilder Is not thread safe （ Can't sync access ）.

because StringBuilder Compare with StringBuffer Speed advantage , So in most cases, it is recommended to use StringBuilder class .

// Create a StringBuilder object 
StringBuilder sb = new StringBuilder(10);

// Create a StringBuffer object 
StringBuffer sBuffer = new StringBuffer(" Rookie tutorial website ：");

// Add content to sBuffer After the string 
sBbuffer.append(" Content ");

//toString()  Method is used to return a string representing  Number  The object is worth 
System.out.println(new Object().toString());

  Common methods ：

Java StringBuffer and StringBuilder class | Novice tutorial (runoob.com)

Java toString() Method | Novice tutorial (runoob.com)

Traversal of binary tree

Depth-first traversal （DFS）

  Their thinking ： Recursion , The idea of depth first traversal

Consider nodes and child nodes of nodes

If the node is a leaf node , Add this node at the end of the path that has been searched , Get a path from the root node to the leaf node , Add this path directly to the return variable

If the node is not a leaf node , Add this node at the end of the path that has been searched , And continue to recursively traverse every child node of the node

Traverse the entire binary tree , You get all the paths from the root node to the leaf node

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
            List<String> paths = new ArrayList<String>();    // Define a return variable paths
            constructPaths(root,"",paths);    // Recursively perform a depth first search 
            return paths;
    }
    public void constructPaths(TreeNode root,String path,List<String> paths){
        if(root != null){    // Determine whether the node exists 
            StringBuffer pathSB = new StringBuffer(path);    // Define a pathSB Used to store temporary paths 
            pathSB.append(String.valueOf(root.val));    // Add the node value to the end of the path 
            if(root.left == null && root.right == null){    // If it's a leaf node 
                paths.add(pathSB.toString());    // take pathSB convert to String Object is added to the return variable paths in 
            } else{
                pathSB.append("->");    // It's not a leaf node , Just add... After the temporary path ->
                constructPaths(root.left,pathSB.toString(),paths);    // Continue to search its child nodes 
                constructPaths(root.right,pathSB.toString(),paths);
            }
        }
    }
}