package com.angelstar.studyandroid;
import java.util.HashSet;
/**
* Created by jackyang on 2017/11/14
*/
public class SuanFa {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] x = twoSum(numbers, 8);
System.out.println(x[0] + "==" + x[1]);
int[] numbers2 = {1, 1, 2, 2, 44, 44, 5};
System.out.println("落单的数字：" + chooseSingleNum(numbers2));
}
/**
* 给一个整数数组，找到两个数使得他们的和等于一个给定的数 target。
* 你需要实现的函数twoSum需要返回这两个数的下标, 并且第一个下标小于第二个下标。注意这里下标的范围是 1 到 n，不是以 0 开头。
*
* @param numbers
* @param target
* @return你‘【】】】5】’
*/
private static int[] twoSum(int[] numbers, int target) {
int[] newArr = new int[2];
for (int i = 0; i <= numbers.length - 1; i++) {
for (int j = 1 + i; j < numbers.length; j++) {
System.out.println("numbers[i] = [" + numbers[i] + "], numbers[j] = [" + numbers[j] + "]");
if (numbers[i] + numbers[j] == target) {
newArr[0] = numbers[i];
newArr[1] = numbers[j];
return newArr;
}
}
}
return newArr;
}
/**
* 给出2*n + 1 个的数字，除其中一个数字之外其他每个数字均出现两次，找到这个数字。
*
* @param arr
* @return 落单的数字
*/
private static int chooseSingleNum(int[] arr) {
int result = 0;
for (int anArr : arr) {
result ^= anArr;
}
return result;
}
/**
* 查找字符串中无重复最长子串的长度
*
* @param s
* @return
*/
public int lengthOfLongestSubstring(String s) {
if (s == null || s.length() == 0)
return 0;
HashSet<Character> set = new HashSet<Character>();
int max = 0;
int walker = 0;
int runner = 0;
while (runner < s.length()) {
if (set.contains(s.charAt(runner))) {
while (s.charAt(walker) != s.charAt(runner)) {
set.remove(s.charAt(walker));
walker++;
}
if (max < runner - walker) {
max = runner - walker;
}
walker++;
} else {
set.add(s.charAt(runner));
}
runner++;
}
max = Math.max(max, runner - walker);
return max;
}
/**
* 将一个整数中的数字进行颠倒，当颠倒后的整数溢出时，返回 0 (标记为 32 位整数)。
*
* @param n
* @return 反转过后的
*/
public static int reverseInteger(int n) {
String str = n + "";
System.out.println("传递过来的值：" + str);
if (str.contains("-")) {
str = str.substring(1, str.length());
System.out.println("负数切割后：" + str);
}
char[] ch = str.toCharArray();
System.out.println("字符长度" + ch.length);
StringBuilder sb = new StringBuilder();
for (int i = ch.length - 1; i >= 0; i--) {
sb.append(ch[i]);
}
if (Long.parseLong(sb.toString()) > Integer.MAX_VALUE) {
return 0;
} else {
if ((n + "").contains("-")) {
return -Integer.parseInt(sb.toString());
}
return Integer.parseInt(sb.toString());
}
}
}
/*
* 二叉树最大深度
*
* C++代码
* <p>
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
* //
* // class Solution {
* // public int maxDepth(TreeNode*root) {
* // int max = 0;
* // if (root != null) {
* // max++;
* // int max_left = maxDepth(root -> left);
* // int max_right = maxDepth(root -> right);
* //
* // max += max_left > max_right ? max_left : max_right;
* // }
* // return max;
* // }
* // }
* //
* }
链表求和2： 假定用一个链表表示两个数，其中每个节点仅包含一个数字。
package suanfa.lintcode;
import java.util.Stack;
//链表
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
next = null;
}
}
public class SumListNode {
/**
* 链表求和1：你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，
* 使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。
*
* @param l1
* example：3->1->5->null
* @param l2
* example：5->9->2->null
* @return
* example：8->0->8->null
*/
public ListNode addListNode1(ListNode l1, ListNode l2) {
ListNode result = new ListNode(0);
ListNode node = result;
// 进位标志
int flag = 0;
while (l1 != null && l2 != null) {
int value = l1.val + l2.val + flag;
flag = value / 10;
value = value % 10;
node.next = new ListNode(value);
node = node.next;
l1 = l1.next;
l2 = l2.next;
}
while (l1 != null) {
int value = l1.val + flag;
flag = value / 10;
value = value % 10;
node.next = new ListNode(value);
node = node.next;
l1 = l1.next;
}
while (l2 != null) {
int value = l2.val + flag;
flag = value / 10;
value = value % 10;
node.next = new ListNode(value);
node = node.next;
l2 = l2.next;
}
if (flag == 1) {
node.next = new ListNode(1);
node = node.next;
}
return result.next;
}
/**
* 链表求和2： 假定用一个链表表示两个数，其中每个节点仅包含一个数字。
* 假设这两个数的数字顺序排列，请设计一种方法将两个数相加，并将其结果表现为链表的形式
*
* @param l1
* example：6->1->7
* @param l2
* example：2->9->5
* @return
* example：9->1->2
*/
public ListNode addListNode2(ListNode l1, ListNode l2) {
Stack<Integer> stack1 = getListNodeStack(l1);
Stack<Integer> stack2 = getListNodeStack(l2);
ListNode result = new ListNode(0);
int flag = 0; // 进位标志
// 对于两个链表，长度相等时计算
while (!stack1.isEmpty() && !stack2.isEmpty()) {
int value = stack1.pop() + stack2.pop() + flag;
flag = value / 10;
value = value % 10;
// 创建一个新的节点
ListNode curr = new ListNode(value);
// 当前节点的next 指向之前的一个节点
curr.next = result.next;
// 将当前节点存储起来
result.next = curr;
}
// 当第一个链表长度大于第二个链表长度时
while (!stack1.isEmpty()) {
int value = stack1.pop() + flag;
flag = value / 10;
value = value % 10;
// 创建一个新的节点
ListNode curr = new ListNode(value);
// 当前节点的next 指向之前的一个节点
curr.next = result.next;
// 将当前节点存储起来
result.next = curr;
}
// 当第二个链表长度大于第一个链表长度时
while (!stack2.isEmpty()) {
int value = stack2.pop() + flag;
flag = value / 10;
value = value % 10;
// 创建一个新的节点
ListNode curr = new ListNode(value);
// 当前节点的next 指向之前的一个节点
curr.next = result.next;
// 将当前节点存储起来
result.next = curr;
}
// 如果flag等于1，则需要创建一个新的节点
if (flag == 1) {
ListNode curr = new ListNode(1);
curr.next = result.next;
result.next = curr;
}
return result.next;
}
/**
* 将链表存储到栈里面
*
* @param node
* @return Stack
*/
public Stack<Integer> getListNodeStack(ListNode node) {
Stack<Integer> stack = new Stack<>();
while (node != null) {
stack.push(node.val);
node = node.next;
}
return stack;
}
}
