HeatDeath的博客

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。public class Solution { public TreeLinkNode GetNext(TreeLinkNode node) { if (node == null) { retu...

public class Solution { public void Mirror(TreeNode root) { if(root == null) return; if(root.left == null && root.right == null) return; Tre...

1 计算二叉树深度非递归实现public int nonRecursive(TreeNode root){ if(root == null) return 0; Queue<TreeNode> queue = new ArrayList<>(); queue.add(root); int depth = 0, coun...

输入一个链表，从尾到头打印链表每个节点的值。思路一：使用栈package com.sword_to_offer;import java.util.ArrayList;import java.util.Stack;public class ReversePrintLinkedList { public ArrayList<Integer> printListFromTailToHead(L

用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。 队列中的元素为 int 类型。stack1 用来入队， stack2 用来出队package com.sword_to_offer;import java.util.Stack;public class TwoStackImplQueue { Stack<Integer> stack1 = new Stack<>();

题目要求： 请实现一个函数，将一个字符串中的空格替换成 “%20”。例如，当字符串为 We Are Happy. 则经过替换之后的字符串为 We%20Are%20Happy。思路一：遍历输入的字符串，若当前字符为' ' ，则向 result_str 中 append ‘%20’，否则将当前字符 append 到 result_str 中。时间复杂度 O(n)，空间复杂度 O(n)package

思路：入栈操作：直接对 queue_1 进行 add 操作出栈操作：若 queue_1 的长度 > 1，对 queue_1 进行 remove 操作，将这些数据放入 queue_2 中，直到 queue_1 只剩下一个元素为止 queue_1 剩余的元素即为应该 出栈的元素， remove 操作将 queue_2 中的元素放回到 queue_1 中大致的示意图：package com.d

思路：当进行入队操作的时候检查 stack_2 是否为空若 stack_2 非空，将 stack_2 中的数据放入 stack_1 中将需要入队的数据 push 到 stack_1 中当进行出队操作的时候检查 stack_1 是否为空若 stack_1 非空，将 stack_1 的数据放入 stack_2 中将 stakc_2 的栈顶元素 pop 出栈大致的示意图package co

先序遍历void preOrder(Node node){ Stack<Node> stack = new Stack<>(); while(node != null || !stack.isEmpty()){ while(node != null){ System.out.println(node.val); stac

1 概述符号表是一种用于存储键值对（key-value pair）的数据结构，我们平常经常使用的数组也可以看做是一个特殊的符号表，数组中的“键”即为数组索引，值为相应的数组元素。也就是说，当符号表中所有的键都是较小的整数时，我们可以使用数组来实现符号表，将数组的索引作为键，而索引处的数组元素即为键对应的值，但是这一表示仅限于所有的键都是比较小的整数时，否则可能会使用一个非常大的数组。散列表是对以上策

206. Reverse Linked ListReverse a singly linked list.click to show more hints.Hint:A linked list can be reversed either iteratively or recursively. Could you implement both?package com.leetcode.linked

归并排序要将一个数组排序，可以先（递归地）将它分成两半分别排序，然后将结果归并起来。自顶向下的归并排序归并排序应用了分治的思想，如果它能将两个子数组排序，它就能够通过归并两个子数组来将整个数组排序。命题F：对于长度为 N 的任意数组，自顶向下的归并排序需要 (1/2)*NlgN 到 NlgN 次比较。命题G：对于长度为 N 的人艺术组，自顶向下的归并排序最多需要访问数组 6NlgN 次。因为递归会

规则排序成本模型：在研究排序算法时，我们需要计算比较和交换的数量。对于不交换元素的算法，我们会计算访问数组的次数。排序算法可以分为两类：除了函数调用所需的栈和固定数目的实例变量之外无需额外内存的原地排序算法需要额外内存空间来存储另一份数组副本的其他排序算法选择排序首先，找到数组中最小的那个元素。其次，将它和数组的第一个元素交换位置。（如果第一个元素最小，那么它和自己交换位置）再次，在剩下

349. Intersection of Two ArraysGiven two arrays, write a function to compute their intersection.Example:Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].Note:Each element in the result must be

167. Two Sum II - Input array is sortedGiven an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.The function twoSum shoul

75. Sort ColorsGiven an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.Here, we will use the

283. Move ZeroesGiven an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.For example, given nums = [0, 1, 0, 3, 12], after ca

将图中的所有边存到最小堆中当最小堆非空 取出权重最小的边 如果此边的两个端点是连接的 跳出本次循环 将此边加入 mst 中 在并查集中 union 此边的两端点package com.dataStructure.weight_graph;import com.dataStructure.heap.MinHeap;import com.dataStru

最小生成树切分定理LazyPrimpackage com.dataStructure.weight_graph;import com.dataStructure.heap.MinHeap;import java.util.ArrayList;import java.util.List;public class LazyPrimMST{ private WeightedGraph graph

使用 Edge.java 存放两节点之间的边Edge.javapackage com.dataStructure.weight_graph;// 有权图的边public class Edge<Weight extends Number & Comparable> implements Comparable<Edge> { private int v; // 边的一个端点 v pr

package com.dataStructure.graph;// 使用 广度优先遍历 查找节点之间的最短路径import java.util.*;public class ShortestPath { private Graph graph; private int startNode; private boolean[] visited; private int

package com.dataStructure.graph;import java.util.ArrayList;import java.util.List;import java.util.Stack;// 使用 dfs 获取两节点之间的路径public class Path { private Graph graph; // 输入的图 private boolean

package com.dataStructure.graph;// 求无权图的联通分量public class Components { private Graph graph; // 存放输入的数组 private boolean[] visited; // 存放节点被访问状态 private int componentCount; // 连通分量的数量 p

package com.dataStructure.graph;//// 稠密图 - 使用邻接矩阵表示//public class DenseGraph {//// private int n; // 节点数// private int m; // 边数// private boolean directed; // 是否为有向图// private boo

package com.dataStructure.graph;import java.util.ArrayList;import java.util.List;//// 稀疏图 - 邻接表//public class SparseGraph {//// private int n; // 节点数// private int m; // 边数// private b

package com.dataStructure.union_find;public class UnionFind5 { private int[] parent; private int[] rank; private int count; public UnionFind5(int n) { count = n; parent =

基于 size 的优化package com.dataStructure.union_find;public class UnionFind3 { private int[] parent; // parent[i]表示第一个元素所指向的父节点 private int[] size; // sz[i]表示以i为根的集合中元素个数 private int count;

package com.dataStructure.union_find;public class UnionFind2 { // parent[i] 表示第一个元素所指向的父节点 private int[] parent; private int count; public UnionFind2(int n) { count = n;

package com.dataStructure.union_find;public class UnionFind1 { // 第一版的 Union-Find 本质是一个数组 private int[] id; // 数据个数 private int count; public UnionFind1(int n) { count = n;

前驱// -------------------------------------------------------------------- // 查找 key 的前驱 public Key predecessor(Key key){ // 在二叉搜索树中查找 key 对应的节点 Node node = search(root, key);

代码 // 移除 指定 key 的节点操作 public void remove(Key key){ root = remove(root, key); } // 删除掉以node为根的二分搜索树中键值为key的节点, 递归算法 // 返回删除节点后新的二分搜索树的根 private Node remove(Node node, Key k

// -------------------------------------------------------------------- // 搜索 最小节点操作 // 寻找二叉搜索树的最小 key public Key minimum(){ Node minNode = minimum(root); return minNode.key;

二叉搜索树的深度优先遍历先序遍历// 先序遍历二叉搜索树 public void preOrder() { preOrder(root); } // 对以node为根的二叉搜索树进行前序遍历, 递归算法 private void preOrder(Node node) { if (node != null) { S

基础// 二叉搜索树// 由于Key需要能够进行比较，所以需要extends Comparable<Key>public class BinarySearchTree<Key extends Comparable<Key>, Value> { // 树中的节点为私有的类，外界不需要了解二叉搜索树节点的具体实现 private class Node{ private

非递归int find(int[] arr, int target){ int l=0, r=arr.length-1; while(l<=r){ int mid = (r-l)/2 + l; if(arr[mid] == target) return mid; if(arr[mid] > target) r = mid-1;

package com.dataStructure.heap;import java.util.Arrays;public class IndexMaxHeap { // 最大索引堆中的数据 private Integer[] data; // 最大索引堆中的索引 private int[] indexes; private int count; pr

package com.algorithm.sort;public class HeapSortInPlace { private HeapSortInPlace() { } public static void sort(Integer[] arr) { int n = arr.length; // 注意：我们堆的索引是从0开始的

基本的堆排序HeapSortBasic.javapackage com.algorithm.sort;import com.dataStructure.heap.MaxHeap;public class HeapSortBasic { private HeapSortBasic() { } // 对整个arr数组使用 HeapSortBasic 排序 // HeapSo

基本介绍堆的实现通过构造二叉堆（binary heap），实为二叉树的一种；这种数据结构具有以下性质。任意节点小于（或大于）它的所有后裔，最小元（或最大元）在堆的根上（堆序性）。堆总是一棵完全树。即除了最底层，其他层的节点都被元素填满，且最底层尽可能地从左到右填入。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。n个元素序列{k1, k2… ki…kn},当且仅当满足下列

QuickSortThreeWays.javapackage com.algorithm.sort;public class QuickSortThreeWays { private QuickSortThreeWays() { } public static void sort(Integer[] arr) { int n = arr.length;