我的梦境传说

反转链表的两种方法

import java.util.Arrays;//167. 两数之和 II - 输入有序数组public class TwoSum { /** * 思路是使用二分搜索，因为是升序的数组，如果low+high得到的值大于target， * 则high--，等于target则退出，否则是low++ */ public static int[] twoSum(int[] arr, int target){ int[] result = {-1,.

public class FibArray { //非递归实现 public static int fib(int N) { if(N <= 1){ return N; } return memorize(N); } public static int memorize(int N){ int[] cache = new int[N + 1]; cache[1].

public class SwapNode2 { public static ListNode swapNode(ListNode head){ if(head == null || head.next == null){ return head; } ListNode firstNode = head; ListNode secondNode = head.next; firstNode.n.

/** * 两两交换链表中的节点 * 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 * 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 * 给定 1->2->3->4, 你应该返回 2->1->4->3. */public class SwapNode { /** * 解题思路 * 先按照奇偶性把链表分解成两个链表l1,l2， * 然后再合并，先先合并后面的链表l2，再合并前面的l1，也是按.

import java.util.HashMap;import java.util.LinkedList;/** * 给定一个整数数组nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。 * 示例 : * 输入: [1,2,1,3,2,5] * 输出: [3,5] * 链接：https://leetcode-cn.com/problems/single-number-iii */public class SingleNumber3 { ..

import java.util.HashMap;/** * 137. 只出现一次的数字 II * 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。 * 说明： * 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ * 示例 1: * 输入: [2,2,3,2] * 输出: 3 * 示例 2: * 输入: [0,1,0,1,0,1,99] * 输出: 99 */public class SingleNumb.

/** * 只出现一次的数字 * 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 * 说明： * 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ * https://leetcode-cn.com/problems/single-number/ */public class SingleNumber { public static int singleNumber(int[] nums){ fo.

import java.util.Stack;/** * 使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1.

import java.util.Stack;/** * 逆波兰表达式求值 * 整数除法只保留整数部分。 * 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 * 示例1： * 输入: ["2", "1", "+", "3", "*"] * 输出: 9 * 解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9 * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems..

/** * 对称二叉树 * 给定一个二叉树，检查它是否是镜像对称的。 * 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 */public class IsSymmetric { public static boolean check(TreeNode p, TreeNode q){ //对比根节点是否相同 if(p == null && q == null){ return true; .

import java.util.Stack;public class MiniStack { public MiniStack(){ data = new Stack<>(); minValue = new Stack<>(); } Stack<Integer> data; Stack<Integer> minValue; public void push(int num){.

/** * 判断链表是不是回文链表 */public class IsPalindrome { //先找到链表的中间位置分开，然后把后半部分反转，遍历作比较，遇到不等就返回false public static boolean isPalindrome(ListNode head){ if(head == null){ return true; } ListNode fast = head; L.

/** * 判断一个链表是否有环， * 思路是快慢指针法，通过判断两个节点是否==， * 即内存地址相同则证明链表有环存在 *返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 */public class LinkedListCycle02 { /** * @param head 链表的头 * @return 是否有环 */ public static ListNode hasCycle(ListNode head){ .

/** *快慢指针，前面是慢指针一次走一个节点，快指针一次走两个节点， *直到快指针的后继节点为空。返回慢节点即可。/class Solution { public ListNode middleNode(ListNode head) { ListNode fast = head; ListNode slow = head; while(fast != null && fast.next != null){ .

/** * 判断一个链表是否有环， * 思路是快慢指针法，通过判断两个节点是否==， * 即内存地址相同则证明链表有环存在 */public class LinkedListCycle { /** * 给定一个链表，判断链表中是否有环。 * 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 * 如果 pos 是 -1，则在该链表中没有环。 * 示例 1： * 输入：head = [3,2.

/** * 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 */public class SortList { //排序链表 public static ListNode sortList(ListNode list){ if(list == null || list.next == null){ return list; } //获取中间节点 ListNode mid.

/** * 给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。 * 你应当保留两个分区中每个节点的初始相对位置。 * 示例: * 输入: head = 1->4->3->2->5->2, x = 3 * 输出: 1->2->2->4->3->5 * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems/partition-lis.

/** * 将两个升序链表合并为一个新的升序链表并返回。 * 新链表是通过拼接给定的两个链表的所有节点组成的。 */public class MergeTwoList { /** * 思路是新建一个带头节点的链表，然后根据比较两个节点的值得大小， * 把小的那个存到新建的链表中，之后判断是否两个链表中有一个没有遍历完， * 把它添加到尾部即可，然后返回头节点的下一个节点即可。 * @param list1 链表一 * @param lis.

/** * 反转从位置 m 到 n 的链表。请使用一趟扫描完成反转 */public class ReverseListNode02 { public static ListNode reverseList(ListNode head, int m, int n){ ListNode temp = head; ListNode before = new ListNode(0); ListNode mid = null; Lis.

public class Solution1 { /** * 删除有序链表中重复的节点，只保留出现一次的节点 * @param head 链表 * @return 链表头 */ public static ListNode deleteDuplicates(ListNode head) { //链表的长度小于等于1，直接返回 if(head == null || head.next == null){ ...

/** * 反转单链表 */public class ReverseListNode { /** * 反转单链表,方法一使用的是链表的头插法 * @param head 传入的单链表 * @return 单链表的头 */ public static ListNode reverseList01(ListNode head){ ListNode temp = head; ListNode newList = nu.

public class MyCode { /** *链表比如1->2->,......->100；然后转化成1->100->2->99->3。。要求空间复杂度o1,时间复杂度On * 用奇偶性来把链表分成两个链表，然后合并，其中偶数的要使用头插法，奇数的使用尾插法。 * @param head */ public static Node dealLinkedList(Node head){ .

/** * 删除有序链表中的重复节点 */public class RemoveDuplicateFromSortedList { /** * 删除有序链表中的重复节点,第一种方法，双指针，当遇到不相同的值时用前面的指针的next指向后面指针的内容 * @param head 链表 */ public static void deleteDuplicateNode01(Node head){ //判断链表的长度必须大于1 .

import java.util.LinkedList;import java.util.Stack;/** * 验证一个二叉树是否是二叉搜索树 */public class ValidateBinarySearchTree { /** * 根据中序遍历的结果来判断是否是二叉搜索树 * @param list * @return */ public static boolean isValidate(LinkedList<Inte.

import java.util.ArrayList;import java.util.LinkedList;/** * 按照z字形遍历二叉树 */public class ZLevelOrder { /** * 按照Z字形访问遍历二叉树，就是在原来的层次遍历的基础上增加了一个标志位，来确定是正序还是反序加入 * @param root 二叉树 * @return 二叉树的遍历结果 */ public static LinkedList.

/** * 返回二叉树两个节点的最近公共祖先 */public class LowestCommonAncestor { public static BinaryTree getLowestCommonAncestor(BinaryTree root, BinaryTree node1, BinaryTree node2){ if(root == null){ return root; } if(root == nod.

/** * 二叉树的最大路径和 */public class BinaryTreeMaxPathSum { private static Integer maxSum; /** * 获取二叉树的最大路径和 * @param root 二叉树 * @return 返回二叉树的最大路径和 */ public static Integer getMaxPathSum(BinaryTree root){ if(root ==.

/** * 判断一个二叉树是否为平衡二叉树 */public class BalanceTree { public static boolean isBalanced(BinaryTree root){ //如果是平衡树就直接返回大于等于0的高度值，否则就返回-1 if(getDepth(root) == -1){ return false; } return true; } /*.

/** * 返回二叉树的深度，二叉树的高度 */public class MaxDeepOfBinaryTree { /** * 使用递归获取二叉树的高度 * @param root 二叉树 * @return 二叉树的高度 */ public static int getHeight(BinaryTree root){ //如果节点为空则返回0 if(root == null){ r.

import java.util.ArrayList;import java.util.LinkedList;/** * 二叉树的广度优先搜索，广度优先遍历 */public class BinaryTreeBFS { /** * 二叉树的广度优先搜索直接输出遍历结果，使用队列的先进先出特点实现 * @param root */ public static void binaryTreeBFS01(BinaryTree root){ .

import java.util.ArrayList;import java.util.Stack;public class BianryTreeDFS { /** * 二叉树的深度优先搜索，递归实现,也就是二叉树的先序遍历 * @param tree 二叉树 */ public static void preOrderDFS(BinaryTree tree){ if(tree == null){ return;.

package com.code.binarytree;import java.util.Stack;/** * 二叉树的后序遍历 */public class AfterOrder { /** * 二叉树的递归后序遍历 * @param binaryTree 二叉树 */ public static void afterOrder(BinaryTree binaryTree){ if(binaryTree != null){.

import java.util.Stack;/** * 二叉树的中序遍历 */public class InOrder { /** * 二叉树的递归中序遍历 * @param binaryTree 二叉树 */ public static void inOrder(BinaryTree binaryTree){ if(binaryTree != null){ //先遍历左节点 in.

import java.util.Stack;/** * 二叉树的前序遍历 */public class PreOrder { /** * 二叉树的前序递归遍历 * @param binaryTree 二叉树 */ public static void PreOrder(BinaryTree binaryTree){ //先访问根节点 if(binaryTree != null){ Syste.