前言

计划做一系列算法题的文章，因为自己这块确实比较薄弱，但又很重要！写这篇文章前，我已经刷了一本剑指offer，leetcode top150道，牛客某题库106道 这个样子吧，感觉题量算是入门了吧？个人感觉还是入门级别，因为最开始的题完全是硬刷，全是混个脸熟。到现在才开始对里面的门门道道研究，总结。
所以打算从这篇文章开始，静下心来过一遍。留下自己的足迹也算是给自己打气吧！

leetcode

前言
1 ✔ [21]合并两个有序链表 Easy 2023-02-22 222
2 [102]二叉树的层序遍历 Medium 2022-09-21 202
3 ✔ [33]搜索旋转排序数组 Medium 2023-03-08 197
4 ✔ [20]有效的括号 Easy 2023-01-12 194
5 ✔ [5]最长回文子串 Medium 2023-03-05 193
6 ✔ [121]买卖股票的最佳时机 Easy 2023-01-12 192

1 ✔ [21]合并两个有序链表 Easy 2023-02-22 222

//将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
//
//
//
// 示例 1：
//
//
//输入：l1 = [1,2,4], l2 = [1,3,4]
//输出：[1,1,2,3,4,4]
//
//
// 示例 2：
//
//
//输入：l1 = [], l2 = []
//输出：[]
//
//
// 示例 3：
//
//
//输入：l1 = [], l2 = [0]
//输出：[0]
//
//
//
//
// 提示：
//
//
// 两个链表的节点数目范围是 [0, 50]
// -100 <= Node.val <= 100
// l1 和 l2 均按非递减顺序排列
//
//
// Related Topics 递归链表 👍 2826 👎 0

自测代码

public class P21_MergeTwoSortedLists{
	 public static void main(String[] args) {
		 int[] ints = {1, 2, 4};

		 ListNode listNode = new ListNode(ints);

		 int[] ints2 =  {1,3,4};
		 ListNode listNode2 = new ListNode(ints2);
		 //测试代码
	 	 Solution solution = new P21_MergeTwoSortedLists().new Solution();
		 ListNode listNode1 = solution.mergeTwoLists(listNode, listNode2);

		 System.out.println(listNode1.toString());

	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for singly-linked list.
 * 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 list1, ListNode list2) {

		ListNode listNode = new ListNode(0);

		ListNode res = listNode;


		while (list1 != null || list2 != null ){

			if (list1 == null){
				listNode.next = list2;
				return  res.next;
			}

			if(list2 == null){
				listNode.next = list1;
				return  res.next;
			}

			if (list1.val > list2.val) {
				listNode.next = list2;
				list2 = list2.next;
			}else {
				listNode.next = list1;
				list1 = list1.next;
			}
			listNode = listNode.next;

		}

		return res.next;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

}

提交代码

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

		ListNode listNode = new ListNode(0);

		ListNode res = listNode;


		while (list1 != null || list2 != null ){

			if (list1 == null){
				listNode.next = list2;
				return  res.next;
			}

			if(list2 == null){
				listNode.next = list1;
				return  res.next;
			}

			if (list1.val > list2.val) {
				listNode.next = list2;
				list2 = list2.next;
			}else {
				listNode.next = list1;
				list1 = list1.next;
			}
			listNode = listNode.next;

		}

		return res.next;
    }
}

2 [102]二叉树的层序遍历 Medium 2022-09-21 202

//给你二叉树的根节点 root ，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。
//
//
//
// 示例 1：
//
//
//输入：root = [3,9,20,null,null,15,7]
//输出：[[3],[9,20],[15,7]]
//
//
// 示例 2：
//
//
//输入：root = [1]
//输出：[[1]]
//
//
// 示例 3：
//
//
//输入：root = []
//输出：[]
//
//
//
//
// 提示：
//
//
// 树中节点数目在范围 [0, 2000] 内
// -1000 <= Node.val <= 1000
//
//
// Related Topics 树广度优先搜索二叉树 👍 1604 👎 0

自测代码

public class P102_BinaryTreeLevelOrderTraversal{
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P102_BinaryTreeLevelOrderTraversal().new Solution();
		  String data = "[3,9,20,null,null,15,7]";
		 TreeNode treeNode = mkTree(data);
		 List<List<Integer>> lists = solution.levelOrder(treeNode);
		 for (int i = 0; i < lists.size(); i++) {
			 System.out.println();
			 List<Integer> integers = lists.get(i);
			 for (int i1 = 0; i1 < integers.size(); i1++) {
				 System.out.print("  " + integers.get(i1));
			 }
		 }
	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for a binary tree node.
 * 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<List<Integer>> levelOrder(TreeNode root) {
		Queue<TreeNode> queue = new ArrayDeque<>();
		List<List<Integer>> res = new ArrayList<>();
		if(root != null){
			queue.add(root);
		}
		if (!queue.isEmpty()) {
			do {
				 queue = check(queue, res);

			}while (!queue.isEmpty()) ;

		}

		return res;
	}

	public Queue<TreeNode> check(Queue<TreeNode> queue,List<List<Integer>> data){

		Queue<TreeNode> res = new ArrayDeque<>();
		ArrayList<Integer> integers = new ArrayList<>();
		while (!queue.isEmpty() ){
			
			TreeNode poll = queue.poll();
			if (poll == null) {
				break;
			}

			int val = poll.val;
			integers.add(val);

			TreeNode left = poll.left;
			if (left != null) {
				res.add(left);
			}

			TreeNode right = poll.right;
			if (right != null) {
				res.add(right);
			}
		}
		data.add(integers);
		return res;
	}


}

提交代码

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
		Queue<TreeNode> queue = new ArrayDeque<>();
		List<List<Integer>> res = new ArrayList<>();
		if(root != null){
			queue.add(root);
		}
		if (!queue.isEmpty()) {
			do {
				 queue = check(queue, res);

			}while (!queue.isEmpty()) ;

		}

		return res;
	}

	public Queue<TreeNode> check(Queue<TreeNode> queue,List<List<Integer>> data){

		Queue<TreeNode> res = new ArrayDeque<>();
		ArrayList<Integer> integers = new ArrayList<>();
		while (!queue.isEmpty() ){
			
			TreeNode poll = queue.poll();
			if (poll == null) {
				break;
			}

			int val = poll.val;
			integers.add(val);

			TreeNode left = poll.left;
			if (left != null) {
				res.add(left);
			}

			TreeNode right = poll.right;
			if (right != null) {
				res.add(right);
			}
		}
		data.add(integers);
		return res;
	}


}

主要是使用了队列的特性，然后通过新建一个方法更清晰的区分，每一层的数据

3 ✔ [33]搜索旋转排序数组 Medium 2023-03-08 197

//整数数组 nums 按升序排列，数组中的值互不相同。
//
// 在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[
//k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2
//,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
//
// 给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
//
// 你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
//
//
//
// 示例 1：
//
//
//输入：nums = [4,5,6,7,0,1,2], target = 0
//输出：4
//
//
// 示例 2：
//
//
//输入：nums = [4,5,6,7,0,1,2], target = 3
//输出：-1
//
// 示例 3：
//
//
//输入：nums = [1], target = 0
//输出：-1
//
//
//
//
// 提示：
//
//
// 1 <= nums.length <= 5000
// -10⁴ <= nums[i] <= 10⁴
// nums 中的每个值都独一无二
// 题目数据保证 nums 在预先未知的某个下标上进行了旋转
// -10⁴ <= target <= 10⁴
//
//
// Related Topics 数组二分查找 👍 2422 👎 0

自测代码


public class P33_SearchInRotatedSortedArray{
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P33_SearchInRotatedSortedArray().new Solution();

		  String data = "[4,5,6,7,0,1,2]";
		 int[] ints = StrToIntArray(data);
		 System.out.println(solution.search(ints, 0));
	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int search(int[] nums, int target) {
		int num = nums.length;

		int res = -1;
		
		if (nums.length == 0){
			return  res;
		}

		if ( num == 1 ) {
			if (nums[0] == target) {
				return 0;
			}else {
				return res;
			}
		}

		int r = 0;
		int l = num-1;
		while (r <= l){
			int mid = (l-r)/2 +r;

			if ( nums[mid] == target ) {
				return mid;
			}
			
			if (nums[r] <= nums[mid] ) {

				if (  nums[r] <= target && target < nums[mid] ) {
					l = mid -1 ;
				}else {
					r = mid +1;
				}

			}else{

				if (target <= nums[l] && target > nums[mid] ) {
					r = mid +1 ;
				}else{
					l = mid -1;
				}

			}

		}

		return res;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

}

提交代码

class Solution {
    public int search(int[] nums, int target) {
		int num = nums.length;

		int res = -1;
		
		if (nums.length == 0){
			return  res;
		}

		if ( num == 1 ) {
			if (nums[0] == target) {
				return 0;
			}else {
				return res;
			}
		}

		int r = 0;
		int l = num-1;
		while (r <= l){
			int mid = (l-r)/2 +r;

			if ( nums[mid] == target ) {
				return mid;
			}
			
			if (nums[r] <= nums[mid] ) {

				if (  nums[r] <= target && target < nums[mid] ) {
					l = mid -1 ;
				}else {
					r = mid +1;
				}

			}else{

				if (target <= nums[l] && target > nums[mid] ) {
					r = mid +1 ;
				}else{
					l = mid -1;
				}

			}

		}

		return res;
    }
}

中等难度，笔者之前也刷到过，但是还是想了很久。
第一：看错了题目，以为要求旋转之前 target的下标
第二：善用二分查找方法，遇到查找的时候想想二分方法，二分方法有一个特性就是可以直接舍弃一半数据，用另一半数据计算，所以当有一部分条件不是有序的时候，二分还是可以使用。
第三：边界值判断，如果直接把mind赋值给左或者右，可能会导致死循环，因为只有两个数的时候做除法mind值可能一直和左下标相同。
所以之后在自己声明了左右指针的时候，赋值时最好把中间值+1或者-1。
另外 循环条件也需要改成<=或者>= 因为 +1 / -1之后很可能导致两个数相等，这个时候需要有等于的条件继续循环判断

4 ✔ [20]有效的括号 Easy 2023-01-12 194

//给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
//
// 有效字符串需满足：
//
//
// 左括号必须用相同类型的右括号闭合。
// 左括号必须以正确的顺序闭合。
// 每个右括号都有一个对应的相同类型的左括号。
//
//
//
//
// 示例 1：
//
//
//输入：s = “()”
//输出：true
//
//
// 示例 2：
//
//
//输入：s = “()[]{}”
//输出：true
//
//
// 示例 3：
//
//
//输入：s = “(]”
//输出：false
//
//
//
//
// 提示：
//
//
// 1 <= s.length <= 10⁴
// s 仅由括号 ‘()[]{}’ 组成
//
//
// Related Topics 栈字符串 👍 3786 👎 0

自测代码

public class P20_ValidParentheses{
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P20_ValidParentheses().new Solution();
		 String s = "]";
		 solution.isValid(s);
	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public boolean isValid(String s) {

		HashMap<String, String> hashMap = new HashMap<>();
		hashMap.put("(",")");
		hashMap.put("{","}");
		hashMap.put("[","]");

		String[] split = s.split("");
		int length = split.length;

		Stack<String> data = new Stack<>();

		try{
			for (int i = 0; i < length; i++) {

				String s1 = hashMap.get(split[i]);
				if (s1 == null) {
					String pop = data.pop();
					if (pop == null || !pop.equals(split[i])) {
						return false;
					}
				}else{
					data.add(s1);
				}
			}
		}catch (Exception e){
			return false;
		}

		if (!data.empty()) {
			return  false;
		}
		return true;
    }


}
//leetcode submit region end(Prohibit modification and deletion)

}

提交代码

class Solution {
    public boolean isValid(String s) {

		HashMap<String, String> hashMap = new HashMap<>();
		hashMap.put("(",")");
		hashMap.put("{","}");
		hashMap.put("[","]");

		String[] split = s.split("");
		int length = split.length;

		Stack<String> data = new Stack<>();

		try{
			for (int i = 0; i < length; i++) {

				String s1 = hashMap.get(split[i]);
				if (s1 == null) {
					String pop = data.pop();
					if (pop == null || !pop.equals(split[i])) {
						return false;
					}
				}else{
					data.add(s1);
				}
			}
		}catch (Exception e){
			return false;
		}

		if (!data.empty()) {
			return  false;
		}
		return true;
    }


}

对我来说没有太大难度了，感觉对字符串操作的我貌似都擅长一些。
这道题目就是利用了一下栈的先进先出特性

5 ✔ [5]最长回文子串 Medium 2023-03-05 193

//给你一个字符串 s，找到 s 中最长的回文子串。
//
// 如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。
//
//
//
// 示例 1：
//
//
//输入：s = “babad”
//输出：“bab”
//解释：“aba” 同样是符合题意的答案。
//
//
// 示例 2：
//
//
//输入：s = “cbbd”
//输出：“bb”
//
//
//
//
// 提示：
//
//
// 1 <= s.length <= 1000
// s 仅由数字和英文字母组成
//
//
// Related Topics 字符串动态规划 👍 6257 👎 0

动态规划 这个问题我其实已经写了好几遍了，但是这次再做还是做不出来，或者想到的方法非常复杂。感觉还是没有完全掌握动态规划。
因此，我特地去学习了动态规划相关的知识。
首先 动态规划是解决有重复计算，可以拆分成子问题的一类问题的解决方案。
主要表现 求最短路径，最大回文子序列，多少种走法。
分析原问题 =》找出子问题 =》找出子问题和原问题的关系 =》解决子问题并记录答案=》根据子问题解决原问题。
正确子问题：一般情况下都比较简单，特点一般是个数少，逻辑和原问题有关联
记录子问题答案：通过记录子问题答案，帮助解决原问题，减少重复计算，一般通过数组，二维数组来做。

这道题目求最长回文子序列，
首先回文子序列如果满足，那么去调开头和结尾的字母，依然满足是回文子序列。
如果一直去除，那么就会变成单个字母或者两个相同的字母，
利用这个特性，就可以找到子问题。

因为子问题和原问题的连接点是两边添加参数，所以一定要注意动态规划的循环顺序

然后就是边界值的判断，
只有一个的时候肯定是回文串，两个的时候只需要判断两个是否相等。

自测代码

public class P5_LongestPalindromicSubstring {
    public static void main(String[] args) {
        //测试代码
        Solution solution = new P5_LongestPalindromicSubstring().new Solution();
        String s = "bb";
        System.out.println(solution.longestPalindrome(s));
    }

    //力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        public String longestPalindrome(String s) {
            char[] chars = s.toCharArray();
            int length = chars.length;

            /*简单的动态规划都是记录一个值，这个最长回文子序列可以通过记录左右两个值*/
            Boolean[][] data  = new Boolean[length][length];
            data[0][0] = true;
            int[] res = new int[2];
            res[0] = 0;
            res[1] = 0;
            for (int i = 1; i < length; i++) {
                for (int j = 0; j < i; j++) {
                    /*长度小于三的情况*/
                    if (i - j < 3) {
                        if (chars[i] == chars[j]) {
                            data[j][i] = true;
                        }else {
                            data[j][i] = false;
                        }
                    } else if (chars[i] == chars[j] &&  data[j+1][i-1]   ) {
                        data[j][i] = true;
                    }else{
                        data[j][i] = false;
                    }

                    if (data[j][i]) {
                        if (res[1] - res[0] <= i -j) {
                            res[0] = j;
                            res[1] = i;
                        }
                    }
                }
            }


//            0 1 2 3 4
            return s.substring(res[0],res[1]+1);
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}

提交代码

    class Solution {
        public String longestPalindrome(String s) {
            char[] chars = s.toCharArray();
            int length = chars.length;

            /*简单的动态规划都是记录一个值，这个最长回文子序列可以通过记录左右两个值*/
            Boolean[][] data  = new Boolean[length][length];
            data[0][0] = true;
            int[] res = new int[2];
            res[0] = 0;
            res[1] = 0;
            for (int i = 1; i < length; i++) {
                for (int j = 0; j < i; j++) {
                    /*长度小于三的情况*/
                    if (i - j < 3) {
                        if (chars[i] == chars[j]) {
                            data[j][i] = true;
                        }else {
                            data[j][i] = false;
                        }
                    } else if (chars[i] == chars[j] &&  data[j+1][i-1]   ) {
                        data[j][i] = true;
                    }else{
                        data[j][i] = false;
                    }

                    if (data[j][i]) {
                        if (res[1] - res[0] <= i -j) {
                            res[0] = j;
                            res[1] = i;
                        }
                    }
                }
            }


//            0 1 2 3 4
            return s.substring(res[0],res[1]+1);
        }
    }

6 ✔ [121]买卖股票的最佳时机 Easy 2023-01-12 192

//给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
//
// 你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。
//
// 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
//
//
//
// 示例 1：
//
//
//输入：[7,1,5,3,6,4]
//输出：5
//解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
// 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
//
//
// 示例 2：
//
//
//输入：prices = [7,6,4,3,1]
//输出：0
//解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
//
//
//
//
// 提示：
//
//
// 1 <= prices.length <= 10⁵
// 0 <= prices[i] <= 10⁴
//
//
// Related Topics 数组动态规划 👍 2672 👎 0

配合上一道也是动态规划问题，正好巩固一下
这道题目相对来说简单，
还是通过找关系，
求最大收益，我就先求每天的最大收益，每天的最大收益和买入时的价格有关，就记录能够买入的最小价格，
循环的顺序从前往后，子问题就和主问题联系起来了

自测代码

public class P121_BestTimeToBuyAndSellStock{
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P121_BestTimeToBuyAndSellStock().new Solution();
		String data = "[7,1,5,3,6,4]";
		 System.out.println(solution.maxProfit(ArrayUtil.StrToIntArray(data)));

	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int maxProfit(int[] prices) {
		int len = prices.length;
		int min = Integer.MAX_VALUE;
		int res = 0;
		for (int i = 0; i < len; i++) {
			min = prices[i] <min ? prices[i] : min;
			res = prices[i] - min > res ? prices[i] - min : res;
		}

		return res;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

}

提交代码

class Solution {
    public int maxProfit(int[] prices) {
		int len = prices.length;
		int min = Integer.MAX_VALUE;
		int res = 0;
		for (int i = 0; i < len; i++) {
			min = prices[i] <min ? prices[i] : min;
			res = prices[i] - min > res ? prices[i] - min : res;
		}

		return res;
    }
}