top100思路

1：反转链表

先判断根节点是否为空，为空直接返回null，然后定义两个结点一个cur=head，一个pre=null，当cur！=null时循环
循环里定义一个temp结点
temp=cur.next
cur.next=pre
pre=cur
cur=temp
返回pre

2：链表内指定区间反转

跟1思路相似，定义一个res，res.next = head，一个pre，一个cur，先循环到反转的位置，然后在开始反转
ListNode temp = cur.next;
cur.next = temp.next;
temp.next = pre.next;
pre.next = temp;
最后返回res.next

3：链表中的节点每k个进行一次反转

给一个tail接受head，先对链表进行一次k次的循环，判断tail是否为空（判断这此循环是不是有k个节点，如果没有就直接返回head）。给pre=null，cur=head，当cur！=tail的情况下循环，循环体就如1题，然后head.next=下一个k个节点（重新调用方法）
最后返回pre

4:合并两个排序链表

先判断两个链表是否为空，如果为空直接返回另一个，再在两个链表都不为空的情况下循环，分别对比两个链表当前值的大小，小的在前面。循环后判断是否一个为空一个不为空，如果有就把不为空的挂在后面然后返回，需要两个指针一个记录当前节点一个当哨兵

5：合并k个排序链表

直接返回两个链表分别merge，两个指针记录左右，左大于右直接返回null，左等于右的时候说明中间一个值，返回这个节点，找出中间值，返回对这两个中间值进行合并两个排序链表

6：判断链表中是否有环

先判断链表是否为空，空直接返回。快慢指针，快指针不为空并且快指针下一个也不为空的时候循环，快指针移动俩，慢指针移动一个，如果相遇就有环，外层返回false

7：

8：

9：

10：

11：

12：

13：

14：

15：

16：

17：二分查找

列表左右端点指针，左小于等于右的情况下循环，如果目标数和中间数相同直接返回，如果小于就把范围放到左半部分，大于放到右半部分。循环

18：二维数组中查找

判断是否为空（全部，一行）找出行列长度，从左下角开始对比，小就往上移，大就往右移 找到返回true

19：寻找峰值

先给两个指针在集合左右，在左指针小于右指针的情况下循环，找出mid值，判断mid值和mid+1值哪边大范围就换到哪边，最后返回右边的值

20 写了一遍还不会

21：旋转数组最小的数字

先给两个指针在集合左右，左边下标小于右边下标情况下循环，找mid值，判断mid值跟right值大小，mid大于right值范围就在右半边，小于就在左半边，等于就right–挨个比，返回left

22：比较版本号

先给n1，n2作为两个版本的长度，然后给两个指针i，j，在i，j其中之一在n1，n2范围里的情况下循环，定义两个数为0，再在两个版本中分别循环（i在n1里并且不为.）数*10+charat（i）-‘0’ 循环完成后比较两数大小

23：二叉树前序遍历（中左右）

先定义一个Arraylist存节点
写一个preorder方法
定义一个res列表存结果
循环把Arraylist中的值移到res中

preorder方法
如果root==null直接返回
先add根节点
然后自调用root。left
然后自调用root。right

24：二叉树的中序遍历（左中右）

思路同上

25：二叉树的后续遍历（右左中）

思路同上上

26：二叉树的层次遍历

先定义一个和方法返回类型一样的res，然后判断root是否为空，空直接返回res，定义一个队列(ArrayDeque)，把root放到队列里，在队列不为空的情况下循环，定义n为q的长度，row为ArrayList，从0-n循环，把队列中的节点的值放到row中（先定义一个treenode类型的cur变量，然后cur.val）同时判断cur的左右结点是否为空，不为空就放到队列里，然后在大循环里把row放到res里

27：按之字形打印二叉树

思路和26一样，唯一不同是在26定义队列用ArrayDeque，这里用LinkedList，另外在外面加了一个变量flag来作为判断是否需要反转的标志，

28：二叉树的最大深度

先判断节点是否为空，为空直接返回0
直接返回 Math.max(左节点，右节点)+1

29：二叉树中和为某一值的路径

两个判断一个return
1、判断根节点是否为空，空直接返回false
2、左右节点都为空并且sum-root.val==0
3‘、返回 hasPathSum(root.left ,sum-root.val)||hasPathSum(root.right,sum-root.val);，

30：二叉搜索树与双向链表（二叉搜索树满足每个节点的左子树上的所有节点均小于当前节点且右子树上的所有节点均大于当前节点。）

方法前先定义pre，head=null，方法中：如果根节点为空直接返回空，然后调用自己传参左子树，判断pre是否为空，如果为空就把当前节点传给pre，head，如果不为空就pre.right = root;root.left = pre;pre = root;,然后调用自己传参右子树，返回head。

31：

32：

33：

34：判断是不是二叉搜索树（二叉搜索树满足每个节点的左子树上的所有节点均小于当前节点且右子树上的所有节点均大于当前节点。）

先判断根节点是否为空，为空返回true，然后调用自己到最左边的节点，if(!isValidBST(root.left)) return false;
找到最左边节点后判断最左边节点的值是否小于最小值，如果小于就把当前节点值付给最小值
然后返回右边的节点

35：判断是不是完全二叉树

先判断根节点是否为空，为空直接返回true（空树也是完全二叉树），
起一个队列，实现链表，定义一个boolen判断队列中是否有空，
队列不为空的情况下循环，
定义一个指针记录当前节点，如果当前节点为空，改之前定义的boolen
循环中判断boolen，如果之前有节点为空直接返回FALSE（因为大循环是队列不为空的情况下）
最后别忘了把当前节点的左右节点都加到队列里

36：判断是不是平衡二叉树

先判断根节点，是空返回true
int 左为调用方法deep(root.left)
int 右调用方法 deep（root.right）
如果左减右>1或者<-1 直接返回false
然后返回当前节点的左右节点为参数的自调用函数之&&

deep函数：先判断root是否为null 是直接返回0
int 左为调用方法deep(root.left)
int 右调用方法 deep（root.right）
返回：左大于右的话返回左+1，否则右+1

37：二叉搜索树的最近公共祖先

ArrayList定义两个变量p，q代表root到两个点的路径
int定义一个res变量记录结果，
循环，i小于p和q的长度自增，，如果两个点相等就把点的值赋给res，不相等就break
返回res

获取root到两个点的路径的方法
ArrayList path node=root
判断node的值是否等于target，先add node，如果不等于就把node加到path中，然后判断是左节点还是右节点（判断左右节点和node大小关系）
最后add node 然后返回path

38：在二叉树中找到两个节点的最近公共祖先

最外定义flag，dfs时判断是否停止
ArrayList定义两个变量p，q代表root到两个点的路径。int定义一个res变量记录结果
dfs找p，flag重置，q路径
循环判断p，q是否相等，相等直接输出

dfs：传参root，p，p的路径
判断flag或者root==null 返回
root值放路径里
判断root值等于？p，等于给个true ， return
dfs左子树，dfs右
判断flag return
o_path.remove(o_path.size()-1);

39：

40：重建二叉树

前序和中序列表
m，n是前序，中序列表长度
如果m或者n等于0返回null
定义根节点就是前序遍历第一个元素
循环，判断中序列表中元素是否为根节点，如果是
根节点。left就是调用方法本身，参数为前序的左半部分，中序的左半部分
根节点。right就是调用方法本身，参数为前序的右半部分，中序的右半部分
break
返回root

41：

42：用两个栈实现队列

当1栈不为空的时候把1栈的值赋给2栈，这样1栈最下面数据就在2栈最上面，然后弹出2栈最上面数据就实现队列

43：包含min函数的栈

先把node结点push到栈1，然后判断node结点是否为空或者最上面结点是否比node结点大，如果是就把node结点push到栈2，如果不是就把栈2最上面结点重复push到栈2

44：有效括号序列

定义一栈泛型character，在字符串长度范围内循环，如果遇见（栈里push）【】{}一样，如果栈空了或者出栈元素和charat（i）不相等，返回false，最后返回栈。isempty

45：

46：最小的k个数

定义一个list作为res，判断k或者input是否为空，为空直接返回
** PriorityQueue q = new PriorityQueue((o1,o2)->o2.compareTo(o1)); **
先把0-k放入q
然后在k-input.length范围比，如果q中peek大于后面的数就替换掉。
返回res

47：寻找第K大

先快排再直接拿数

48：数据流中的中位数

先定义一个数组val
insert方法：判断val空否，空直接add，不为空则：先定义i=0，for循环不写第一块，如果num《=第i个数则break，在大循环里val。add
getmedim方法：定义n为val长度，判断是否单数，单数直接n/2，双数找到n/2和n/2-1

49：

50：两数求和

通过hashmap判断
先循环数组，判断target-数组中的数是否再hashmap中存在，如果不存在就把数组里的数放map中，如果存在直接返回两个脚标组成的【】

51：

52：

53：

54：

55: 没有重复项数字的全排序

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param num int整型一维数组 
     * @return int整型ArrayList<ArrayList<>>
     */


    public void swap(ArrayList<Integer> num, int i, int j){
        int temp = num.get(i);
        num.set(i,num.get(j));
        num.set(j,temp);
    }
    public void recursion(ArrayList<ArrayList<Integer>> res,ArrayList<Integer> num, int index){
        if(index==num.size()-1){
            res.add(num);
        }else{
            for(int i = index;i<num.size();i++){
                swap(num,i,index);
                recursion(res,num,index+1);
                swap(num,i,index);
            }
        }
    }
    public ArrayList<ArrayList<Integer>> permute (int[] num) {
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> nums = new ArrayList<Integer>();
        for(int i = 0;i<num.length;i++){
            nums.add(num[i]);
        }
        recursion(res,nums,0);
        return res;
    }
}

56：

57：

58：

59：

60：

61：

62：

63：

64：

65：

66：

67：

68：

69：

70：

71：

72：

73：

74：

75：

76：

77：

78：

79：

80：

81：

82：

83：字符串变形

思路：先整体把大小写转换，然后翻转整体，再翻转空格中间的
循环字符串，判断是否等于空格并且指针是否小于长度，成立则取出空格间字符串转换成stringbuffer类型，然后reverse再还给temp，最后res。replace

84：

85：

86：

87：

88：

89：

90：

91：

92：

93：

94：

95：

96：

97：

98：

99：

100：

101：