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;       

    }

}