2019.9.20
175.组合两个表(颤抖…第一次用Join)
SELECT FirstName, LastName, City, State
FROM Person
LEFT JOIN Address
ON Person. PersonId = Address. PersonId
700.二叉搜索树中的搜索(我终于会一点点树的递归了!)
public TreeNode searchBST ( TreeNode root, int val) {
if ( root == null) { return null; }
if ( root. val < val) {
return searchBST ( root. right, val) ;
} else if ( root. val > val) {
return searchBST ( root. left, val) ;
} else {
return root;
}
}
public TreeNode searchBST ( TreeNode root, int val) {
if ( root == null) { return null; }
TreeNode tmp = root;
while ( tmp != null) {
if ( tmp. val == val) {
return root;
} else if ( tmp. val < val) {
root = root. right;
} else if ( root. val > val) {
root = root. left;
}
tmp = root;
}
return null;
}
590.N叉树的后序遍历
private List< Integer> list = new ArrayList < Integer> ( ) ;
public List< Integer> postorder ( Node root) {
post ( root) ;
return list;
}
private void post ( Node root) {
if ( root == null) { return ; }
for ( Node node: root. children) {
post ( node) ;
}
list. add ( root. val) ;
}
public List< Integer> postorder ( Node root) {
List< Integer> list = new ArrayList < > ( ) ;
Stack< Node> nodes = new Stack < > ( ) ;
if ( root != null) {
nodes. push ( root) ;
while ( ! nodes. empty ( ) ) {
Node node = nodes. pop ( ) ;
list. add ( node. val) ;
for ( Node n : node. children) {
nodes. push ( n) ;
}
}
Collections. reverse ( list) ;
}
return list;
}
589.N叉树的前序遍历
private List< Integer> list1 = new ArrayList < Integer> ( ) ;
public List< Integer> preorder ( Node root) {
pre ( root) ;
return list1;
}
public void pre ( Node root) {
if ( root == null) return ;
list1. add ( root. val) ;
for ( Node n : root. children) {
pre ( n) ;
}
}
public List< Integer> preorder ( Node root) {
List< Integer> lists = new ArrayList < > ( ) ;
Stack< Node> nodes = new Stack < > ( ) ;
if ( root == null) return lists;
nodes. push ( root) ;
while ( ! nodes. isEmpty ( ) ) {
Node node = nodes. pop ( ) ;
if ( node != null) {
lists. add ( node. val) ;
for ( int i = node. children. size ( ) - 1 ; i >= 0 ; i-- ) {
nodes. push ( node. children. get ( i) ) ;
}
}
}
return lists;
}
2019.10.9
104.二叉树的最大深度
public int maxDepth ( TreeNode root) {
if ( root == null) return 0 ;
int l = maxDepth ( root. left) + 1 ;
int r = maxDepth ( root. right) + 1 ;
return l < r ? r : l;
}
public int maxDepth1 ( TreeNode root) {
int dep = 0 ;
int max = 0 ;
Stack< TreeNode> nodes = new Stack < > ( ) ;
Stack< Integer> deps = new Stack < > ( ) ;
while ( ! nodes. empty ( ) || root != null) {
while ( root != null) {
deps. push ( ++ dep) ;
nodes. push ( root) ;
root = root. left;
}
root = nodes. pop ( ) ;
dep = deps. pop ( ) ;
max = Math. max ( max, dep) ;
root = root. right;
}
return max;
}
public static void main ( String[ ] arg) {
TreeNode node = new TreeNode ( 0 ) ;
node. left = new TreeNode ( 2 ) ;
node. right = new TreeNode ( 4 ) ;
node. left. left = new TreeNode ( 1 ) ;
node. right. left = new TreeNode ( 3 ) ;
node. right. right = new TreeNode ( - 1 ) ;
node. left. left. left = new TreeNode ( 5 ) ;
node. left. left. right = new TreeNode ( 1 ) ;
node. right. left. right = new TreeNode ( 6 ) ;
node. right. right. right = new TreeNode ( 8 ) ;
System. out. println ( maxDepth2 ( node) ) ;
}
public static int maxDepth2 ( TreeNode root) {
if ( root == null) return 0 ;
Queue< TreeNode> nodes = new LinkedList < > ( ) ;
nodes. offer ( root) ;
int dep = 0 ;
while ( ! nodes. isEmpty ( ) ) {
dep++ ;
int size = nodes. size ( ) ;
for ( int i = 0 ; i < size; i++ ) {
TreeNode node = nodes. remove ( ) ;
if ( node. left != null) nodes. offer ( node. left) ;
if ( node. right != null) nodes. offer ( node. right) ;
}
}
return dep;
}