算法题分类

链表

查找单链表中倒数第k个节点(先求长度，再length-k)

从尾到头打印单链表（把各个节点push 进stack中，先进后出）

单链表反转（pre=null;cur=head;next=null  当前节点的下一个节点指向前一个节点，再移动）

合并两个有序的单链表（双指针）

链表中环的入口节点（先相遇，然后 快 head  慢不动；最后等速相遇）

判断链表是否有环（hashset或者快慢指针）

删除链表中的节点（）

 

排序

快排

冒泡

 

数组与字符串

两数之和（1次遍历，放入hashmap；第2次遍历，检查在不在map中）

三数之和（1.排序 2.定义三个数 ，移动直到和等于给定值 3.记得去重）

寻找两个有序数组的中位数（待定）

合并两个有序数组（双指针比较，放入num1中，需要一个nums_copy）

和为S的两个数

和为S的连续子序列

最长回文子串(采用动态规划，注意回文子串的特点p(i，j)=p(i+1,j-1)&&s(i)==s(j))

　　记得先把字符串转换成字符数组！s.toCharArray();

　　步骤：先判断1个，两个的情况；在双层循环，判断三个字母以上的情况

字符串转换整数

 构建乘积数组  先计算上三角，再计算下三角

数组中重复的数字 放到hashmap中去

数组中只出现一次的数字  异或运算 任何数字异或自己都等于0留下的就是只出现1次的

步骤：(把原数组分成两个数组，在数组里面分别异或，得到最终结果)

1.将数组中的数字依次异或；

2.找到第一个为1的位index；

3.判断数组中每一位(index)是否是1，是1在数组1中异或，否则在数组2中异或。

数组在排序数组中出现的次数 利用二分查找找到数字对应的Index，然后向前向后查找。

 

 

有效的括号

删除排序数组中的重复项（双指针；注意数组是排好序的，重复的数字都在一起）

for(int j = 1; j < nums.length; j++){
            //找到不相等的，插入重复位置
            if(nums[i] != nums[j]){
                i++;
                nums[i] = nums[j];
            }
            
        }

 

反转字符串（前后双指针，交换即可）

反转链表

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre=null;
        ListNode cur=head;
        while(cur!=null){
            ListNode nextnode=cur.next;
            cur.next=pre;
            pre=cur;
            cur=nextnode;
        }
        return pre;
    }
}

 

数组中的第k个最大元素

方法1：排序o(nlgn)

方法2：堆排序o(nlgk)

创造小顶堆 [0,k) [k,nums.length)  每次与堆定元素比较，大于堆顶则add进去,并把堆顶元素remove

public int findKthLargest(int[] nums, int k) {
        Queue<Integer> q=new PriorityQueue<>();
        for(int i=0;i<k;i++){
            q.add(nums[i]);
        }
        for(int i=k;i<nums.length;i++){
            if(nums[i]>q.peek()){
                q.remove();
                q.add(nums[i]);
            }
        }
        return q.peek();
    }

 数组中出现次数超过一半的数字(1.排序 2 hashmap )

二维数组中的查找（whiel条件：row<=array.length;col>=0 右上角数字与target比较）

旋转数组的最小数字（while条件：low<high;二分法）

调整数组顺序使得奇数位于偶数前面

连续子数组的最大和

把数组排成最小的数数组中的逆序对

 

 

二叉树

注意：二叉树的题目一般都会用到递归，所以要注意递归终止条件！！！

二叉树的最大深度

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        } else {
            int left = maxDepth(root.left);
            int right = maxDepth(root.right);
            return Math.max(left, right) + 1;
        }
    }
}

 

二叉树的最大路径和（困难leetcode）

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

二叉树的最近公共祖先

二叉树的遍历

二叉搜索树中的第k小的元素

输入两棵二叉树A和B，判断树B是不是A的子结构

通过先序遍历构造二叉树（主要就是循环数组找到比根节点大的值，作为下一次递归的分割线）

二叉树展开为链表

class Solution {
    //先右后左  定义一个全局变量
    TreeNode pre=null;
    public void flatten(TreeNode root) {
        if(root==null)return;
        flatten(root.right);
        flatten(root.left);
        root.right=pre;
        root.left=null;
        pre=root;   
    }
}

 重建二叉树

树的子结构

二叉树镜像

从上往下打印二叉树

二叉搜索树的后序遍历序列

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

二叉搜索树与双向链表

二叉树的深度

平衡二叉树

二叉树的下一个结点

对称的二叉树

按之字形顺序打印二叉树

序列化二叉树

二叉搜索树的第K个节点

 

 

 

 

 

回溯

括号生成

子集

全排列

 

动态规划

爬楼梯

最大子序和

动态规划的是首先对数组进行遍历，当前最大连续子序列和为 sum，结果为 ans
如果 sum > 0，则说明 sum 对结果有增益效果，则 sum 保留并加上当前遍历数字
如果 sum <= 0，则说明 sum 对结果无增益效果，需要舍弃，则 sum 直接更新为当前遍历数字
每次比较 sum 和 ans的大小，将最大值置为ans，遍历结束返回结果

不同路径

买卖股票的最佳时机

 全排列

最长公共子序列

int f[m][n];//记忆
f[0][0]=0//初始条件
f[i][j]=max[f[i-1][j-1]+1, max(f[i-1][j],f[i][j-1])]//状态方程

 

设计

LRU缓存机制

最小栈

 

 

用两个栈实现队列）

 

转载于:https://www.cnblogs.com/NeverGiveUp0/p/11177477.html