LeetCode中需要用到数据结构的各种方法（Java）_刷leedcode常用jdk方法

String

1、获取指定下标的字符char：charAt ( index)

2、连接两个字符串：str1.concat ( str2 )

3、比较：equals ( str )

4、返回子串：substring ( beginIndex,endIndex )

[ beginIndex , endIndex )，不包括结束索引

5、以字符数组char[ ]形式返回：toCharArray( )

6、删除字符串头尾空白处：trim( )

本质上是返回一个新的字符串，不改变原来的字符串

7、查看是否包含某个字符串，若是字符，必须用双引号引用：contains ( charSequence )

8、分割字符串：split ( regex )、split ( regex , limit)

返回String [ ]； . 、 $、 | 和 * 等转义字符，必须得加 \\；多个分隔符，可以用 | 作为连字符

9、变成字符数组：toCharArray ( )

示例：char[] array = str.toCharArray();

补充：String key = new String(array)表达式成立

x、字符串的长度：str.length ( )

---

StringBuilder（StringBuffer →线程安全）

注意：务必要通过toString ( )转换为String类的对象

1、追加字符：append( strs )

2、反转：reverse ( )

直接改变内部对象，返回对象本身（直接调用即可，不必返回）；'0'的ASCII值为48.

3、删除指定下标的字符：delete ( startIndex,endIndex)

不包括endIndex

4、在某个下标前插入字符串：insert (offset,str)

示例：sb.insert(1, "--");=====》》  a--bcdef

5、指定起始下标替代字符串：replace (startIndex,endIndex,str)

6、返回指定下标的字符：charAt ( )

x、长度：length ( )

---

数组

1、新建数组（int类型示例）：new int[ ]{101,102,103,104}

2、扩充（Math静态方法）：Math.max(a,b)、Math.min(a,b)

                                             参数类型：int、long、float、double

3、扩充（Integer静态属性）：Integer.MAX_VALUE 、                                                                          Integer.MIN_VALUE

4、异或运算，计算二进制中不同位置的个数⬇：x^y

异或满足交换律和结合律，与自己异或为0，与0异或为本身

5、计算二进制中1的个数：Integer.bitCount ( i )

6、数组排序：Arrays.sort ( array )

无返回值！直接改变原数组！参数可为：byte[ ]、int[ ]、double[ ]、char[ ] 等

补充：String key = new String(array)，array为char[ ]类型

7、数组转换为List集合（静态方法）：List<T> asList(T... a)

示例：List list_2 = Arrays.asList(new String[]{"String", "char","int","double"});

x、数组长度：array.length

---

一、LinkedList（ArrayList）

正常当作队列使用：

1、 尾部添加：add ( e )   等价于   addLast ( e )

2、头部移除：remove ( )   等价于   removeFirst( )

      指定下标删除：remove ( index)

3、list转换为数组：T[ ] toArray(T[ ] a)

示例：String[ ] strs = list.toArray(new String[list.size()]);

栈：(先进后出）

1、压入（添加到）栈中：push ( e )

2、弹出栈外，并返回该值：pop ( )

3、获取栈顶的值（不弹出）：peek ( )

4、判断是否为空：isEmpty( )

队列：（先进先出）

1、 尾部添加：offer( e )   等价于   offerLast ( e )

2、头部移除：poll( )   等价于   pollFirst( )

3、返回第一个元素：peek( )   等价于   element ( )、getFirst ( )

4、获取list长度：size ( )

---

二、HashMap

HashMap 中的元素实际上是对象 ，如果是基本数据类型，则填写包装器类（除了 int-Integer、char-Character，其他的包装器类皆为首字母大写。）

1、添加 ：put ( key, value )

若key已存在，则替代并返回旧的 value 值；若不存在则直接插入，返回 null。

2、访问：get ( key )

3、删除：remove ( key )

删除key对应的键值对key-value，返回删除的key对应的value值

4、清空所有：clear ( )

清空所有的键值对，void无返回值

5、迭代key / value：keySet ( ) values ( )

keySet方法返回的是泛型的Set集合，values方法返回的是Collection<T>的集合

6、判断键值对存在与否：containsKey (key)   containsValue(value)

7、计算大小：size ( )

---

三、HashSet 

底层调用HashMap的类，参数亦是对象，基本类型需要输入包装器类。

1、添加元素：add( e )

若已添加，返回false

2、删除指定元素：remove ( e )

3、判断是否包含某值：contains ( e )

4、删除集合内所有元素：clear ( )

5、迭代：

HashSet<String> sites=new HashSet<>();
sites.put("xxxxxx1");
sites.put("xxxxxx2");
sites.put("xxxxxx3");
for (String i : sites) {
    System.out.println(i);
}

x、计算大小：size ( )

---

四、ListNode（链表）

  public class ListNode {
      int val;
      ListNode next;
      ListNode() {}
      ListNode(int val) { this.val = val; }
      ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  }

合并两个有序列表：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1==null){
            return l2;
        }else if(l2==null){
            return l1;
        }else if(l1.val<l2.val){
            l1.next=mergeTwoLists(l1.next,l2);
            return l1;
        }else{
            l2.next=mergeTwoLists(l1,l2.next);
            return l2;
        }
}
}

---

五、TreeNode（二叉树）

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<Integer> inorderTraversal(TreeNode root) {
        LinkedList<Integer> res=new LinkedList<Integer>();
        backtrace(root,res);
        return res;
    }
 
    public void backtrace(TreeNode root,LinkedList<Integer> res){
        if(root==null){
            return;
        }
 
        backtrace(root.left,res);
        res.add(root.val);
        backtrace(root.right,res);
    }
 
}

对称二叉树：

class Solution {
    public boolean isSymmetric(TreeNode root) {
          return check(root.left,root.right);
    }
 
    public boolean check(TreeNode p,TreeNode q){
        if(p==null && q==null){
            return true;
        }
 
        if(p==null || q==null){
            return false;
        }
 
        return p.val==q.val && check(p.left,q.right) && check(p.right,q.left);
    }
}