基础算法题

先提前了解一些常用的类以及方法：
类 Scanner：
从控制台输入：
方法一：

Scanner sc = new Scanner(System.in); //构造一个Scanner对象实例
String queue = sc.next(); //接受控制台输入

125000000
输出

 Scanner in = new Scanner(System.in);
 int x0 = in.nextInt();

**next（）**一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next（）方法会自动将其去掉
**nextLine（）**方法的结束符只是Enter键，即nextLine（）方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。

方法二：

//Scanner sc = new Scanner(System.in);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String p = br.readLine();

String[] s1 = p.trim().split(" ");//忽略前导空白和尾部空白，并按空格分割开成多个String数组

String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串

ListNode h = new ListNode(0);//定义一个新的链表来存放结果

XXX nextXXX() 输入XXX（基本数据类型）类型的

使用户能够从 System.in 中读取一个数：
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
String next() 查找并返回来自此扫描器的下一个完整标记。
int nextInt() 将输入信息的下一个标记扫描为一个 int。
同理nextXXX():

创建一个ArrayList数组。元素类型为Integer
List lists = new ArrayList<>();
list.add(1); 添加元素
list.add(2);
list.add(3);
list.add(4);
list.add(5);
类型为TreeNode
ArrayList queue = new ArrayList<>()

ArrayList的基本的增删改查：
增：boolean add(E e) ； boolean addAll(Collection<? extends E> c)
删：E remove(int index) 移除此列表中指定位置上的元素，并返回该删除的元素
改：E set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。并返回修改前的元素
查：
E get(int index)返回此列表中指定位置上的元素
int size() 返回此列表中的元素数。 不用length
Object[] toArray() 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
boolean isEmpty()如果此列表中没有元素，则返回 true
必须掌握的类的常用函数：添加，删除，转换成其他类型

Integer
static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析 ‘2’–》 2

把特定的字符串转化成int变量 如：
String string = “123”
1）int s = Integer.parseInt(string);
2）int s = new Integer(string);

String类
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串,变成String字符串数组

str11 = "a,b,c,d";
String[] strings = str11.split(",");
for (String s1 : strings){
    System.out.print(s1 + " ");//a b c d
}

例如输入为数组 [3, 6, 9, 12] String[] a=str.split(","); ==>{3,6,9,12}

char charAt(int index) 从String字符串中返回指定索引处的 char 值 比如：返回字符串的第一个字符
char[] toCharArray() 将此字符串转换为一个新的字符数组。

String的构造函数支持将byte[],int[]，char[]转换成字符串，也可指定范围

boolean contains(CharSequence s)
当且仅当此字符串包含指定的 char 值序列时，返回 true。 用于判断是否包含某字串（作弊啊）

String concat(String str) 将指定字符串连接到此字符串的结尾。

boolean contentEquals(CharSequence cs) 将此字符串与指定的 CharSequence 比较。 比较两个字符串的内容是否一样
//CharSequence的实现类CharBuffer, Segment, String, StringBuffer, StringBuilder，即参数可以是它们其中一个
//当且仅当此 String 与指定序列表示相同的 char 值序列时，结果才为 true。

static String copyValueOf(char[] data)返回指定数组中表示该字符序列的 String。也课取某一段的 用于将某个char[]数组转换成字符串，或者截取char[]数组某个部分变成字符串

System.out.println(String.format("%s_%s",str9,str10));//abcd_ABCD 以后中格式输出，如类似C语言的打印时的%d

byte[] getBytes() 将字符串转换成byte[]数组

int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。 可以确定字串在指定字符串的位置
int indexOf(String str, int fromIndex) 从指定的索引开始。

boolean isEmpty() 当且仅当 length() 为 0 时返回 true，

System.out.println("".isEmpty());//true
String str11 = "";
System.out.println(str11.isEmpty());//str11为""或者null true

int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(String str, int fromIndex) 从指定的索引开始反向搜索。

String
replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 全部指定替换掉

CharSequence
subSequence(int beginIndex, int endIndex) 获取一个子字符串。
String
substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。 区别在于subSequence的对象类型范围更大

String toUpperCase() 所有字符都转换为大写。

static String valueOf(char c)等 valueOf能将基本数据类型及其包装类，char[],Object（任意对象类型）转换成String字符串

Stack:
new一个栈，其元素为Integer

Stack stack2 = new Stack<>();
new一个栈，其元素为String

Stack stack2 = new Stack<>();
主要函数：
boolean empty()
测试堆栈是否为空。
E peek()
查看堆栈顶部的对象，但不从堆栈中移除它。
E pop()
移除堆栈顶部的对象，并作为此函数的值返回该对象。
E push(E item)
把项压入堆栈顶部。
int search(Object o)
返回对象在堆栈中的位置，以 1 为基数。

新建一个等长的数组

int[] newArray = new int[array.length];

String[] newArray = new String[array.length];

LinkedList：
boolean add(E e)
将指定元素添加到此列表的结尾。
void add(int index, E element)
在此列表中指定的位置插入指定的元素。
void addFirst(E e)
将指定元素插入此列表的开头。
void addLast(E e)
将指定元素添加到此列表的结尾。
void clear()
从此列表中移除所有元素。
E get(int index)
返回此列表中指定位置处的元素。
E getFirst()
返回此列表的第一个元素。
E getLast()
返回此列表的最后一个元素。
boolean offer(E e)
将指定元素添加到此列表的末尾（最后一个元素）。
E peek()
获取但不移除此列表的头（第一个元素）。
E poll()
获取并移除此列表的头（第一个元素）
Object[] toArray()
返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。

array[i]&1相当于取余；注意，要加（），优先级问题！！

（array[i]&1） != 0  false奇数    true偶数

或者（array[i]&1）==1表示奇数
ListNode p, q;新建两个结点
p = q = head;让他们都指向头指针，也就是相当于拷贝了两个链表

递归树时常用的判断

if(root == null)
        return;
    if(root.left == null && root.right == null)
        return;

返回String类型的边界判断

if(numbers==null || numbers.length==0) {
            return "";
        }

返回的是字符串链表，因为要求返回所有可能满足条件的
public ArrayList Permutation(String str)
<>里面装的是一个ArrayList元素的类型，此为一个ArrayListstring数组作为元素
public ArrayList

字符串转换成字符数组：
char[] chars = str.toCharArray() ;

HashMap<K,V>
boolean containsKey(Object key) 判断是否存在该键，则返回 true。
boolean containsValue(Object value) 判断是否存在该值，则返回 true。
V get(Object key) 返回key对应的value值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
boolean isEmpty() 是否为null，则返回 true。
V put(K key, V value) 增加一个键值对
V remove(Object key) 移除key对应的value（如果存在）。
int size() key-value键值对的个数

二叉树
层次遍历

public static void BFSOrder(BinTree t)
    {
        if(t==null) return ;
        Queue<BinTree> queue = new ArrayDeque<BinTree>();    
        //队列小知识：使用offer和poll优于add和remove之处在于它们返回值可以判断成功与否，而不抛出异常
        queue.offer(t);              //进入队列
        while(!queue.isEmpty())
        {
            t=queue.poll ();           //当前节点出队列            System.out.print(t.date);
            if(t.lchild!=null)              //当前节点左孩子去排队，在前面哦                queue.offer(t.lchild);
            if(t.rchild!=null)            //右孩子排第二                queue.offer(t.rchild);    
        }
    }

前序遍历

public void theFirstTraversal(Node root) {  //先序遍历          
        printNode(root);  
        if (root.getLeftNode() != null) {  //使用递归进行遍历左孩子              
            theFirstTraversal(root.getLeftNode());  
        }  
        if (root.getRightNode() != null) {  //递归遍历右孩子              
            theFirstTraversal(root.getRightNode());  
        }  
    }  


    public void theInOrderTraversal(Node root) {  //中序遍历  
        if (root.getLeftNode() != null) {  
            theInOrderTraversal(root.getLeftNode());  
        }  
        printNode(root);  
        if (root.getRightNode() != null) {  
            theInOrderTraversal(root.getRightNode());  
        }  
    }

    public void thePostOrderTraversal(Node root) {  //后序遍历  
        if (root.getLeftNode() != null) {  
            thePostOrderTraversal(root.getLeftNode());  
        }  
        if(root.getRightNode() != null) {  
            thePostOrderTraversal(root.getRightNode());  
        }  
        printNode(root);  
    }

单例模式
手写常用的几个单例模式（懒汉模式和饿汉模式，线程安全等）
构造方法定义为私有方法
提供一个静态方法，
饿汉式（静态常量）:在类装载的时候就完成实例化。避免了线程同步问题

public class Singleton {

    private final static Singleton INSTANCE = new Singleton();final修饰的静态实例

    private Singleton(){}  私有化构造器

    public static Singleton getInstance(){   提供一个静态的方法返回实例
        return INSTANCE;
    }
}