Fighting

二叉树有三种遍历方式：前序、中序和后序。递归遍历1.前序遍历 public static void preTraversal(Node root) { if(root==null) return ; System.out.println(root.value); preTraversal(root.left);

代码：辗转相除即可。import java.util.*;public class Main{ public static boolean judge(long value){ for(long i = 1;i<=value;i++){ if(value%i==0&&value!=i&&i!=1){ return fals

思路：先用1表示的初始化一遍，再用5表示的继续在原来基础上继续初始化…代码：import java.util.*;public class Coins { public int countWays(int n) { // write code here int[] coins={1,5,10,25}; int[] dp = new int[100

思路分析：使用BFS对一个节点四周可以通行的节点进行初始化。因为无论是已经遍历过的节点，还是有障碍的节点，其值都不可能是0，因此我们用0来做判断标准。代码及注释如下：import java.util.*;//使用BFS来解决public class Flood { public int floodFill(int[][] map, int n, int m) { // wr

思路：入栈，入栈时如果空栈那么直接入栈，否则检查栈顶和下一个字符是否匹配，匹配则出栈，否则继续入栈。AC代码：import java.util.*;public class Parenthesis { public boolean chkParenthesis(String A, int n) { // write code here Stack<Charac

分析：提取首字母，然后对首字母后面的字符进行递归操作即可。我的代码：import java.util.*;public class Permutation { public ArrayList<String> getPermutation(String A) { // write code here if(A==null){ retur

思路跟魔术数一差不多，但是递归搜索的范围变化了。可以在直角坐标系中划出直线根据斜率思考。import java.util.*;public class MagicIndex { public boolean findMagicIndex(int[] A, int n) { // write code here if(find(A,0,n-1)!=-1)

思路：类似于二分查找，import java.util.*;public class MagicIndex { public boolean findMagicIndex(int[] A, int n) { // write code here if(findOne(A,0,n-1)!=-1) return true;

思路分析：还是动态规划，不过需要同时判断map数组的状态，然后依照状态进行不同的操作。import java.util.*;public class Robot { public int countWays(int[][] map, int x, int y) { // write code here int[][] res = new int[x][y];

这还是一个动态规划问题，可以使用递归或者使用数组储存中间过程结果的方法来编程。代码一使用递归的方法，这样没有申请额外的存储空间，执行效率低一些：import java.util.*;public class Robot { public int countWays(int x, int y) { // write code here if(x<=0||y<=0

这是一个动态规划的问题。思路分析：以最后剩下台阶的个数分类。另外，使用一个数组来缓存前面的结果。代码：import java.util.*;public class GoUpstairs { public int countWays(int n) { // write code here int[] a = new int[100000]; a

这个题目很值得研究。下面是代码：import java.util.*;public class KthNumber { public int findKth(int k) { // write code here if(k<0) return 0; int val = 0; Queue<Integer> q

题目分析，无论是几只蚂蚁，因为每个蚂蚁占据一个顶点，因此不发生碰撞的情况只有2种，即全部都顺时针爬行或者逆时针爬行。所以只要求出一共爬行的情况就好，而显然有2n 2^n 种情况。第一次提交的代码如下：import java.util.*;public class Ants { public double antsCollision(int n) { // write cod

代码如下：import java.util.*;public class Zipper { public String zipString(String iniString) { // write code here StringBuilder sb = new StringBuilder(); int count=1; sb.

题目：1将链表中的所有元素为奇数的节点移到元素为偶数节点的前面，并保证奇数之间顺序不变，偶数之间顺序不变。示例： 交换前链表的顺序 交换后链表的顺序 4→5→3→1→2 ==> 5→3→1→4→2 1 ==> 1 （链表仅含一个元素) 2→1 ==>1→2 ==> (链表为空)C/C++: 链表节点定义为： struct node

之前做过很多类似的题目，比如说给你一个字符串ABC，然后请给出他的子集（A，B，C，AB，AC，BC，ABC），差不多都是这样的，当然也有给你ABC，请给出跟其长度一样的组合（ABC,ACB,BAC,BCA,CAB,CBA）等等。由于这种题目都是涉及到排列组合数学，因此这里来总结一下。1.首先我们来讨论第一种情况，即给出一个集合，求出其子集。从数学角度，我们可以知道，拥有n个元素的集合，它拥有2n

本文代码可在我的github中BinDecimal.java中找到。题目描述：有一个介于0和1之间的实数，类型为double，返回它的二进制表示。如果该数字无法精确地用32位以内的二进制表示，返回“Error”。 给定一个double num，表示0到1的实数，请返回一个string，代表该数的二进制表示或者“Error”。思路分析：一位一位的判断，判断一位去掉一位。并且另起一个字符串进行表示。代

本文涉及到的代码在我的github中的Balance.java中。 题目描述：实现一个函数，检查二叉树是否平衡，平衡的定义如下，对于树中的任意一个结点，其两颗子树的高度差不超过1。给定指向树根结点的指针TreeNode* root，请返回一个bool，代表这棵树是否平衡。思路分析：求得左子树深度和右子树深度，如果差别大于1，那么返回false，否则对左右子树分别递归判断。代码如下：package

本文涉及到的代码可以在我的github中找到。 题目描述：对于一个元素各不相同且按升序排列的有序序列，请编写一个算法，创建一棵高度最小的二叉查找树。 给定一个有序序列int[] vals,请返回创建的二叉查找树的高度。分析：这里题目只是要求返回二叉树的高度，虽然我们可以用公式直接算出来，不过我们是出于练习的目的，因此我们这里也建个树。首先使用公式计算的方法的一种代码：package newcod

import java.util.*;public class Joseph { public int getResult(int n, int m) { // write code here ArrayList<Integer> list = new ArrayList<>(); for(int i = 0;i<n;i++){

今天开始为校招做准备。本文的实现代码可以在我的github中找到。题目来自牛客网：请实现一个函数，检查一棵二叉树是否为二叉查找树。给定树的根结点指针TreeNode* root，请返回一个bool，代表该树是否为二叉查找树。分析思路：只要节点的值大于左子节点和左子节点的右子节点，小于右子节点和右子节点的左子节点即可。这样用递归很容易实现。代码：import java.util.*;/*public

思路分析：用一个f数组中的f[i]来储存前i个箱子所能到达的最大高度。还是动态规划的思路。代码如下：class Box { int f[501] = {0}; //存放n个箱子的最大上升高度public: int getHeight(vector<int> w, vector<int> l, vector<int> h, int n) { for(int i = w

程序思路结构分析：在第一行第一个位置放置一个皇后，然后在下一行放置一个皇后，判断是否冲突，如果冲突就将刚刚放置的皇后再次后移放置，直到没有冲突，然后递归调用放置。import java.util.*;public class Queens { public int nQueens(int n) { // write code here int[] res =

我的代码：import java.util.*;public class Main{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); while(sc.hasNext()){ int st = sc.nextInt();

注意事项：要用TreeMap而不是HashMap，因为前者有序。我的代码：import java.util.*;public class Main{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); Map<Integer,Integer> map = new

题目如下：分析：反转整个句子，然后以空格为标志，反转每个单词即可代码如下：import java.util.*;public class Main{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); String sen = sc.nextLine();

题目：给一个正整数 n, 找到若干个完全平方数(比如1, 4, 9, … )使得他们的和等于 n。你需要让平方数的个数最少。 给出 n = 12, 返回 3 因为 12 = 4 + 4 + 4。 给出 n = 13, 返回 2 因为 13 = 4 + 9。动态规划的思路，代码及注释如下：package tuyamobile;import java.util.ArrayList;import j

思路都在注释中。import java.util.*;public class Joseph { public int getResult(int n) { // write code here LinkedList<Integer> list = new LinkedList<Integer>(); for(int i = 0;i<n;i+

思路分析：每2个点计算斜率和截距并包装成为一个对象，加入map，统计个数，最后找出最高的。代码如下：import java.util.*;/*public class Point { int x; int y; public Point(int x, int y) { this.x = x; this.y = y; } pub

归并排序算法分2部分：第一部分是“并”，即将2个有序表合成一个新的有序表。第二部分是“分”与“递归”，即采用递归的方式将一个长的表分成2个较短的表，在彻底分解完成之后，然后开始“并”。具体代码如下：package Sort;public class MergeSorttest { //*****以下为“并”的处理。 public static void merge(i

堆排序包括两部分，一是数组的堆化，而是交换堆顶元素与最后一个元素的位置。 数组的堆化，需要与归并排序用相同的思想考虑。即都是在原来堆化好的基础上继续堆化。以下是代码及部分注释：package sort;public class heapSort { // 这部分是在已堆化好的堆上添加pos位置的元素。 public static void adjustMinHeap(int[

希尔排序，又叫缩小增量排序，通过取不同的增量，将数组分成不同的组并进行插入排序，然后不断缩小增量，等到基本有序后，进行一次全面的插入排序。以下是代码：package Sort;public class ShellSort { // 第一种方法，以某一增量为间隔，将组内所有的值进行插入排序。缩小增量，继续重复操作。 public static void shellsort1(int

插入排序：从最前面的一个元素开始，每次依次添加一个元素并排序。下面是代码：package Sort;public class insertSort{ public static void sortwithinsert(int[] arr) { int j = 0; for (int i = 1; i < arr.length; i++)// 控制外层循环 { in

快速排序，简称快排，主要采用了“分治法”，即第一趟排序得到以某一数据为基准的序列，即该数左边的数都比该数小，右边的都比该数大（以升序考虑），然后对左序列重新找基准重复上述过程，右序列也是如此处理。代码如下：package Sort;public class QUICKsort{ public static int adjust(int[] arr, int a, int b)

之前觉得冒泡排序好简单，但是最近重新写的时候，竟然卡壳了，真是无奈。还是老老实实的多写几遍吧以下是源代码：package SecondSort;public class BubbleSort{ public static void b_sort(int[] a) { int len = a.length; int i,j; for(i = 0;i<len;i++)/

题目源自牛客网的一个练习题：请实现一个算法，确定一个字符串的所有字符是否全都不同。这里我们要求不允许使用额外的存储结构。给定一个string iniString，请返回一个bool值,True代表所有字符全都不同，False代表存在相同的字符。保证字符串中的字符为ASCII字符。字符串的长度小于等于3000。测试样例："aeiou"返回：True"BarackObama

题目来自牛客网：    请设计一个算法，寻找二叉树中指定结点的下一个结点（即中序遍历的后继）。给定树的根结点指针TreeNode* root和结点的值int p，请返回值为p的结点的后继结点的值。保证结点的值大于等于零小于等于100000且没有重复值，若不存在后继返回-1。    其实考察了一下树的遍历算法而已。下面给出示例代码：import java.util.*;/*

哈希表 散列表（Hash table，也叫哈希表），是根据关键字（key value）而直接访问数据在内存中位置的数据结构，也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中的一个位置来访问记录，这加快了查找速度，这个映射函数称作散列函数，存放记录的数组成为散列表。 —维基百科哈希冲突解决方式开放定址法这种方法要求哈希表的每个位置有且仅有一

前言关于算法与具体实现结构之间的关系，我感觉倪升武的博客解释的很好。 这里引用一段： 前面讨论的数据结构都有一个框架，这个框架都是由相应的算法设定的。比如说，二叉树是那样一个形状，就是因为那样的形状使他更容易搜索数据和插入新数据，树的边表示了从一个节点到另一个节点的快捷方式。而图通常有一个固定的形状，这是因为由物理或抽象的问题所决定的。———–倪升武的博客哎，最近成了倪升武的追随者了，不过这

2-3-4 Tree简介2-3-4 Tree又叫2-4 Tree，属于一种平衡查找树，其高度满足：<=$\log_2 x N$,关于性能问题，以后会专门出个小专题来讨论。另外，为了行文方便，下面统一将2-3-4 Tree成为2-4 Tree。– 以下出自[维基百科]2-节点，就是说，他包含1个元素和2个子节点3-节点，就是说，他包含2个元素和3个子节点4-节点，就是说，他包含3个元素和4个