- 连续子数组的最大和
public class A {
private static void maxSonSum(int[] array) {
if (array == null || array.length == 0)
return;
int[] dp = new int[array.length];
dp[0] = array[0];
int max = dp[0];
for (int i = 1; i < array.length; i++) {
dp[i] = Math.max(dp[i - 1] + array[i], array[i]);
if (max < dp[i])
max = dp[i];
}
System.out.println(max);
}
private static void maxSonSum2(int[] array) {
if (array == null || array.length == 0)
return;
int sum = 0;
int result = array[0];
for (int num : array) {
sum = sum > 0 ? sum + num : num;
result = Math.max(result, sum);
}
System.out.println(result);
}
public static void main(String[] args) {
int[] array = {1, -2, -3, -10, 4, -5};
maxSonSum(array);
maxSonSum2(array);
}
}
- 从1到n整数中1出现的次数
public class B {
private static int numberOf1(int n) {
int count = 0;
int i = 1;
int current, after, before;
while ((n / i) != 0) {
before = n / (i * 10);
current = (n / i) % 10;
after = n - (n / i) * i;
if (current == 0)
count = count + before * i;
else if (current == 1)
count = count + before * i + after + 1;
else if (current > 1)
count = count + (before + 1) * i;
i *= 10;
}
return count;
}
public static void main(String[] args) {
System.out.println(numberOf1(125));
}
}
- 把数组排成最小的数
public class C {
private static void printMinNumber(int[] array) {
if (array == null || array.length == 0)
return;
int len = array.length;
String[] strs = new String[len];
for (int i = 0; i < len; i++) {
strs[i] = String.valueOf(array[i]);
}
Arrays.sort(strs, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
String s1 = o1 + o2;
String s2 = o2 + o1;
return s1.compareTo(s2);
}
});
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i++) {
sb.append(strs[i]);
}
System.out.println(sb.toString());
}
public static void main(String[] args) {
int[] array = {3,32,321};
printMinNumber(array);
}
}
- 丑数
public class D {
private static int getKUgly(int k) {
if (k <= 0)
return 0;
int[] arr = new int[k];
arr[0] = 1;
int m2 = 0, m3 = 0, m5 = 0;
for (int i = 1; i < k; i++) {
int min = Math.min(arr[m2] * 2, Math.min(arr[m3] * 3, arr[m5] * 5));
arr[i] = min;
if (arr[m2] * 2 == min)
m2++;
if (arr[m3] * 3 == min)
m3++;
if (arr[m5] * 5 == min)
m5++;
}
return arr[k - 1];
}
public static void main(String[] args) {
System.out.println(getKUgly(10));
}
}
- 第一个只出现一次的字符
public class E {
private static void getFirstOnce(String str) {
if (str == null || str.length() == 0)
return;
char[] chars = str.toCharArray();
HashMap<Character, Integer> map = new HashMap<>();
for (char c : chars) {
if (map.containsKey(c))
map.put(c, map.get(c) + 1);
else
map.put(c, 1);
}
for (char c : chars) {
if (map.get(c) == 1) {
System.out.println(c);
break;
}
}
}
public static void main(String[] args) {
getFirstOnce("abbabacsadiuh");
}
}
- 数组中的逆序对
public class A {
private static int count = 0;
private static void inversePairs(int[] array) {
if (array == null || array.length == 0)
return;
mergeSort(array, 0, array.length - 1);
System.out.println(count);
}
private static void mergeSort(int[] array, int start, int end) {
int mid = (start + end) / 2;
if (start < end) {
mergeSort(array, start, mid);
mergeSort(array, mid + 1, end);
merge(array, start, mid, end);
}
}
private static void merge(int[] data, int start, int mid, int end) {
int[] arr = new int[end - start + 1];
int c = 0;
int s = start;
int index = mid + 1;
while (start <= mid && index <= end) {
if (data[start] < data[index]) {
arr[c++] = data[start++];
} else {
arr[c++] = data[index++];
count += mid + 1 - start;
count %= 1000000007;
}
}
while (start <= mid)
arr[c++] = data[start++];
while (index <= end)
arr[c++] = data[index++];
for (int i : arr)
data[s++] = i;
}
public static void main(String[] args) {
int[] arr = {7,5,6,4};
inversePairs(arr);
}
}
- 两个链表的第一个公共结点
public class B {
private static void findFirstCommon(int[] a, int[] b) {
if (a == null || b == null || a.length == 0 || b.length == 0)
return;
int len = Math.abs(a.length - b.length);
if (a.length > b.length) {
for (int value : b) {
if (a[len++] == value) {
System.out.println(a[--len]);
break;
}
}
} else {
for (int value : a) {
if (b[len++] == value) {
System.out.println(b[--len]);
break;
}
}
}
}
private static void findFirstCommon1(int[] a, int[] b) {
if (a == null || b == null || a.length == 0 || b.length == 0)
return;
Stack<Integer> stackA = new Stack<>();
Stack<Integer> stackB = new Stack<>();
for (int i : a) {
stackA.push(i);
}
for (int i : b) {
stackB.push(i);
}
Integer common = null;
while (!stackA.empty() && !stackB.empty() && stackA.peek().equals(stackB.peek())) {
common = stackA.pop();
stackB.pop();
}
System.out.println(common);
}
public static void main(String[] args) {
int[] b = {1, 2, 3, 6, 7};
int[] a = {5, 4, 6, 7};
findFirstCommon1(a, b);
}
}
- 数字在排序数组中出现的次数
public class C {
private static int getK(int[] arr, int start, int end, int k, int flag) {
if (arr == null || arr.length == 0 || start >= end)
return -1;
int index = -1;
int mid = (end + start) / 2;
if (flag == 1) {
if (k < arr[mid])
index = getK(arr, start, mid, k, flag);
else if (k > arr[mid])
index = getK(arr, mid + 1, end, k, flag);
else if (arr[mid] == k) {
if (mid == 0 || arr[mid - 1] != k)
return mid;
else
index = getK(arr, start, mid, k, flag);
}
} else {
if (k < arr[mid])
index = getK(arr, start, mid, k, flag);
else if (k > arr[mid])
index = getK(arr, mid + 1, end, k, flag);
else if (arr[mid] == k) {
if (mid + 1 == end || arr[mid + 1] != k)
return mid;
else
index = getK(arr, mid + 1, end, k, flag);
}
}
return index;
}
private static int kCount(int[] arr, int k) {
int first = getK(arr, 0, arr.length, k, 1);
System.out.println(first);
int last = getK(arr, 0, arr.length, k, 0);
System.out.println(last);
return first == -1 ? 0 : last - first + 1;
}
public static void main(String[] args) {
int[] arr = {1};
System.out.println(kCount(arr, 1));
}
}
- 二叉树的深度/是否是平衡二叉树
public class D {
private static int getDepth(Tree root) {
if (root == null)
return 0;
int left = getDepth(root.left);
int right = getDepth(root.right);
return left > right ? left + 1 : right + 1;
}
private static boolean isBalanced(Tree root) {
if (root == null)
return true;
boolean condition = Math.abs(getDepth(root.left) - getDepth(root.right)) <= 1;
return condition && isBalanced(root.left) && isBalanced(root.right);
}
public static void main(String[] args) {
Tree root = Tree.creat(new Tree());
System.out.println(isBalanced(root));
}
}
- 数组中只出现一次的数字
public class E {
private static void FindNumsAppearOnce(int[] array) {
if (array == null || array.length < 2)
return;
int res = 0;
for (int num : array)
res ^= num;
int index = 0;
for (; index < 32; index++) {
if (((res >> index) & 1) == 1)
break;
}
int[] result = new int[2];
for (int num : array) {
if (((num >> index) & 1) == 1)
result[0] ^= num;
else
result[1] ^= num;
}
System.out.println(Arrays.toString(result));
}
public static void main(String[] args) {
int[] arr = {2,4,3,6,3,2,5,5};
FindNumsAppearOnce(arr);
}
}