java常用函数知识——-leetcode篇

for 循环

for (循环变量类型 循环变量名称 : 要被遍历的对象)  循环体

借助这种语法，遍历一个数组的操作就可以采取这样的写法：

 int[] a = {1， 2， 3， 4};
 for (int i : a) {
     System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */
 }

String

String s;

s.chartAt(i);//第i个位置的内容

s.subString(i,j);//截取字符串

s.length()//字符串长度

数组

StringBuffer[] b=new StringBuffer[numRows];//字符串数组，动态创建用stringbuffer  ,string 创建之后不能改变

char a[]=s.toCharArray();//string to 字符数组

a.length;//数组长度  [ ]的数组

a.append();//数组添加元素-----动态字符串数组 -----stringbuffer有

静态数组---------Array / [ ]

一维数组的声明方式：
type var[]; 或type[] var;

声明数组时不能指定其长度（数组中元素的个数），
Java中使用关键字new创建数组对象，格式为：
数组名 = new 数组元素的类型 [数组元素的个数]

动态初始化：
int[] s = new int[5];

初始化：
1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。

静态初始化：String[] ss =  {"0","1","2"} ;或者 int[] aa = {0,1,2};

动态数组（ArrayList）：

ArrayList List = new ArrayList();
for( int i=0;i <10;i++ )
List.Add(i);

arraylist.size();

Tree

泛型

List list = new ArrayList();

list默认的类型为Object类型

List<String> list = new ArrayList<String>();
采用泛型写法后，通过List<String>，直接限定了list集合中只能含有String类型的元素，编译器已经能够确认它是String类型

LIst与ArrayList

List是一个接口，而ListArray是一个类。 
ListArray继承并实现了List。 
所以List不能被构造，但可以向上面那样为List创建一个引用，而ListArray就可以被构造。 
List list;     //正确   list=null; 
List list=new List();    //   是错误的用法

List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。 
而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。

为什么要用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢？ 
问题就在于List有多个实现类，现在你用的是ArrayList，也许哪一天你需要换成其它的实现类，如 LinkedList或者Vector等等，这时你只要改变这一行就行了： 
List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。 
假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。(ArrayList特有的方法，而List没有，在List list=new ArrayList()中是不能用的)

用迭代的方法实现树需要借用stack

Stack<TreeNode> stack=new Stack<TreeNode>();

stack.isEmpty();//判断栈是否为空

inorder traversal  中序遍历，有很多应用

遍历顺序   左中右

publicList<Integer> inorderTraversal(TreeNode root) {  

List<Integer>list = new ArrayList<>();  

if(root == null)returnlist;  

Stack<TreeNode>stack = newStack<>();  

while(root != null || !stack.empty()){ //栈为空，或者根节点为空，结束

while(root != null){  //节点为空，则向右转

stack.push(root);  

root = root.left;  //将左孩子入栈，至左侧最深得根节点

}  

root =stack.pop(); //弹出左侧节点，向右侧遍历  

list.add(root.val);  

root = root.right;  

}  

returnlist;

}

中序遍历得到的顺序是左中右，刚好满足BST平衡二叉树的要求，左<中，中<右

所以中序遍历可以用来判断是否是平衡二叉树，遍历的结果，前一个值小于后一个值，即为满足BST的要求

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root==null) return true;
        Stack<TreeNode> stack=new Stack<TreeNode>();
        TreeNode pre=null;
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            if(pre!=null&&pre.val>=root.val) return false;
            pre=root;
            root=root.right;          
        }
        return true;       
    }
}