weixin_44629054的博客

题目：给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。思路：可能的情况有两种，如下图：贴上代码：public class LowestCommonAncestor { @Test public void test(){ TreeNode head = new TreeNode(1); head.left = new TreeNode(2); head.right = new TreeNode(3); head.l

题目：打印一个字符串的全部子序列，包括空字符串假如该字符串为"abc"则用画图的方式穷举所有可能代码如下：public class PrintAllSubsquences { /** * 方法一 * @param str */ public static void function(String str) { char[] chs = str.toCharArray(); process(chs, 0, new Arra

题目：给定一个单链表的头节点head，节点的值类型是整型，再给定一个整数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于pivot的节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点。思路：新建六个指针分别为小于给定值的头节点，尾节点；等于给定值的头节点，尾节点；大于给定值的头节点，尾节点。然后还需要一个next指针保存当前节点的下一个节点。具体代码：public ListNode listPartition(ListNode head,int target

题目要求：给定两个有序链表的头指针node1和node2，打印两个链表的公共部分。思路：比较简单，用两个指针从头节点开始遍历，比较两个节点的值，有三种情况1.如果node1的指针指向的值大于node2的指针指向的值值，将node2的指针指向后一个节点。2.如果node1的指针指向的值小于node2的指针指向的值值，将node1的指针指向后一个节点。3.如果node1的指针指向的值等于node2的指针指向的值值，打印节点的值，将node2的指针和node1的指针都指向后一个节点。该过程在while循

1.非递归的解法先上代码：public static LinkNode singleReverse(LinkNode node){ if (node == null) return null; LinkNode head = null; LinkNode next = null; while (node != null){ next = node.next; node.

定义：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。public static boolean CBT(Node head){ if (head != null){ //新建一个队列 LinkedList<Node> queue = new LinkedList<>(); //判断是否是叶子节点 boolean leaf = false;

定义：（二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。解法一：用二叉树的递归中序遍历改//中序遍历改 public static int preValue = Integer.MIN_VALUE; public static boolean checkBST(Node head){ if (h

public static String myReverse(String str,int index,int last) {// if (str != null && index >= 0 && last < str.length()){// char[] chars = str.toCharArray();// for (int l=index,r=last-1;l<r;l++,r--){

public String getMaxSameStr(String str1,String str2){ if (str1 != null && str2 != null){ String maxStr = str1.length() >= str2.length() ? str1 : str2; String minStr = str1.length() < str2.length() ? str1 : str2

递归版本：public static void reverseIn(Node head){ if (head == null) return; reverseIn(head.left); reverseIn(head.right); System.out.print(head.value+","); }非递归版本：public static void unReverseIn(Node head){

递归版本：public static void reversePos(Node head){ if (head == null) return; reversePos(head.left); System.out.print(head.value+","); reversePos(head.right); }非递归版本：public static void unReversePos(Node head){

递归版本：public static void reversePre(Node head){ if (head == null) return; System.out.print(head.value+","); reversePre(head.left); reversePre(head.right); }非递归版本：public static void unReversePre(Node head){

此代码生成从小到大的顺序，故先构造一棵大堆树，然后将根节点与层序遍历最后一个节点或最后一个下标交换，遍历这个过程直到最后一个节点//向上调整 //变成大顶堆 public static void heapInsert(int[] arr, int index) { while (arr[index] > arr[(index - 1) / 2]) { swap(arr, index, (index - 1) /2); index = (index - 1)/2 ; } }

快速排序：选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。//快速排序 public static void quickSort(int[] arr){ if (arr == null || arr.length < 2) return; quickSort(arr,0

算法思想分而治之：分阶段可以理解为就是递归拆分子序列的过程，治阶段，我们需要将两个已经有序的子序列合并成一个有序序列public static void mergeSort(int[] arr) { if (arr == null || arr.length < 2) { return; } mergeSort(arr, 0, arr.length - 1); } public static void mergeSort(int[] arr, int l, int r) {

假设前面的数已经排好序插入一个数依次与前面比较 public static void insertionSort(int[] arr) { if (arr == null || arr.length < 2) { return; } for (int i = 1; i < arr.length; i++) { for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) { swap(

回顾一下冒泡排序原理:它重复地走访过要排序的元素列，依次比较两个相邻的元素,如果前面一个数大于后面的数就交换在数组中的位置，否则什么也不做最后会生成由小到大的数组 public static void bubbleSort(int[] arr) { if (arr == null || arr.length < 2) { return; } for (int e = arr.length - 1; e > 0; e--) { for (int i = 0; i <

回顾一下选择排序工作原理：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾public static void selectionSort(int[] arr) { if (arr == null || arr.length < 2) { return; } for (int i = 0; i < arr.length - 1; i++) { int minIndex

master公式（递归算法的时间复杂度分析）公式为 T [n] = aT[n/b] + T (N^d)使用：1.d<logb a时，时间复杂度为O(n^(logb a))2.当d=logb a时，时间复杂度为O((n^d)*logn)3.当d>logb a时，时间复杂度为O(n^d)举个例子a表示递归的次数也就是生成的子问题数，b表示每次递归是原来的1/b之一个规模，除去的迭代部分的时间复杂度结合求一个数组最大值代码分析public static int getMax(int

求一个数组出现奇数次的数1.一个数组只有一个数出现奇数次其它都出现偶数次用异或解决同样用hashmap也可以一个数组有两个数出现奇数次其它都出现偶数次用位运算1.一个数组只有一个数出现奇数次其它都出现偶数次用异或解决public class EvenTimesOddTimes { public static void main(String[] args) { int[] arr = {1,2,2,3,2,3,2,1,3}; printOddTimesNum1(

写下此篇是为了加强对递归的李姐，之前一直对此模模糊糊，废话不多说**题目描述**输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。示例1输入复制{1,2,3,4,5,#,6,#,#,7}返回值复制4public class Solution { public int TreeDepth(TreeNode root) { if(root == null) return