applyIds = new ArrayList<>();
18 | applyIds.add("123");
19 | int max = applyIds.size();
20 | int index = (int) (Math.random()*max);
21 | System.out.println(index);
22 |
23 | }
24 |
25 | private void test01() {
26 | //int[] a = new int[10];
27 | //stdOut.print(stdRandom.random(a));
28 | System.out.println(UUID.randomUUID().toString());
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/SwordOffer/f48_不能被继承的类.java:
--------------------------------------------------------------------------------
1 | package SwordOffer;
2 |
3 | /**
4 | * 题目：设计一个不能被继承的类
5 | * Java中，被final修饰的类，不能被继承
6 | *
7 | * 这里顺便复习一下抽象类和接口的区别吧：
8 | * 抽象类：不能被实例化，他只是把一些类的公共方法、属性抽象出来，
9 | * 当子类继承某个抽象类时，必须重写父类的所有抽象方法
10 | * - 类，只能继承1个
11 | * - abstract不能与private、static、final或native并列修饰同一个方法
12 | *
13 | * 接口：也不能被实例化，他只是抽象出某些类的行为。
14 | * 接口中的所有方法都是抽象的，不能包含实现的方法，也不能包含静态方法
15 | * 实现接口的非抽象类必须实现接口的所有方法，而抽象类不需要
16 | * - 接口，可以实现多个（注意方法名重复）
17 | * - 接口中的成员变量，会被自动转为 public static final的常量，并且必须被显示初始化
18 | *
19 | *
20 | * 原题是用C++设计。
21 | * 书中给了两种方法：
22 | * Ⅰ. 把构造函数和析构函数都设为私有函数。
23 | * 这时，我们可以通过共有的静态函数 来创建和释放类的实例（单例模式）
24 | * Ⅱ. 利用虚拟继承（没看懂 -.-）
25 | *
26 | * Created by nibnait on 2016/10/2.
27 | */
28 | public abstract class f48_不能被继承的类 {
29 | }
30 |
31 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bj160928/IsBalancedBinaryTree.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bj160928;
2 |
3 | import Standard.BinaryTreeNode;
4 |
5 | /**
6 | * 判断一棵二叉树是否为 平衡二叉树
7 | * Created by nibnait on 2016/10/9.
8 | */
9 | public class IsBalancedBinaryTree {
10 |
11 | public static boolean isBalance(BinaryTreeNode head) {
12 | return getHeight(head, 0) != -1;
13 | }
14 |
15 | public static int getHeight(BinaryTreeNode head, int level) {
16 | if (head == null) {
17 | return level;
18 | }
19 | int lh = getHeight(head.left, level + 1);
20 | int rh = getHeight(head.right, level + 1);
21 | if (lh == -1 || rh == -1 || Math.abs(lh - rh) > 1) {
22 | return -1;
23 | }
24 | return Math.max(lh, rh);
25 | }
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/src/xiaozhao/WangYi_163_2.java:
--------------------------------------------------------------------------------
1 | package xiaozhao;
2 |
3 | import java.util.Scanner;
4 |
5 | /**
6 | * 暗黑字符串
7 | *
8 | * Created by nibnait on 2016/9/12.
9 | */
10 | public class WangYi_163_2 {
11 |
12 | public static void main(String[] args) {
13 | Scanner sc = new Scanner(System.in);
14 | int num = sc.nextInt();
15 | if (num == 1) {
16 | System.out.println(3);
17 | return;
18 | }
19 | if (num == 2) {
20 | System.out.println(9);
21 | return;
22 | }
23 | int[] r = new int[100];
24 | int[] n = new int[100];
25 | r[2] = 3;
26 | n[2] = 6;
27 | for (int i = 3; i<=num; i++){
28 | r[i] = r[i-1]+n[i-1];
29 | n[i] = n[i-1]+r[i-1]*2;
30 | }
31 |
32 | System.out.println(r[num]+n[num]);
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/Algorithms_4thEdition/a_Sorting/b_Insertion.java:
--------------------------------------------------------------------------------
1 | package Algorithms_4thEdition.a_Sorting;
2 |
3 | import Standard.std;
4 | import Standard.stdOut;
5 | import Standard.stdRandom;
6 |
7 | /**
8 | * Created by nibnait on 2016/8/7.
9 | */
10 | public class b_Insertion {
11 | public static void main(String[] args) {
12 | int[] a = new int[10];
13 | a = stdRandom.random(a);
14 | stdOut.print(a);
15 |
16 | a = Insertion_Sort(a);
17 | stdOut.print(a);
18 | }
19 |
20 | /**
21 | * 适用于元素基本（接近）有序的数组，
22 | */
23 | public static int[] Insertion_Sort(int[] a) {
24 |
25 | int length = a.length;
26 |
27 | for (int i = 1; i < length; i++) {
28 | for (int j = i; j > 0 && a[j]0? cur:0;
32 | }
33 | return res;
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bb160727/a_SubArrayMaxSum.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bb160727;
2 |
3 | /**
4 | * 子数组最大和（leetcode 53）
5 | * Created by nibnait on 2016/9/10.
6 | */
7 | public class a_SubArrayMaxSum {
8 |
9 | public static void main(String[] args) {
10 | int[] arr = new int[]{3,-2,1,-6,4,3,-2,3};
11 | System.out.println(maxSum(arr));
12 | }
13 |
14 | /**
15 | * 求子数组最大和
16 | * @param arr
17 | * @return
18 | *
19 | * cur和res
20 | */
21 | public static int maxSum(int[] arr) {
22 | if (arr==null || arr.length<0){
23 | return 0;
24 | }
25 |
26 | int cur = arr[0];
27 | int res = cur;
28 | for (int i = 1; i < arr.length; i++) {
29 | cur += arr[i];
30 | res = Math.max(res, cur);
31 | cur = cur>0? cur:0;
32 | }
33 | return res;
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/zzzTest/ReturnTest.java:
--------------------------------------------------------------------------------
1 | package zzzTest;
2 |
3 | /**
4 | * Created by nibnait on 2016/9/20.
5 | */
6 | public class ReturnTest {
7 |
8 | public static void main(String[] args) {
9 | System.out.println(getNumber(0));
10 | System.out.println(getNumber(1));
11 | System.out.println(getNumber(2));
12 | System.out.println(getNumber(4));
13 |
14 | // System.out.println(getValue());
15 | }
16 |
17 | private static int getNumber(int num) {
18 | int result = Integer.MAX_VALUE;
19 | try{
20 | result = 2/num;
21 | } catch (Exception e){
22 | return 0;
23 | }
24 | // return result;
25 | finally {
26 | return -1;
27 | }
28 | }
29 |
30 | public static int getValue() {
31 | try{
32 | return 0;
33 | } finally {
34 | return 1;
35 | }
36 | }
37 | }
--------------------------------------------------------------------------------
/src/SwordOffer/b09_斐波那契数列.java:
--------------------------------------------------------------------------------
1 | package SwordOffer;
2 |
3 | /**
4 | * Created by nibnait on 2016/9/20.
5 | */
6 | public class b09_斐波那契数列 {
7 |
8 | public static void main(String[] args) {
9 | System.out.println(Fib1(10));
10 | System.out.println(Fibonacci(10));
11 | }
12 |
13 | private static long Fibonacci(int n) {
14 |
15 | if (n <= 0){
16 | return 0;
17 | } else if (n == 1){
18 | return 1;
19 | } else {
20 | long fibNMinusOne = 0;
21 | long fibNMinusTwo = 1;
22 | long fibN = 0;
23 | for (int i = 2; i <= n; i++) {
24 | fibN = fibNMinusOne + fibNMinusTwo;
25 | fibNMinusOne = fibNMinusTwo;
26 | fibNMinusTwo = fibN;
27 | }
28 | return fibN;
29 | }
30 | }
31 |
32 | private static long Fib1(int n) {
33 | return n<2? (n<1?0:1) : Fib1(n-1)+Fib1(n-2);
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/SwordOffer/f46_求1到n的和.java:
--------------------------------------------------------------------------------
1 | package SwordOffer;
2 |
3 | /**
4 | * 题目：求1 + 2 + ···+ n，
5 | * 要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A ? B : C）
6 | *
7 | *
8 | * 这是一道C++序员的题目，书上居然给了4种方法：
9 | * Ⅰ. 利用构造函数求解
10 | * Ⅱ. 利用虚函数求解
11 | * Ⅲ. 利用函数指针求解
12 | * Ⅳ. 利用模板类型求解
13 | *
14 | *
15 | * 对于C艹只会cout和cin的我来说，只看懂了第一个：利用构造函数求解：
16 | * 然而Java中，当你new一个n那么大的Temp型数组，JVM并不会为你执行n次Temp的构造函数。 失败！
17 | *
18 | * Created by nibnait on 2016/10/2.
19 | */
20 | public class f46_求1到n的和 {
21 |
22 | private static int cnt = 0;
23 | private static int sum = 0;
24 |
25 | static class Temp{
26 | public Temp() {
27 | cnt++;
28 | sum += cnt;
29 | }
30 | public static int getSum(){
31 | return sum;
32 | }
33 | }
34 |
35 | public static void main(String[] args) {
36 | int n = 4;
37 | Temp[] temps = new Temp[n];
38 | System.out.println(temps[n-1].getSum()); //失败。。
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/zzzTest/JsonParseTest/RunshopAuditWordDto.java:
--------------------------------------------------------------------------------
1 | package zzzTest.JsonParseTest;
2 |
3 | public class RunshopAuditWordDto {
4 | private long id;
5 | private String sensitiveWord;
6 | private short wordType;
7 | private short isValid;
8 |
9 | public long getId() {
10 | return id;
11 | }
12 |
13 | public void setId(long id) {
14 | this.id = id;
15 | }
16 |
17 | public String getSensitiveWord() {
18 | return sensitiveWord;
19 | }
20 |
21 | public void setSensitiveWord(String sensitiveWord) {
22 | this.sensitiveWord = sensitiveWord;
23 | }
24 |
25 | public short getWordType() {
26 | return wordType;
27 | }
28 |
29 | public void setWordType(short wordType) {
30 | this.wordType = wordType;
31 | }
32 |
33 | public short getIsValid() {
34 | return isValid;
35 | }
36 |
37 | public void setIsValid(short isValid) {
38 | this.isValid = isValid;
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/others/Prime.java:
--------------------------------------------------------------------------------
1 | package others;
2 |
3 | /**
4 | * 求1000以内的素数
5 | * Created by nibnait on 2016/9/18.
6 | */
7 | public class Prime {
8 |
9 | public static void main(String[] args) {
10 | int n = 1000;
11 | for (int i = 0; i < 1000; i++) {
12 | if (prime(i)) {
13 | System.out.println(i);
14 | }
15 | }
16 | }
17 |
18 | /**
19 | * n如果是素数，return true
20 | * @param n
21 | * @return
22 | */
23 | private static boolean prime(int n) {
24 |
25 | if (n%2 == 0){ //少检验了1/2个数字
26 | return n==2;
27 | }
28 | if (n%3 ==0){ //少检验了1/3个数字
29 | return n==3;
30 | }
31 | if (n%5 ==0){
32 | return n==5;
33 | }
34 | for (int i = 7; i*i < n; i++) { //避免调用sqrt函数，节省开销
35 | if (n%i == 0){
36 | return false;
37 | }
38 | }
39 | return true;
40 | }
41 |
42 | }
43 |
--------------------------------------------------------------------------------
/src/zzzTest/HangzhouFdaTest/util/SHAUtil.java:
--------------------------------------------------------------------------------
1 | package zzzTest.HangzhouFdaTest.util;
2 |
3 | import java.io.UnsupportedEncodingException;
4 | import java.security.MessageDigest;
5 | import java.security.NoSuchAlgorithmException;
6 |
7 | public class SHAUtil {
8 | public SHAUtil() {
9 | }
10 |
11 | public static String sha1(String data) throws NoSuchAlgorithmException, UnsupportedEncodingException {
12 | MessageDigest md = MessageDigest.getInstance("SHA1");
13 | md.update(data.getBytes("UTF-8"));
14 | StringBuffer buf = new StringBuffer();
15 | byte[] bits = md.digest();
16 |
17 | for(int i = 0; i < bits.length; ++i) {
18 | int a = bits[i];
19 | if(a < 0) {
20 | a += 256;
21 | }
22 |
23 | if(a < 16) {
24 | buf.append("0");
25 | }
26 |
27 | buf.append(Integer.toHexString(a));
28 | }
29 |
30 | return buf.toString();
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bd160810/src/ReverseStackUsingRecursive.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bd160810.src;
2 |
3 | import java.util.Stack;
4 |
5 | public class ReverseStackUsingRecursive {
6 |
7 | public static void reverse(Stack stack) {
8 | if (stack.isEmpty()) {
9 | return;
10 | }
11 | int i = getAndRemoveLast(stack);
12 | reverse(stack);
13 | stack.push(i);
14 | }
15 |
16 | public static int getAndRemoveLast(Stack stack) {
17 | int result = stack.pop();
18 | if (stack.isEmpty()) {
19 | return result;
20 | } else {
21 | int last = getAndRemoveLast(stack);
22 | stack.push(result);
23 | return last;
24 | }
25 | }
26 |
27 | public static void main(String[] args) {
28 | Stack test = new Stack();
29 | test.push(1);
30 | test.push(2);
31 | test.push(3);
32 | test.push(4);
33 | test.push(5);
34 | reverse(test);
35 | while (!test.isEmpty()) {
36 | System.out.println(test.pop());
37 | }
38 |
39 | }
40 |
41 | }
42 |
--------------------------------------------------------------------------------
/src/zzzTest/RegularTest.java:
--------------------------------------------------------------------------------
1 | package zzzTest;
2 |
3 | import java.util.regex.Matcher;
4 | import java.util.regex.Pattern;
5 |
6 | public class RegularTest {
7 |
8 | public static void main(String[] args) {
9 | test02();
10 | }
11 |
12 | private static void test02() {
13 | String bankCard = "12345678901234567";
14 | //位数 16-19位
15 | Pattern p = Pattern.compile("^d{16,19}");
16 | Matcher m = p.matcher(bankCard);
17 | System.out.println(m.matches());
18 | System.out.println(m.find());
19 | System.out.println(m.lookingAt());
20 | }
21 |
22 | private static void test01() {
23 | Pattern p = Pattern.compile("肯德基|满记甜品|呵呵|五芳斋");
24 | // Matcher m = p.matcher("呵呵肯德基哼哼哼");
25 | Matcher m = p.matcher("满记甜品（M+购物中心店）");
26 | //完全匹配
27 | System.out.println(m.matches());
28 | //部分匹配
29 | System.out.println(m.find());
30 | System.out.println(m.lookingAt());
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bc160803/src/SubArrayMaxSum.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bc160803.src;
2 |
3 | public class SubArrayMaxSum {
4 |
5 | public static int maxSum(int[] arr) {
6 | if (arr == null || arr.length == 0) {
7 | return 0;
8 | }
9 | int max = Integer.MIN_VALUE;
10 | int cur = 0;
11 | for (int i = 0; i != arr.length; i++) {
12 | cur += arr[i];
13 | max = Math.max(max, cur);
14 | cur = cur < 0 ? 0 : cur;
15 | }
16 | return max;
17 | }
18 |
19 | public static void printArray(int[] arr) {
20 | for (int i = 0; i != arr.length; i++) {
21 | System.out.print(arr[i] + " ");
22 | }
23 | System.out.println();
24 | }
25 |
26 | public static void main(String[] args) {
27 | int[] arr1 = { -2, -3, -5, 40, -10, -10, 100, 1 };
28 | System.out.println(maxSum(arr1));
29 |
30 | int[] arr2 = { -2, -3, -5, 0, 1, 2, -1 };
31 | System.out.println(maxSum(arr2));
32 |
33 | int[] arr3 = { -2, -3, -5, -1 };
34 | System.out.println(maxSum(arr3));
35 |
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/src/zzzTest/JsonParseTest/flavorConvert/FlavorDto.java:
--------------------------------------------------------------------------------
1 | package zzzTest.JsonParseTest.flavorConvert;
2 |
3 | public class FlavorDto {
4 | private int id;
5 | private int rst_id;
6 | private String main_flavorname;
7 | private String sub_flavorname;
8 |
9 | public int getId() {
10 | return id;
11 | }
12 |
13 | public void setId(int id) {
14 | this.id = id;
15 | }
16 |
17 | public int getRst_id() {
18 | return rst_id;
19 | }
20 |
21 | public void setRst_id(int rst_id) {
22 | this.rst_id = rst_id;
23 | }
24 |
25 | public String getMain_flavorname() {
26 | return main_flavorname;
27 | }
28 |
29 | public void setMain_flavorname(String main_flavorname) {
30 | this.main_flavorname = main_flavorname;
31 | }
32 |
33 | public String getSub_flavorname() {
34 | return sub_flavorname;
35 | }
36 |
37 | public void setSub_flavorname(String sub_flavorname) {
38 | this.sub_flavorname = sub_flavorname;
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/zzzTest/Base64Convert.java:
--------------------------------------------------------------------------------
1 | package zzzTest;
2 |
3 | import java.io.FileInputStream;
4 | import java.io.IOException;
5 | import java.io.InputStream;
6 | import java.util.*;
7 |
8 |
9 | public class Base64Convert {
10 |
11 | public static void main(String[] args) throws IOException {
12 | String fileBase64Code = getBaseCode();
13 | System.out.println(fileBase64Code);
14 | }
15 |
16 | /**
17 | * 将文件转化为字节数组字符串，并对其进行Base64编码处理
18 | * @return
19 | */
20 | private static String getBaseCode() throws IOException {
21 | InputStream in = null;
22 | byte[] data = null;
23 | try {
24 | in = new FileInputStream("/Users/nibnait/Desktop/食安风险－店铺投诉2017.05.10.xlsx");
25 | data = new byte[in.available()];
26 | in.read(data);
27 | } catch (Exception e) {
28 | e.printStackTrace();
29 | } finally {
30 | in.close();
31 | }
32 | // 返回Base64编码过的字节数组字符串
33 | return Base64.getEncoder().encodeToString(data);
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/Algorithms_4thEdition/a_Sorting/a_Bubble.java:
--------------------------------------------------------------------------------
1 | package Algorithms_4thEdition.a_Sorting;
2 |
3 | import Standard.std;
4 |
5 | /**
6 | * Bubble_Sort
7 | * 时间复杂度：O(n^2)
8 | *
9 | *【思路】
10 | * 共遍历n次数组A[]，（i=[0,n-1]）
11 | * 每次比较 A[j]和A[j+1], 每遍历一次选出一个最大值 放在数组A[]的倒数第i个位置上
12 | * 【
13 | * j的范围可以优化 、 [0,n-1-i]
14 | * 】
15 | *
16 | * Created by nibnait on 2016/9/23.
17 | */
18 |
19 | public class a_Bubble {
20 |
21 | public static void main(String[] args) {
22 | int[] A = new int[]{54,35,48,36,27,12,44,44,8,14,26,17,28};
23 | int[] B = new int[13];
24 |
25 | A = Bubble_Sort(A, 13);
26 |
27 | for (int i = 0; i < A.length; i++) {
28 | System.out.print(A[i]+" ");
29 | }
30 |
31 | }
32 |
33 | public static int[] Bubble_Sort(int[] a, int n) {
34 |
35 | int temp;
36 | for(int i=0; ia[j+1]){
39 | std.swap(a, j, j+1);
40 | }
41 | }
42 | }
43 | return a;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/src/xiaozhao/XiaoMi_02.java:
--------------------------------------------------------------------------------
1 | package xiaozhao;
2 |
3 | import java.util.Scanner;
4 |
5 | /**
6 | 句子反转
7 | 时间限制：C/C++语言 1000MS；其他语言 3000MS
8 | 内存限制：C/C++语言 65536KB；其他语言 589824KB
9 | 题目描述：
10 | 给定一个句子（只包含字母和空格）， 将句子中的单词位置反转，单词用空格分割, 单词之间只有一个空格，前后没有空格。
11 | 比如：
12 | （1） “hello xiao mi”-> “mi xiao hello”
13 | 输入
14 | 输入数据有多组，每组占一行，包含一个句子(句子长度小于1000个字符)
15 | 输出
16 | 对于每个测试示例，要求输出句子中单词反转后形成的句子
17 |
18 | 样例输入
19 | hello xiao mi
20 | 样例输出
21 | mi xiao hello
22 | * Created by nibnait on 2016/9/23.
23 | */
24 | public class XiaoMi_02 {
25 |
26 | public static String reverse(String str) {
27 | String[] arr = str.split(" ");
28 | StringBuffer sb = new StringBuffer();
29 | for (int i = arr.length - 1; i >= 0; i--) {
30 | sb.append(arr[i]).append(" ");
31 | }
32 | return sb.substring(0, sb.length() - 1);
33 | }
34 |
35 | public static void main(String[] args) {
36 | Scanner sc = new Scanner(System.in);
37 | while (sc.hasNext()) {
38 | System.out.println(reverse(sc.nextLine()));
39 | }
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/others/Odd_forward.java:
--------------------------------------------------------------------------------
1 | package others;
2 |
3 | import Standard.std;
4 | import Standard.stdOut;
5 |
6 | /**
7 | * 奇数放在偶数的前面。（插入排序的变异）
8 | * 【剑指Offer 14题】
9 | * Created by nibnait on 2016/8/7.
10 | */
11 | public class Odd_forward {
12 |
13 | public static void main(String[] args) {
14 | int[] a = {1, 2, 1, 3, 4, 5};
15 | stdOut.print(a);
16 |
17 | for (int i = 1; i < a.length; i++) {
18 | for (int j = i; j > 0 && IsOdd(a[j]) && !IsOdd(a[j-1]); j--) {
19 | std.swap(a,j,j-1);
20 | }
21 | }
22 |
23 | //时间复杂度：O(n)的方法：
24 | //两个指针
25 | /* for (int i = 0; i < a.length; i++) {
26 | if (!IsOdd(a[i])) {
27 | for (int j = a.length - 1; j > 0 && i < j; j--) {
28 | if (IsOdd(a[j])) {
29 | std.swap(a, i, j);
30 | }
31 | }
32 | }
33 | }*/
34 | stdOut.print(a);
35 | }
36 |
37 | private static boolean IsOdd(int i) {
38 | return i % 2 == 1;
39 | }
40 |
41 |
42 | }
43 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bb160727/b_TwoSubArrayMaxSum.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bb160727;
2 |
3 | /**
4 | * 求两个子数组最大的累加和
5 | *
6 | * Created by nibnait on 2016/9/10.
7 | */
8 | public class b_TwoSubArrayMaxSum {
9 |
10 | public static void main(String[] args) {
11 | int[] arr = new int[]{3,-2,1,-6,4,3,-2,3};
12 | System.out.println(maxSum(arr));
13 | }
14 |
15 | public static int maxSum(int[] arr) {
16 |
17 | int length = arr.length;
18 | int[] Rmax = new int[length];
19 | int cur = arr[length-1];
20 | Rmax[length-1] = cur;
21 | for (int i=length-2; i>=0; i--){
22 | cur = cur>0? cur: 0;
23 | cur += arr[i];
24 | Rmax[i] = Math.max(Rmax[i], cur);
25 | }// Rmax遍历完毕
26 |
27 | cur = arr[0];
28 | int Lmax = arr[0];
29 | int res = Lmax + Rmax[1];
30 | for (int i=1; i0? cur: 0;
32 | cur += arr[i];
33 | Lmax = Math.max(cur, Lmax);
34 | res = Math.max(res, Lmax+Rmax[i+1]);
35 | }
36 | return res;
37 | }
38 |
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bj160928/src/Problem_13_IsBalancedTree.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bj160928.src;
2 |
3 | public class Problem_13_IsBalancedTree {
4 |
5 | public static class Node {
6 | public int value;
7 | public Node left;
8 | public Node right;
9 |
10 | public Node(int data) {
11 | this.value = data;
12 | }
13 | }
14 |
15 | public static boolean isBalance(Node head) {
16 | return getHeight(head, 0) != -1;
17 | }
18 |
19 | public static int getHeight(Node head, int level) {
20 | if (head == null) {
21 | return level;
22 | }
23 | int lh = getHeight(head.left, level + 1);
24 | int rh = getHeight(head.right, level + 1);
25 | if (lh == -1 || rh == -1 || Math.abs(lh - rh) > 1) {
26 | return -1;
27 | }
28 | return Math.max(lh, rh);
29 | }
30 |
31 | public static void main(String[] args) {
32 | Node head = new Node(1);
33 | head.left = new Node(2);
34 | head.right = new Node(3);
35 | head.left.left = new Node(4);
36 | head.left.right = new Node(5);
37 | head.right.left = new Node(6);
38 | head.right.right = new Node(7);
39 |
40 | System.out.println(isBalance(head));
41 |
42 | }
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/src/xiaozhao/LeShi_01.java:
--------------------------------------------------------------------------------
1 | package xiaozhao;
2 |
3 | import java.util.Scanner;
4 |
5 | /**
6 | * Created by nibnait on 2016/9/19.
7 | */
8 | public class LeShi_01 {
9 |
10 | public static void main(String[] args) {
11 | Scanner sc = new Scanner(System.in);
12 | while (sc.hasNext()) {
13 | int n = sc.nextInt();
14 | if (n==0){
15 | System.out.println(0);
16 | return;
17 | }
18 | int step = 0;
19 | int sum = 0;
20 | while (true){
21 | sum+=++step;
22 | if ( n == sum){
23 | System.out.println(step);
24 | break;
25 | }
26 | if (n > sum){ //如果n不是 1+2+3+4+5的情况
27 | int x = n-sum-1; //比上一档多几
28 | int xx = (step+1)*step/2 -1; //基数
29 | if (xx < step){
30 | continue;
31 | }
32 | System.out.println(2*(xx+x)+1);
33 | break;
34 | }
35 | }
36 | }
37 | }
38 |
39 | }
40 |
--------------------------------------------------------------------------------
/src/nowcoder/a_1st_Season/aa_Manacher_bfprt_KMP/README.md:
--------------------------------------------------------------------------------
1 | ## Manacher算法： 最长回文字串
2 |
3 | 每个元素之间插入一个字符'#'，抵消奇回文与偶回文的差别（任意字符都行，不会影响最终的计算结果）
4 | - pArr[i]：i位置上，所能扩到的最大回文半径
5 | - maxRight：记录回文半径扫到最右位置的下一个位置。（即将到达的位置）
6 | - index：当pR更新的时候，此时回文中心的位置
7 |
8 | 详解：[http://tianbin.leanote.com/post/b1cc9d96-Manacher算法](http://tianbin.leanote.com/post/Manacher%E7%AE%97%E6%B3%95)
9 |
10 |
11 | ## KMP算法
12 | 【题目】
13 | 给定字符串str1 和str2，请返回str2 在str1 中第一次出现的位置；如果str1 不包含str2，返
14 | 回-1
15 | 【要求】
16 | 时间复杂度O(N) （N为str1的长度）
17 |
18 | 【推广题目】
19 | 给定两棵二叉树的头节点head1 和head2，判断head2 是不是head1 的子树
20 | 【要求】
21 | 时间复杂度O(N)
22 |
23 | - 前缀：从第一个字符开始向后扩，不包含最后一个字符
24 | - 后缀：从最后一个字符向前扩， 不包含第一个字符
25 | 例： S(c) ： 在不包含"c"这个字符，只考察"c"前面的字符串，前缀和后缀相同的字符的最大长度。
26 | ababc --> S(c)=2;
27 | aaaac --> S(c)=3;
28 |
29 | - nextArr：
30 | nextArr[0] = -1;
31 | nextArr[1] = 0;
32 | nextArr[i]
33 | 将每一个位置的S(i)右移一位，然后S(0)=-1。
34 |
35 |
36 |
37 | 详解：[http://tianbin.leanote.com/post/KMP%E7%AE%97%E6%B3%95](http://tianbin.leanote.com/post/KMP%E7%AE%97%E6%B3%95)
38 |
39 |
--------------------------------------------------------------------------------
/src/zzzTest/LocalDateTimeTest.java:
--------------------------------------------------------------------------------
1 | package zzzTest;
2 |
3 | import java.time.DayOfWeek;
4 | import java.time.Instant;
5 | import java.time.LocalDate;
6 | import java.time.LocalDateTime;
7 | import java.util.TimeZone;
8 |
9 | public class LocalDateTimeTest {
10 | public static void main(String[] args) {
11 | // test1();
12 | LocalDateTime beginDate = LocalDate.now().minusDays(67).atStartOfDay();
13 | LocalDateTime endDate = LocalDate.now().minusDays(60).atStartOfDay();
14 | System.out.println(beginDate+" "+endDate);
15 |
16 | }
17 |
18 | private static void testTimestamp() {
19 | Long timestamp = 1488187910l;
20 | LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochSecond(timestamp), TimeZone.getDefault().toZoneId());
21 | System.out.println(localDateTime);
22 | }
23 |
24 | private static void test1() {
25 | System.out.println(LocalDateTime.now().getDayOfWeek());
26 | System.out.println(LocalDateTime.now().getDayOfMonth());
27 |
28 | DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
29 | System.out.println(1+dayOfWeek.getValue());
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/Algorithms_4thEdition/a_Sorting/a_Selection.java:
--------------------------------------------------------------------------------
1 | package Algorithms_4thEdition.a_Sorting;
2 |
3 | import Standard.std;
4 | import Standard.stdOut;
5 | import Standard.stdRandom;
6 | /**
7 | * Selection_Sort
8 | * 时间复杂度：O(n^2)
9 | *
10 | *【思路】
11 | * 共遍历n次数组A[]，（i=[0,n-1]）
12 | * 每次选出一个最小的数 放在数组A[]的第i位上
13 | *
14 | * Created by nibnait on 2016/8/5.
15 | */
16 | public class a_Selection {
17 | public static void main(String[] args) {
18 | int[] a = new int[10];
19 | a = stdRandom.random(a);
20 | stdOut.print(a);
21 |
22 | a = Selection_Sort(a);
23 | stdOut.print(a);
24 | }
25 |
26 | /**
27 | * 不断的选择剩余元素中的最小者
28 | * 比较 N*(N-1)/2次
29 | * 交换 N-1次
30 | *
31 | * 时间复杂度：O（N^2)
32 | */
33 | public static int[] Selection_Sort(int[] a) {
34 | int N = a.length;
35 | for (int i = 0; i < N - 1; i++) {
36 | int min = i;
37 | for (int j = i + 1; j < N; j++) {
38 | if (a[min] > a[j]) {
39 | min = j;
40 | }
41 | }
42 | std.swap(a, i, min);
43 | }
44 | return a;
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/out/production/algorithms/nowcoder/a_1st_Season/aa_Manacher_bfprt_KMP/README.md:
--------------------------------------------------------------------------------
1 | ## Manacher算法： 最长回文字串
2 |
3 | 每个元素之间插入一个字符'#'，抵消奇回文与偶回文的差别（任意字符都行，不会影响最终的计算结果）
4 | - pArr[i]：i位置上，所能扩到的最大回文半径
5 | - maxRight：记录回文半径扫到最右位置的下一个位置。（即将到达的位置）
6 | - index：当pR更新的时候，此时回文中心的位置
7 |
8 | 详解：[http://tianbin.leanote.com/post/b1cc9d96-Manacher算法](http://tianbin.leanote.com/post/Manacher%E7%AE%97%E6%B3%95)
9 |
10 |
11 | ## KMP算法
12 | 【题目】
13 | 给定字符串str1 和str2，请返回str2 在str1 中第一次出现的位置；如果str1 不包含str2，返
14 | 回-1
15 | 【要求】
16 | 时间复杂度O(N) （N为str1的长度）
17 |
18 | 【推广题目】
19 | 给定两棵二叉树的头节点head1 和head2，判断head2 是不是head1 的子树
20 | 【要求】
21 | 时间复杂度O(N)
22 |
23 | - 前缀：从第一个字符开始向后扩，不包含最后一个字符
24 | - 后缀：从最后一个字符向前扩， 不包含第一个字符
25 | 例： S(c) ： 在不包含"c"这个字符，只考察"c"前面的字符串，前缀和后缀相同的字符的最大长度。
26 | ababc --> S(c)=2;
27 | aaaac --> S(c)=3;
28 |
29 | - nextArr：
30 | nextArr[0] = -1;
31 | nextArr[1] = 0;
32 | nextArr[i]
33 | 将每一个位置的S(i)右移一位，然后S(0)=-1。
34 |
35 |
36 |
37 | 详解：[http://tianbin.leanote.com/post/KMP%E7%AE%97%E6%B3%95](http://tianbin.leanote.com/post/KMP%E7%AE%97%E6%B3%95)
38 |
39 |
--------------------------------------------------------------------------------
/src/SwordOffer/f47_不用加减乘除做加法.java:
--------------------------------------------------------------------------------
1 | package SwordOffer;
2 |
3 | /**
4 | * 题目：写一个函数，求两个整数之和，要求在函数体内不得使用＋、－、×、÷四则运算符号。
5 | *
6 | * 【解】：
7 | * 不用加减乘除，那就只剩下位运算了
8 | * 回到了计算机中是如何做加法的：
9 | * 求 A + B
10 | * while(B != 0){
11 | * 1. sum = A ^ B;
12 | * 2. carry = (A & B) << 1; //只有A和B都是1时，才有进位
13 | * //如果又进位，则sum与carry还要再异或一次。
14 | * 3. A = sum, B = carry
15 | * }
16 | *
17 | * Created by nibnait on 2016/10/2.
18 | */
19 | public class f47_不用加减乘除做加法 {
20 |
21 | public static void main(String[] args) {
22 | System.out.println(add(1, 2) + ", " + (1 + 2));
23 | System.out.println(add(13, 34)+ ", " + (13 + 34));
24 | System.out.println(add(19, 85)+ ", " + (19 + 95));
25 | System.out.println(add(865, 245)+ ", " + (865 + 245));
26 | }
27 |
28 | private static int add(int num1, int num2){
29 | int sum = 0;
30 | int carry = 0;
31 | while (num2 != 0){
32 | sum = num1 ^ num2;
33 | carry = (num1 & num2) << 1;
34 | num1 = sum;
35 | num2 = carry;
36 | }
37 | return num1;
38 | }
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/src/zzzTest/JsonParseTest/certificationConvert/OperatorDto.java:
--------------------------------------------------------------------------------
1 | package zzzTest.JsonParseTest.certificationConvert;
2 |
3 | public class OperatorDto {
4 | private String user_id;
5 | private String name;
6 | private String email;
7 | private String mobile;
8 | private String comment;
9 |
10 | public String getUser_id() {
11 | return user_id;
12 | }
13 |
14 | public void setUser_id(String user_id) {
15 | this.user_id = user_id;
16 | }
17 |
18 | public String getComment() {
19 | return comment;
20 | }
21 |
22 | public void setComment(String comment) {
23 | this.comment = comment;
24 | }
25 |
26 | public String getName() {
27 | return name;
28 | }
29 |
30 | public void setName(String name) {
31 | this.name = name;
32 | }
33 |
34 | public String getEmail() {
35 | return email;
36 | }
37 |
38 | public void setEmail(String email) {
39 | this.email = email;
40 | }
41 |
42 | public String getMobile() {
43 | return mobile;
44 | }
45 |
46 | public void setMobile(String mobile) {
47 | this.mobile = mobile;
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bd160810/src/SlidingWindowMaxArray.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bd160810.src;
2 |
3 | import java.util.LinkedList;
4 |
5 | public class SlidingWindowMaxArray {
6 |
7 | public static int[] getMaxWindow(int[] arr, int w) {
8 | if (arr == null || w < 1 || arr.length < w) {
9 | return null;
10 | }
11 | LinkedList qmax = new LinkedList();
12 | int[] res = new int[arr.length - w + 1];
13 | int index = 0;
14 | for (int i = 0; i < arr.length; i++) {
15 | while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[i]) {
16 | qmax.pollLast();
17 | }
18 | qmax.addLast(i);
19 | if (qmax.peekFirst() == i - w) {
20 | qmax.pollFirst();
21 | }
22 | if (i >= w - 1) {
23 | res[index++] = arr[qmax.peekFirst()];
24 | }
25 | }
26 | return res;
27 | }
28 |
29 | // for test
30 | public static void printArray(int[] arr) {
31 | for (int i = 0; i != arr.length; i++) {
32 | System.out.print(arr[i] + " ");
33 | }
34 | System.out.println();
35 | }
36 |
37 | public static void main(String[] args) {
38 | int[] arr = { 4, 3, 5, 4, 3, 3, 6, 7 };
39 | int w = 3;
40 | printArray(getMaxWindow(arr, w));
41 |
42 | }
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bc160803/src/PrefixCheck.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bc160803.src;
2 |
3 | import java.util.HashMap;
4 |
5 | public class PrefixCheck {
6 |
7 | public static class Tries {
8 | private HashMap children = new HashMap();; //字符不挂在结点上，挂在边上！
9 | private boolean end = false;
10 |
11 | public boolean addAndCheck(char[] chs, int i) {
12 | if (end) {
13 | return true;
14 | }
15 | if (i == chs.length) {
16 | end = true;
17 | return !children.isEmpty();
18 | }
19 | if (!children.containsKey(chs[i])) {
20 | children.put(chs[i], new Tries());
21 |
22 | }
23 | return children.get(chs[i]).addAndCheck(chs, i + 1);
24 | }
25 |
26 | }
27 |
28 | public static boolean hasPrefix(String[] strs) {
29 | Tries tries = new Tries();
30 | for (String str : strs) {
31 | if (str == null || str.equals("")) {
32 | return true;
33 | }
34 | if (tries.addAndCheck(str.toCharArray(), 0)) {
35 | return true;
36 | }
37 | }
38 | return false;
39 | }
40 |
41 | public static void main(String[] args) {
42 | String[] strs = { "abcd", "abc" };
43 | System.out.println(hasPrefix(strs));
44 | }
45 |
46 | }
47 |
--------------------------------------------------------------------------------
/src/others/Matrix_Print1.java:
--------------------------------------------------------------------------------
1 | package others;
2 |
3 | /**
4 | * Created by nibnait on 2016/8/8.
5 | */
6 | public class Matrix_Print1 {
7 |
8 | public static void main(String[] args) {
9 | int[][] arr = {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25}};
10 | int[] x = arrayScan(arr, 5);
11 | for (int i = 0; i < 25; i++) {
12 | System.out.print(x[i]+" ");
13 | }
14 | }
15 |
16 | private static int[] arrayScan(int[][] arr, int n) {
17 |
18 | int[] a = new int[n*n];
19 | int cnt = n*(n+1)/2;
20 | int cntt = cnt;
21 | int x = 0;
22 | int i = 0;
23 | for (int k = arr.length-1; k >=0; k--) {
24 | i = k;
25 | for (int j = 0; jx && i 即a[0]< a[h]< a[2*h]<...，a[1]< a[h+1]< a[2*h+1]<...
22 | //h：1, 4, 13, 41, 121, 364, 1093... 3倍的倍数递增。
23 | public static int[] Shell_Sort(int[] a) {
24 |
25 | int length = a.length;
26 | int h = 1; //步长
27 | while (h < length/3){
28 | h = 3*h +1;
29 | }
30 |
31 | while (h>0){
32 | for (int i = h; i < length; i++) {//将数组整理成【h有序数组】，
33 | for (int j = i; j >= h && a[j] modelList = excelReader.loadSheet();
14 |
15 | StringBuffer sb = new StringBuffer();
16 | for (ProtectBrand model : modelList) {
17 | sb.append("\'" + model.getSensitive_word() + "\',");
18 | }
19 | String updateSQL = "UPDATE runshop_audit_sensitive_word\nSET is_valid = 0\nWHERE sensitive_word in (";
20 | // String updateSQL = "UPDATE runshop_audit_sensitive_word SET is_valid = 0 WHERE sensitive_word in (";
21 | System.out.println(updateSQL+sb.toString().substring(0, sb.length()-1) + ");");
22 | }
23 |
24 | }
25 |
26 | /*
27 | UPDATE runshop_audit_sensitive_word
28 | SET is_valid = 0
29 | WHERE sensitive_word in ('吉野家华东','吉野家华南','吉野家华中','山东吉野家','食其家华东','食其家华南','食其家华北','大脸鸡排');
30 |
31 | */
--------------------------------------------------------------------------------
/src/zzzTest/MainTestFuncation.java:
--------------------------------------------------------------------------------
1 | package zzzTest;
2 |
3 |
4 | import java.io.IOException;
5 |
6 | public class MainTestFuncation {
7 |
8 | static class Person {
9 | int age;
10 | String name;
11 |
12 | public int getAge() {
13 | return age;
14 | }
15 |
16 | public void setAge(int age) {
17 | this.age = age;
18 | }
19 |
20 | public String getName() {
21 | return name;
22 | }
23 |
24 | public void setName(String name) {
25 | this.name = name;
26 | }
27 |
28 | @Override
29 | public String toString() {
30 | return "Person{" +
31 | "age=" + age +
32 | ", name=" + name +
33 | '}';
34 | }
35 | }
36 |
37 | public static void main(String[] args) throws IOException {
38 | Person p = new Person();
39 | p.setAge(1);
40 | p.setName("kkk");
41 | System.out.println(p.toString());
42 | setPerson(p);
43 | System.out.println(p.toString());
44 | }
45 |
46 | private static void setPerson(Person p) {
47 | p.setAge(2);
48 | p.setName("sdfa");
49 | }
50 | }
51 |
52 |
--------------------------------------------------------------------------------
/src/SwordOffer/b03_二维数组中的二分查找.java:
--------------------------------------------------------------------------------
1 | package SwordOffer;
2 |
3 | /**
4 | * 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
5 | * 请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
6 | *
7 | * 【思路】
8 | * 从二维数组的右上角往左下角开始比较。
9 | * Created by nibnait on 2016/9/20.
10 | */
11 | public class b03_二维数组中的二分查找 {
12 |
13 | public static void main(String[] args) {
14 | int[][] matrix = new int[][]{
15 | {1, 2, 8, 9},
16 | {2, 4, 9, 12},
17 | {4, 7, 10, 13},
18 | {6, 8, 11, 15}
19 | };
20 | System.out.println(findInPartiallySortedMatrix(matrix, 6));
21 | }
22 |
23 | private static int findInPartiallySortedMatrix(int[][] matrix, int key) {
24 | int rows = matrix.length;
25 | int cols = matrix[0].length;
26 | if (matrix==null || rows<1 || cols<1){
27 | return 0;
28 | }
29 | int row = 0;
30 | int col = cols-1;
31 | while (row=0){
32 | if (matrix[row][col] == key){
33 | return 1;
34 | } else if (matrix[row][col] < key){
35 | row++;
36 | } else {
37 | col--;
38 | }
39 | }
40 | return 0;
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/zzzTest/StaticFunctionTest.java:
--------------------------------------------------------------------------------
1 | package zzzTest;
2 |
3 | import java.util.List;
4 |
5 | public class StaticFunctionTest {
6 | static class test {
7 | int id;
8 | String name;
9 |
10 | public test(int id, String name) {
11 | this.id = id;
12 | this.name = name;
13 | }
14 |
15 | @Override
16 | public String toString() {
17 | return "test{" +
18 | "id=" + id +
19 | ", name='" + name + '\'' +
20 | '}';
21 | }
22 |
23 | public int getId() {
24 | return id;
25 | }
26 |
27 | public void setId(int id) {
28 | this.id = id;
29 | }
30 |
31 | public String getName() {
32 | return name;
33 | }
34 |
35 | public void setName(String name) {
36 | this.name = name;
37 | }
38 | }
39 |
40 | public static void main(String[] args) {
41 | String xx = null;
42 |
43 | test t = new test(1, xx);
44 | System.out.println(t.toString());
45 | setTestId(t);
46 | System.out.println(t.toString());
47 | }
48 |
49 | public static void setTestId(test t) {
50 | t.setId(2);
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/nowcoder/AlgorithmPrototype/SlidingWindowMaxValue.java:
--------------------------------------------------------------------------------
1 | package nowcoder.AlgorithmPrototype;
2 |
3 | import Standard.stdOut;
4 |
5 | import java.util.LinkedList;
6 |
7 | /**
8 | * 双端队列的操作
9 | *
10 | * Created by nibnait on 2016/9/13.
11 | */
12 | public class SlidingWindowMaxValue {
13 |
14 | public static void main(String[] args) {
15 | int[] arr = {4, 3, 5, 4, 3, 3, 6, 7};
16 | int w = 3;
17 | stdOut.print(getWindowMaxValue(arr, w));
18 | }
19 |
20 | private static int[] getWindowMaxValue(int[] arr, int w) {
21 |
22 | if (arr == null || w < 1 || arr.length < w) {
23 | return null;
24 | }
25 |
26 | LinkedList deque = new LinkedList();
27 | int[] res = new int[arr.length - w + 1];
28 | int cnt = 0;
29 | for (int i = 0; i < arr.length; i++) {
30 | while (!deque.isEmpty() && arr[deque.peekFirst()] <= arr[i]) {
31 | deque.pollLast();
32 | }
33 | deque.addLast(i);
34 | if (deque.peekFirst() <= i - w) {
35 | deque.pollFirst();
36 | }
37 | if (i >= w - 1) {
38 | res[cnt++] = arr[deque.peekFirst()];
39 | }
40 | }
41 |
42 | return res;
43 | }
44 |
45 |
46 | }
47 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bc160803/src/CompleteTreeNodeNumber.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bc160803.src;
2 |
3 | public class CompleteTreeNodeNumber {
4 |
5 | public static class Node {
6 | public int value;
7 | public Node left;
8 | public Node right;
9 |
10 | public Node(int data) {
11 | this.value = data;
12 | }
13 | }
14 |
15 | public static int nodeNum(Node head) {
16 | if (head == null) {
17 | return 0;
18 | }
19 | return bs(head, 1, mostLeftLevel(head, 1));
20 | }
21 |
22 | public static int bs(Node node, int l, int h) {
23 | if (l == h) {
24 | return 1;
25 | }
26 | if (mostLeftLevel(node.right, l + 1) == h) {
27 | return (1 << (h - l)) + bs(node.right, l + 1, h);
28 | } else {
29 | return (1 << (h - l - 1)) + bs(node.left, l + 1, h);
30 | }
31 | }
32 |
33 | public static int mostLeftLevel(Node node, int level) {
34 | while (node != null) {
35 | level++;
36 | node = node.left; //一路向左
37 | }
38 | return level - 1; //返回高度
39 | }
40 |
41 | public static void main(String[] args) {
42 | Node head = new Node(1);
43 | head.left = new Node(2);
44 | head.right = new Node(3);
45 | head.left.left = new Node(4);
46 | head.left.right = new Node(5);
47 | head.right.left = new Node(6);
48 | System.out.println(nodeNum(head));
49 |
50 | }
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bj160928/IsSearchBinaryTree.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bj160928;
2 |
3 | import Standard.BinaryTreeNode;
4 |
5 | /**
6 | * 判断一棵二叉树是否为搜索二叉树
7 | *
8 | * Created by nibnait on 2016/10/9.
9 | */
10 | public class IsSearchBinaryTree {
11 |
12 | public static boolean isBST(BinaryTreeNode head) {
13 | if (head == null) {
14 | return true;
15 | }
16 | boolean res = true;
17 | BinaryTreeNode pre = null;
18 | BinaryTreeNode cur1 = head;
19 | BinaryTreeNode cur2 = null;
20 | while (cur1 != null) {
21 | cur2 = cur1.left;
22 | if (cur2 != null) {
23 | while (cur2.right != null && cur2.right != cur1) {
24 | cur2 = cur2.right;
25 | }
26 | if (cur2.right == null) {
27 | cur2.right = cur1;
28 | cur1 = cur1.left;
29 | continue;
30 | } else {
31 | cur2.right = null;
32 | }
33 | }
34 | if (pre != null && pre.value > cur1.value) {
35 | res = false;
36 | }
37 | pre = cur1;
38 | cur1 = cur1.right;
39 | }
40 | return res;
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bd160810/SlidingWindowMaxValue.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bd160810;
2 |
3 | import Standard.stdOut;
4 |
5 | import java.util.LinkedList;
6 |
7 | /**
8 | * 双端队列的操作
9 | *
10 | * Created by nibnait on 2016/9/13.
11 | */
12 | public class SlidingWindowMaxValue {
13 |
14 | public static void main(String[] args) {
15 | int[] arr = {4, 3, 5, 4, 3, 3, 6, 7};
16 | int w = 3;
17 | stdOut.print(getWindowMaxValue(arr, w));
18 | }
19 |
20 | private static int[] getWindowMaxValue(int[] arr, int w) {
21 |
22 | if (arr == null || w < 1 || arr.length < w) {
23 | return null;
24 | }
25 |
26 | LinkedList deque = new LinkedList();
27 | int[] res = new int[arr.length - w + 1];
28 | int cnt = 0;
29 | for (int i = 0; i < arr.length; i++) {
30 | while (!deque.isEmpty() && arr[deque.peekFirst()] <= arr[i]) {
31 | deque.pollLast();
32 | }
33 | deque.addLast(i);
34 | if (deque.peekFirst() <= i - w) {
35 | deque.pollFirst();
36 | }
37 | if (i >= w - 1) {
38 | res[cnt++] = arr[deque.peekFirst()];
39 | }
40 | }
41 |
42 | return res;
43 | }
44 |
45 |
46 | }
47 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bj160928/IsCompleteBinaryTree.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bj160928;
2 |
3 | import Standard.BinaryTreeNode;
4 |
5 | import java.util.LinkedList;
6 | import java.util.Queue;
7 |
8 | /**
9 | * 判断一棵二叉树是否为 完全二叉树
10 | * Created by nibnait on 2016/10/9.
11 | */
12 | public class IsCompleteBinaryTree {
13 |
14 | public static boolean isCBT(BinaryTreeNode head) {
15 | if (head == null) {
16 | return true;
17 | }
18 | Queue queue = new LinkedList(); //按层遍历
19 | boolean leaf = false;
20 | BinaryTreeNode l = null;
21 | BinaryTreeNode r = null;
22 | queue.offer(head);
23 | while (!queue.isEmpty()) {
24 | head = queue.poll();
25 | l = head.left;
26 | r = head.right;
27 | if ( (leaf && (l != null || r != null)) || (l == null && r != null) ) {
28 | //当前是叶节点的阶段 && head居然还有孩子 //不管哪个阶段，此结点只要有右无左
29 | return false;
30 | }
31 | if (l != null) {
32 | queue.offer(l);
33 | }
34 | if (r != null) {
35 | queue.offer(r);
36 | } else { //有左无右 或 无左无右
37 | leaf = true;
38 | }
39 | }
40 | return true;
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/SwordOffer/e31_连续子数组的最大和.java:
--------------------------------------------------------------------------------
1 | package SwordOffer;
2 |
3 | /**
4 | * 题目：输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整数组成一个子数组。求所有子数组的和的最大值。
5 | * 要求时间复杂度为 O(n)。
6 | *
7 | * /src/nowcoder/b_2nd_Season/bb160727/README.md：
8 | * 左神做法：
9 | cur 依次累加各个元素，一旦cur为负数时，则将cur清为零。
10 | 并尝试更新一次result（最大值）
11 | 最终返回result即为子数组的最大累加和
12 |
13 | 解释：
14 | 因为最大和的子数组：其任意数量的前缀一定不为负。
15 | 也就是 cur如果没有累加出到负数，就继续往下走。 即模拟了“前缀不可能为负数”的情况。
16 |
17 | *
18 | *
19 | * Created by nibnait on 2016/10/1.
20 | */
21 | public class e31_连续子数组的最大和 {
22 |
23 | public static void main(String[] args) {
24 | int[] data = {1, -2, 3, 10, -4, 7, 2, -5};
25 | int[] data2 = {-2, -8, -1, -5, -9};
26 | int[] data3 = {2, 8, 1, 5, 9};
27 | System.out.println(findGreatestSumOfSubArray(data));
28 | System.out.println(findGreatestSumOfSubArray(data2));
29 | System.out.println(findGreatestSumOfSubArray(data3));
30 | }
31 |
32 | private static int findGreatestSumOfSubArray(int[] arr) {
33 | if (arr==null || arr.length<=0){
34 | return 0;
35 | }
36 |
37 | int cur = arr[0];
38 | int res = cur;
39 | for (int i = 1; i < arr.length; i++) {
40 | cur += arr[i];
41 | res = Math.max(res, cur);
42 | cur = cur>0? cur:0;
43 | }
44 | return res;
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/zzzTest/JsonParseTest/certificationConvert/CertificationDto.java:
--------------------------------------------------------------------------------
1 | package zzzTest.JsonParseTest.certificationConvert;
2 |
3 | public class CertificationDto {
4 | private String created_at;
5 | private String operator_id;
6 | private String operator_type;
7 | private String restaurant_id;
8 | private String updated_at;
9 |
10 | public String getCreated_at() {
11 | return created_at;
12 | }
13 |
14 | public void setCreated_at(String created_at) {
15 | this.created_at = created_at;
16 | }
17 |
18 | public String getOperator_id() {
19 | return operator_id;
20 | }
21 |
22 | public void setOperator_id(String operator_id) {
23 | this.operator_id = operator_id;
24 | }
25 |
26 | public String getOperator_type() {
27 | return operator_type;
28 | }
29 |
30 | public void setOperator_type(String operator_type) {
31 | this.operator_type = operator_type;
32 | }
33 |
34 | public String getRestaurant_id() {
35 | return restaurant_id;
36 | }
37 |
38 | public void setRestaurant_id(String restaurant_id) {
39 | this.restaurant_id = restaurant_id;
40 | }
41 |
42 | public String getUpdated_at() {
43 | return updated_at;
44 | }
45 |
46 | public void setUpdated_at(String updated_at) {
47 | this.updated_at = updated_at;
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bg160831/src/KMPAlgorithm.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bg160831.src;
2 |
3 | public class KMPAlgorithm {
4 |
5 | public static int getIndexOf(String s, String m) {
6 | if (s == null || m == null || m.length() < 1 || s.length() < m.length()) {
7 | return -1;
8 | }
9 | char[] ss = s.toCharArray();
10 | char[] ms = m.toCharArray();
11 | int si = 0;
12 | int mi = 0;
13 | int[] next = getNextArray(ms);
14 | while (si < ss.length && mi < ms.length) {
15 | if (ss[si] == ms[mi]) {
16 | si++;
17 | mi++;
18 | } else if (next[mi] == -1) {
19 | si++;
20 | } else {
21 | mi = next[mi];
22 | }
23 | }
24 | return mi == ms.length ? si - mi : -1;
25 | }
26 |
27 | public static int[] getNextArray(char[] ms) {
28 | if (ms.length == 1) {
29 | return new int[] { -1 };
30 | }
31 | int[] next = new int[ms.length];
32 | next[0] = -1;
33 | next[1] = 0;
34 | int pos = 2; //当前位置
35 | int cn = 0; //最长匹配前缀字串后面的那个字符位置
36 | while (pos < next.length) {
37 | if (ms[pos - 1] == ms[cn]) {
38 | next[pos++] = ++cn;
39 | } else if (cn > 0) {
40 | cn = next[cn];
41 | } else {
42 | next[pos++] = 0;
43 | }
44 | }
45 | return next;
46 | }
47 |
48 | public static void main(String[] args) {
49 | String str = "abcabcababaccc";
50 | String match = "ababa";
51 | System.out.println(getIndexOf(str, match));
52 |
53 | }
54 |
55 | }
56 |
--------------------------------------------------------------------------------
/src/zzzTest/HangzhouFdaTest/util/aes/AES.java:
--------------------------------------------------------------------------------
1 | package zzzTest.HangzhouFdaTest.util.aes;
2 |
3 | import java.io.IOException;
4 | import java.io.UnsupportedEncodingException;
5 | import java.security.InvalidKeyException;
6 | import java.security.NoSuchAlgorithmException;
7 | import javax.crypto.BadPaddingException;
8 | import javax.crypto.IllegalBlockSizeException;
9 | import javax.crypto.NoSuchPaddingException;
10 |
11 | public class AES {
12 | static String spec = "9238513401340235";
13 |
14 | public AES() {
15 | }
16 |
17 | public String encrypt(String content, String key) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
18 | AESencrp aeSencrp = new AESencrp();
19 | aeSencrp.setALGO("AES");
20 | aeSencrp.setKeyValue(key.getBytes());
21 | return aeSencrp.encrypt(content);
22 | }
23 |
24 | public String decrypt(String src, String bm, String key) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, IOException {
25 | AESencrp aeSencrp = new AESencrp();
26 | aeSencrp.setALGO("AES");
27 | aeSencrp.setKeyValue(key.getBytes());
28 | return aeSencrp.decrypt(src, bm);
29 | }
30 |
31 | public static void main(String[] args) throws Exception {
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bc160803/src/MaxSubMatrixSumLessK.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bc160803.src;
2 |
3 | import Standard.BinarySearch;
4 |
5 | public class MaxSubMatrixSumLessK {
6 |
7 | public static int maxSubMatrixSumLessThanK(int[][] m, int sum) {
8 | if (m == null || m.length == 0 || m[0] == null || m[0].length == 0) {
9 | return 0;
10 | }
11 | int res = 0;
12 | for (int i = 0; i < m.length; i++) {
13 | int[] sumArr = new int[m[0].length];
14 | for (int j = i; j < m.length; j++) {
15 | for (int k = 0; k < m[0].length; k++) {
16 | sumArr[k] += m[j][k];
17 | }
18 | res = Math.max(res, (j - i + 1) * maxLength(sumArr, sum));
19 | }
20 | }
21 | return res;
22 | }
23 |
24 | public static int maxLength(int[] arr, int k) {
25 | int[] h = new int[arr.length + 1];
26 | int sum = 0;
27 | h[0] = sum;
28 | for (int i = 0; i != arr.length; i++) {
29 | sum += arr[i];
30 | h[i + 1] = Math.max(sum, h[i]);
31 | }
32 | sum = 0;
33 | int res = 0;
34 | int pre = 0;
35 | int len = 0;
36 | for (int i = 0; i != arr.length; i++) {
37 | sum += arr[i];
38 | pre = BinarySearch.search(h, sum - k);
39 | len = pre == -1 ? 0 : i - pre + 1;
40 | res = Math.max(res, len);
41 | }
42 | return res;
43 | }
44 |
45 | public static void main(String[] args) {
46 | int[][] matrix = { { 1, 0, 1 }, { 0, -2, 3 } };
47 | System.out.println(maxSubMatrixSumLessThanK(matrix, 2));
48 | }
49 |
50 | }
51 |
--------------------------------------------------------------------------------
/src/zzzTest/JsonParseTest/certificationConvert/RunshopDto.java:
--------------------------------------------------------------------------------
1 | package zzzTest.JsonParseTest.certificationConvert;
2 |
3 | public class RunshopDto {
4 | private String dom_id;
5 | private String source;
6 | private String user_id;
7 | private String user_name;
8 | private String user_email;
9 | private String created_at;
10 |
11 | public String getCreated_at() {
12 | return created_at;
13 | }
14 |
15 | public void setCreated_at(String created_at) {
16 | this.created_at = created_at;
17 | }
18 |
19 | public String getDom_id() {
20 | return dom_id;
21 | }
22 |
23 | public void setDom_id(String dom_id) {
24 | this.dom_id = dom_id;
25 | }
26 |
27 | public String getSource() {
28 | return source;
29 | }
30 |
31 | public void setSource(String source) {
32 | this.source = source;
33 | }
34 |
35 | public String getUser_id() {
36 | return user_id;
37 | }
38 |
39 | public void setUser_id(String user_id) {
40 | this.user_id = user_id;
41 | }
42 |
43 | public String getUser_name() {
44 | return user_name;
45 | }
46 |
47 | public void setUser_name(String user_name) {
48 | this.user_name = user_name;
49 | }
50 |
51 | public String getUser_email() {
52 | return user_email;
53 | }
54 |
55 | public void setUser_email(String user_email) {
56 | this.user_email = user_email;
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/SwordOffer/f42_2$左旋转字符串.java:
--------------------------------------------------------------------------------
1 | package SwordOffer;
2 |
3 | import Standard.StringUtils;
4 |
5 | import static SwordOffer.f42_1$翻转单词顺序.Reverse;
6 |
7 | /**
8 | * 题目二：字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。
9 | * 比如输入字符串“abcdefg”和数字 2，
10 | * 该函数将返回左旋转 2 位得到的结果“cdefgab”。
11 | *
12 | *
13 | * 【解】：与上一题类似：
14 | * 第一步，翻转前半部分的字符：ba cdefg
15 | * 第二步，翻转后半部分的字符：ba gfedc
16 | * 第三部，翻转整个字符串：cdegfab
17 | *
18 | * 【左神做法】：/src/nowcoder/b_2nd_Season/bk161012/src/
19 | *
20 | * `小块换过来的东西，定住！
21 | *
22 | *
23 | * Created by nibnait on 2016/10/2.
24 | */
25 | public class f42_2$左旋转字符串 {
26 |
27 | public static void main(String[] args) {
28 | System.out.println(new String(leftRotateString("abcdefg", 2)));
29 | System.out.println(new String(leftRotateString("abcdefg", 1)));
30 | System.out.println(new String(leftRotateString("abcdefg", 6)));
31 | System.out.println(new String(leftRotateString("abcdefg", 7)));
32 | System.out.println(new String(leftRotateString("abcdefg", 0)));
33 | }
34 |
35 | private static String leftRotateString(String str, int n) {
36 | if (StringUtils.isBlank(str) || n<=0 || n>=str.length()){ //n==0，n==str.length 都不用翻转！
37 | return str;
38 | }
39 | char[] chars = str.toCharArray();
40 | Reverse(chars, 0, n-1);
41 | Reverse(chars, n, chars.length-1);
42 | Reverse(chars, 0, chars.length-1);
43 | return new String(chars);
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/ba160720/README.md:
--------------------------------------------------------------------------------
1 | 课程回顾：[http://www.nowcoder.com/live/11/1/1](http://www.nowcoder.com/live/11/1/1)
2 | 课件下载：[https://pan.baidu.com/s/1hs8WGh2](https://pan.baidu.com/s/1hs8WGh2)
3 |
4 | ## 1. 给定一个N*2 的二维数组，看作是一个个二元组，例如[[a1,b1],[a2,b2],[a3,b3]]，
5 | 规定：一个如果想把二元组甲放在二元组乙上，甲中的a 值必须大于乙中的a 值，甲中的b
6 | 值必须大于乙中的b 值。如果在二维数组中随意选择二元组，请问二元组最多可以往上摞
7 | 几个？
8 | 例如：[[5,4],[6,4],[6,7],[2,3]], 最大数量可以摞3 个，[2,3] => [5,4] => [6,7]
9 | 要求：实现时间复杂度O(N*logN)的解法
10 |
11 | 最长递增子序列：
12 | h(i)：当必须以arr的第i号元素结尾的情况下 最长递增子序列的长度的值。
13 |
14 | （2）h(i)：假设我当前遍历到cur这个数时，有效区中，h(i)遍历到 当前时刻为止，长度为i+1的最长递增子序列（子数组）的最小**末尾**
15 |
16 | 排序策略：
17 | - 二元组中两个元素是同等重要的！
18 | - 最优解：先 a 小-->大，（a = a', 再 b 大-->小 排序）。
19 |
20 |
21 |
22 | ## 2.给定一个非负数的数组，代表一个容器。例如数组[0,1,0,2,1,0,1,3,2,1,2,1]，就是
23 | 以下图形中黑色的部分。如果用这个容器接水的话，请问可以接多少水？还以这个数组为例，
24 | 可以接6 格水，就是以下图形中蓝色的部分。
25 | 要求：实现时间复杂度O(N)，额外空间复杂度O(1)的解法
26 |
27 | - 判断有效的波峰波谷！
28 | water[i] = 取两侧的最大值，即可求出此位置的最大水量
29 | 加速求两边的最大值：
30 | 两个辅助数组，
31 | L[i]：从左边一直到当前位置的最大值 、R[i]：
32 | 改进：L[i] --> 一个变量（即可保存遍历到当前位置时的最大值）
33 |
34 | 神级方法：
35 | 两个指针 L、R
36 | 谁指的数字更小，结算当前水量，往中间移动一位，
37 | 相遇即停止
38 |
39 |
40 | ## 3.给定一个非负数的数组，数组中的每个值代表一个柱子的高度，柱子的宽度是1。两个柱
41 | 子之间可以围成一个面积，规定：面积＝两根柱子的最小值＊两根柱子之间的距离。比如数
42 | 组[3,4,2,5]。3 和4 之间围成的面积为0，因为两个柱子是相邻的，中间没有距离。3 和
43 | 2 之间围成的面积为2，因为两个柱子的距离为1，且2 是最短的柱子，所以面积＝1*2。
44 | 3 和5 之间围成的面积为6，因为两个柱子的距离为2，且3 是最短的柱子，所以面积＝
45 | 3*2。求在一个数组中，哪两个柱子围成的面积最大，并返回值。
46 | 要求：实现时间复杂度O(N)，额外空间复杂度O(1)的解法
47 |
48 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bh160907/BiggestSubBSTInTree.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bh160907;
2 |
3 | import Standard.BinaryTreeNode;
4 | import others.PrintBinaryTree;
5 |
6 | /**
7 | * 找到二叉树中的最大搜索二叉子树
8 | *
9 | * Created by nibnait on 2016/9/16.
10 | */
11 | public class BiggestSubBSTInTree {
12 |
13 | private static BinaryTreeNode biggestSubBST(BinaryTreeNode head) {
14 |
15 | return null;
16 | }
17 |
18 |
19 |
20 |
21 | public static void main(String[] args) {
22 |
23 | BinaryTreeNode head = new BinaryTreeNode(6);
24 | head.left = new BinaryTreeNode(1);
25 | head.left.left = new BinaryTreeNode(0);
26 | head.left.right = new BinaryTreeNode(3);
27 | head.right = new BinaryTreeNode(12);
28 | head.right.left = new BinaryTreeNode(10);
29 | head.right.left.left = new BinaryTreeNode(4);
30 | head.right.left.left.left = new BinaryTreeNode(2);
31 | head.right.left.left.right = new BinaryTreeNode(5);
32 | head.right.left.right = new BinaryTreeNode(14);
33 | head.right.left.right.left = new BinaryTreeNode(11);
34 | head.right.left.right.right = new BinaryTreeNode(15);
35 | head.right.right = new BinaryTreeNode(13);
36 | head.right.right.left = new BinaryTreeNode(20);
37 | head.right.right.right = new BinaryTreeNode(16);
38 |
39 | PrintBinaryTree.print(head);
40 | BinaryTreeNode bst = biggestSubBST(head);
41 | PrintBinaryTree.print(bst);
42 |
43 | }
44 |
45 | }
46 |
--------------------------------------------------------------------------------
/out/production/algorithms/nowcoder/b_2nd_Season/ba160720/README.md:
--------------------------------------------------------------------------------
1 | 课程回顾：[http://www.nowcoder.com/live/11/1/1](http://www.nowcoder.com/live/11/1/1)
2 | 课件下载：[https://pan.baidu.com/s/1hs8WGh2](https://pan.baidu.com/s/1hs8WGh2)
3 |
4 | ## 1. 给定一个N*2 的二维数组，看作是一个个二元组，例如[[a1,b1],[a2,b2],[a3,b3]]，
5 | 规定：一个如果想把二元组甲放在二元组乙上，甲中的a 值必须大于乙中的a 值，甲中的b
6 | 值必须大于乙中的b 值。如果在二维数组中随意选择二元组，请问二元组最多可以往上摞
7 | 几个？
8 | 例如：[[5,4],[6,4],[6,7],[2,3]], 最大数量可以摞3 个，[2,3] => [5,4] => [6,7]
9 | 要求：实现时间复杂度O(N*logN)的解法
10 |
11 | 最长递增子序列：
12 | h(i)：当必须以arr的第i号元素结尾的情况下 最长递增子序列的长度的值。
13 |
14 | （2）h(i)：假设我当前遍历到cur这个数时，有效区中，h(i)遍历到 当前时刻为止，长度为i+1的最长递增子序列（子数组）的最小**末尾**
15 |
16 | 排序策略：
17 | - 二元组中两个元素是同等重要的！
18 | - 最优解：先 a 小-->大，（a = a', 再 b 大-->小 排序）。
19 |
20 |
21 |
22 | ## 2.给定一个非负数的数组，代表一个容器。例如数组[0,1,0,2,1,0,1,3,2,1,2,1]，就是
23 | 以下图形中黑色的部分。如果用这个容器接水的话，请问可以接多少水？还以这个数组为例，
24 | 可以接6 格水，就是以下图形中蓝色的部分。
25 | 要求：实现时间复杂度O(N)，额外空间复杂度O(1)的解法
26 |
27 | - 判断有效的波峰波谷！
28 | water[i] = 取两侧的最大值，即可求出此位置的最大水量
29 | 加速求两边的最大值：
30 | 两个辅助数组，
31 | L[i]：从左边一直到当前位置的最大值 、R[i]：
32 | 改进：L[i] --> 一个变量（即可保存遍历到当前位置时的最大值）
33 |
34 | 神级方法：
35 | 两个指针 L、R
36 | 谁指的数字更小，结算当前水量，往中间移动一位，
37 | 相遇即停止
38 |
39 |
40 | ## 3.给定一个非负数的数组，数组中的每个值代表一个柱子的高度，柱子的宽度是1。两个柱
41 | 子之间可以围成一个面积，规定：面积＝两根柱子的最小值＊两根柱子之间的距离。比如数
42 | 组[3,4,2,5]。3 和4 之间围成的面积为0，因为两个柱子是相邻的，中间没有距离。3 和
43 | 2 之间围成的面积为2，因为两个柱子的距离为1，且2 是最短的柱子，所以面积＝1*2。
44 | 3 和5 之间围成的面积为6，因为两个柱子的距离为2，且3 是最短的柱子，所以面积＝
45 | 3*2。求在一个数组中，哪两个柱子围成的面积最大，并返回值。
46 | 要求：实现时间复杂度O(N)，额外空间复杂度O(1)的解法
47 |
48 |
--------------------------------------------------------------------------------
/src/xiaozhao/SoHu_03.java:
--------------------------------------------------------------------------------
1 | package xiaozhao;
2 |
3 | import java.util.Scanner;
4 |
5 | /**
6 | *
7 | 袋鼠过河
8 | 时间限制：C/C++语言 1000MS；其他语言 3000MS
9 | 内存限制：C/C++语言 131072KB；其他语言 655360KB
10 | 题目描述：
11 | 一只袋鼠要从河这边跳到河对岸，河很宽，但是河中间打了很多桩子，每隔一米就有一个，每个桩子上都有一个弹簧，袋鼠跳到弹簧上就可以跳的更远。每个弹簧力量不同，用一个数字代表它的力量，如果弹簧力量为5，就代表袋鼠下一跳最多能够跳5米，如果为0，就会陷进去无法继续跳跃。河流一共N米宽，袋鼠初始位置就在第一个弹簧上面，要跳到最后一个弹簧之后就算过河了，给定每个弹簧的力量，求袋鼠最少需要多少跳能够到达对岸。如果无法到达输出-1
12 | 输入
13 | 输入分两行，第一行是数组长度N，第二行是每一项的值，用空格分隔
14 | 输出
15 | 输出最少的跳数，无法到达输出-1
16 |
17 | 样例输入
18 | 5
19 | 2 0 1 1 1
20 | 样例输出
21 | 4
22 | * Created by nibnait on 2016/9/21.
23 | */
24 | public class SoHu_03 {
25 | public static void main(String[] args) {
26 | Scanner sc = new Scanner(System.in);
27 | while (sc.hasNext()) {
28 | int n = sc.nextInt();
29 | int arr[] = new int[n + 1];
30 | for (int i = 1; i <= n; i++) {
31 | arr[i] = sc.nextInt();
32 | }
33 | int times = 0;
34 | int s = 0;
35 | for (int i = 1; i < arr.length; i++) {
36 | if (s >= n) break;
37 | if (arr[i] != 0) {
38 | times++;
39 | s += arr[i];
40 | continue;
41 | }
42 | if (arr[i] == 0 && arr[1 + s] > 0) {
43 | s += arr[i];
44 | } else {
45 | times = -1;
46 | break;
47 | }
48 | }
49 | System.out.println(times);
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/bd160810/src/TwoStacksImplementQueue.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.bd160810.src;
2 |
3 | import java.util.Stack;
4 |
5 | public class TwoStacksImplementQueue {
6 |
7 | private static class TwoStacksQueue {
8 | public Stack stackPush;
9 | public Stack stackPop;
10 |
11 | public TwoStacksQueue() {
12 | stackPush = new Stack();
13 | stackPop = new Stack();
14 | }
15 |
16 | public void add(int pushInt) {
17 | stackPush.push(pushInt);
18 | }
19 |
20 | public int poll() {
21 | if (stackPop.empty() && stackPush.empty()) {
22 | throw new RuntimeException("Queue is empty!");
23 | } else if (stackPop.empty()) {
24 | while (!stackPush.empty()) {
25 | stackPop.push(stackPush.pop());
26 | }
27 | }
28 | return stackPop.pop();
29 | }
30 |
31 | public int peek() {
32 | if (stackPop.empty() && stackPush.empty()) {
33 | throw new RuntimeException("Queue is empty!");
34 | } else if (stackPop.empty()) {
35 | while (!stackPush.empty()) {
36 | stackPop.push(stackPush.pop());
37 | }
38 | }
39 | return stackPop.peek();
40 | }
41 | }
42 |
43 | public static void main(String[] args) {
44 | TwoStacksQueue test = new TwoStacksQueue();
45 | test.add(1);
46 | test.add(2);
47 | test.add(3);
48 | System.out.println(test.peek());
49 | System.out.println(test.poll());
50 | System.out.println(test.peek());
51 | System.out.println(test.poll());
52 | System.out.println(test.peek());
53 | System.out.println(test.poll());
54 | }
55 |
56 | }
57 |
--------------------------------------------------------------------------------
/src/Algorithms_4thEdition/a_Sorting/g_计数排序.java:
--------------------------------------------------------------------------------
1 | package Algorithms_4thEdition.a_Sorting;
2 |
3 | /**
4 | * 一些时间复杂度趋近于O(N)的排序算法
5 | * （不是基于比较的排序算法）
6 | * 思想来源于桶排序
7 | */
8 |
9 | /**
10 | * Counting_Sort
11 | * 时间复杂度：
12 | * 【题目】
13 | 对于一个int数组，请编写一个计数排序算法，对数组元素排序。
14 | 给定一个int数组A及数组的大小n，请返回排序后的数组。
15 | 测试样例：
16 | [1,2,3,5,2,3],6
17 | [1,2,2,3,3,5]
18 | *
19 | * 【思路】
20 | * 桶排序
21 | *
22 | * Created by nibnait on 2016/9/23.
23 | */
24 |
25 | public class g_计数排序 {
26 | public static void main(String[] args) {
27 | int[] A = new int[]{54,35,48,36,27,12,44,44,8,14,26,17,28};
28 |
29 | A = Counting_Sort(A, 13);
30 |
31 | for (int i = 0; i < A.length; i++) {
32 | System.out.print(A[i]+" ");
33 | }
34 | }
35 |
36 | public static int[] Counting_Sort(int[] A, int n) {
37 |
38 | int max = A[0];
39 | int min = A[0];
40 | for (int i = 0; i < A.length; i++) {
41 | if (A[i]>max) {
42 | max = A[i];
43 | }
44 | if (A[i]0){
58 | A[cnt++] = i+min;
59 | bucket[i]--;
60 | }
61 | }
62 |
63 | return A;
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/src/nowcoder/b_2nd_Season/ba160720/arrUp.java:
--------------------------------------------------------------------------------
1 | package nowcoder.b_2nd_Season.ba160720;
2 |
3 | /**
4 | * 求最长递增子序列的长度
5 | * 自然想法：
6 | * 求出以数组中每一位置结尾的最长递增子序列，
7 | * 即：利用一个辅助数组h[]， h(i)：表示当必须以arr的第i号元素结尾的情况下 最长递增子序列的长度的值。
8 | * 但是这样，你每求一个位置的h(i)都要先遍历一遍arr中他前面的值，都要找到 【比cur(当前值)小的arr[i] 对应的h[i]中最大那个长度 】 然后再加1.，简称：【枚举过程】
9 | * 时间复杂度：O(N^2)
10 | *
11 | * 得分方法：
12 | * 时间复杂度：O(N*log(N) )
13 | * 加速枚举过程，
14 | * 重新定义辅助数组h[]，h(i)：代表当前遍历到cur这个数时，有效区中，h(i)遍历到 当前时刻为止，长度为i+1的最长递增子序列的**最小末尾**
15 | * 这样【因为h[]是有序的】，所以当遍历到cur的时候，cur应该放的位置 可以用二分查找 直接找到！
16 | *
17 | * Created by nibnait on 2016/9/9.
18 | */
19 | public class arrUp {
20 |
21 | public static void main(String[] args) {
22 | int[] arr = new int[]{2, 1, 6, 4, 5, 2, 7, 4};
23 | System.out.println(arrUp(arr));
24 | }
25 |
26 | public static int arrUp(int[] arr) {
27 |
28 | int[] h = new int[arr.length];
29 | int j = 0; //有效区的范围
30 | h[j] = arr[0]; //h[0]表示 当遍历到arr[0]的时候，长度为1的最长递增子序列的最小末尾：就是arr[0]他自己么
31 | for (int i = 1; i < arr.length; i++) {
32 | int lo = 0;
33 | int hi = j;
34 | while (lo <= hi) { //因为h[]是有序的，所以可以利用二分查找，时间复杂度：O(logN)
35 | int mid = (lo + hi) / 2;
36 | if (h[mid] < arr[i]) {
37 | lo = mid + 1;
38 | } else {
39 | hi = mid - 1;
40 | }
41 | }
42 | h[lo] = arr[i]; //将arr[i]放到他应该放的位置上
43 |
44 | j = lo>j? lo: j;
45 | }
46 | return j+1;
47 | }
48 |
49 | }
50 |
--------------------------------------------------------------------------------