Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。与集合 ArrayList 可动态扩容不同，数组是静态的，一个数组实例具有固定的大小，元素的类型也一样，一旦创建了就无法改变容量了。
为了方便学习，小编把与数组相关的算法题目都整理了一份：
正文
1. 二维数组中【查找】
题目描述 ：在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题思路 ：双指针法，从数组的右上角开始，小于目标数就向下，大于目标数就向左。
示例:
输入：
[ [1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30] ]
输出：给定 target =5，返回true；给定 target =20，返回false。
public boolean findNumberIn2DArray(int[][] matrix, int target) {
if (matrix == null || matrix.length == 0) return false;
int row = 0;
int col = matrix.length-1;
while (row < matrix.length && col >= 0) {
int temp = matrix[row][col];
if (temp > target) {
col--;
} else if (temp < target){
row++;
} else {
return true;
}
}
return false;
}2.一维数组中的【查找】
2.1 【找出】数组中出现超过【一半】的数字
题目描述：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。可以假设数组是非空的，并且给定的数组总是存在多数元素。
解题思路：先排序，超过一半的数字必定会覆盖中间元素，找到它。
示例:
输入： [1, 2, 3, 2, 2, 2, 5, 4, 2]
输出：2
public int majorityElement(int[] nums) {
Arrays.sort(nums);
return nums[nums.length/2];
}2.2 【找出】数组中【重复】的数字
题目描述：在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
解题思路：排序之后比较相邻2个元素，相等就是重复元素。
输入： [2, 3, 1, 0, 2, 5, 3]
输出：2 或 3
3. 数字出现的【次数】
3.1 数组中除【一个】数字之外，其他数字都出现了【两次】
题目描述 ：在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了两次。请找出那个只出现一次的数字。
解题思路 ：因为异或相同为0，不同为1，所以2个相同数的异或结果为0，所有数异或结果一定是唯一出现1次的数。
public int singleNumber(int[] nums) {
int num = nums[0];
for (int i = 1; i < nums.length; i++) {
num ^= nums[i];
}
return num;
}3.2 数组中除【一个】数字之外，其他数字都出现了【三次】
题目描述 ：在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。
解题思路 ：利用map找出只出现一次的数字，不管其他数字出现几次都试用，但是空间复杂度不是O(1)。
public int singleNumber(int[] nums) {
List<Integer> list1 = new ArrayList<Integer>();
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) {
if (list1.contains(i)) {
map.put(i, i);
} else {
list1.add(i);
}
}
for (int j : list1) {
if (!map.containsKey(j)) {
return j;
}
}
return -1;
}3.3 数组中除【两个】数字之外，其他数字都出现了【两次】
题目描述 ：一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
解题思路 ：单指针法，先排序，然后对比前后2个值，相等就跳过，不等就输出前面的目标值。
public int[] singleNumbers(int[] nums) {
int[] ret = new int[2];
Arrays.sort(nums);
int i = 1, index = 0;
while (i < nums.length) {
// 与前一个相等就跳过，不等说明i-1是目标数
if (nums[i] == nums[i-1]) {
i += 2;
// 处理目标数字在最后的情况
if (i == nums.length) {
ret[index] = nums[i-1];
}
} else {
ret[index++] = nums[i-1];
i++;
}
}
return ret;
}3.4 【第一个】出现【一次】的字符
题目描述 ：一个整型数组 nums 里有多个数字只出现了一次，找出第一个只出现一次的数字。
解题思路 ：利用 LinkedHashMap 的有序性。
public int FirstNotRepeatingChar(int[] arry) {
LinkedHashMap<Integer, Integer> linkMap = new LinkedHashMap<>();
for (int i = 0;i < arry.length;i++) {
if (linkMap.containsKey(arry[i])) {
linkMap.put(arry[i], linkMap.get(arry[i]) + 1);
} else {
linkMap.put(arry[i], 1);
}
}
Iterator<Map.Entry<Integer, Integer>> it = linkMap.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Integer, Integer> temp = it.next();
if (temp.getValue() == 1) {
return temp.getKey();
}
}
return -1;
}3.5 【第一个】重复的字符
题目描述 ：一个整型数组 nums 里有多个数字只出现了多次，找出第一个重复的数字。
解题思路 ：利用 HashSet 的不可重复性，比 HashMap 更方便，高效。
public int findDuplicate(int[] numbers) {
HashSet<Integer> set = new HashSet<>();
for (int i : numbers) {
if (set.contains(i)) {
return i;
}
set.add(i);
}
return -1;
}4.【合并】两个有序的数组
题目描述：给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
解题思路：因为是递增顺序，所以考虑从末尾输入最大值，然后倒序遍历。
示例：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] ，合并结果是 [1,2,2,3,5,6]。
public void merge(int[] nums1, int m, int[] nums2, int n) {
int end = m+n-1;
int i = m-1;
int j = n-1;
while (j >= 0) {
if (i >= 0 && nums1[i] > nums2[j]) {
nums1[end--] = nums1[i--];
} else {
nums1[end--] = nums2[j--];
}
}
}5.把数组排成【最小的数】
题目描述：输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
解题思路：重写排序规则，注意：不能使用Array.sort()排序，否则3会在30前面，显然330>303不合适。
public String minNumber(int[] nums) {
if (nums == null || nums.length == 0) return "";
// 冒泡排序的原理
for (int i=0;i<nums.length;i++) {
for (int j=i+1;j<nums.length;j++) {
if (this.compare(nums[i], nums[j])) {
int temp = nums[j];
nums[j] = nums[i];
nums[i] = temp;
}
}
}
// 遍历输出结果
StringBuilder sb = new StringBuilder("");
for (int i=0;i<nums.length;i++) {
sb.append(nums[i]+"");
}
return sb.toString();
}
// 重写比较规则（compare方法拆出来是为了更直观）
private boolean compare (int a, int b) {
Long left = Long.valueOf(a + "" + b);
Long right = Long.valueOf(b + "" + a);
if (left > right) {
return true;
} else {
return false;
}
}6. 【括号】匹配的问题
题目描述：给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
思路：利用栈的特性，在栈底多垫一个数存储数值。
示例：
输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"
public int longestValidParentheses(String s) {
int maxNum = 0;
Stack<Integer> stack = new Stack<Integer>();
stack.push(-1);
// 栈里：有多少'('，就需要多少')'
// 栈底存储上一次满足匹配位置的元素下标，用于计算长度
for (int i = 0;i < s.length();i++) {
if (s.charAt(i) == '(') {
stack.push(i);
} else {
stack.pop();
if (stack.isEmpty()) {
stack.push(i);
} else {
// 下标在这里用来计算匹配长度
maxNum = Math.max(maxNum, i-stack.peek());
}
}
}
return maxNum;
}7. 求最长【回文子串 】#
题目描述：给定一个字符串 s，找到 s 中最长的回文子串，假设 s 的最大长度不超过1000。tips: 回文字符串：正读反读都一样。
思路：动态规划的思想，其他方法介绍欢迎查看下面的博文。
示例：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
public String longestPalindrome(String s) {
if (s.isEmpty()) return s;
int len = s.length();
boolean[][] dp = new boolean[len][len];
int left = 0, right = 0;
// 倒序向前遍历
for (int i = len - 2; i >= 0; i--) {
for (int j = i + 1; j < len; j++) {
// 小于3一定是回文，aa或aba
dp[i][j] = s.charAt(i) == s.charAt(j) && ( j-i < 3 || dp[i+1][j-1]);
// 更新左右边界
if(dp[i][j] && right-left < j-i){
left = i;
right = j;
}
}
}
return s.substring(left,right+1);
}
https://blog.csdn.net/weixin_44259720/article/details/1229889818. 连续子数组的【最大和】 #
题目描述：输入一个整型数组，数组中有正数也有负数，数组中一个或连续的多 个整数组成一个子数组，求连续子数组的最大和 。
思路：动态规划，若和小于 0，则将最大和置为当前值，否则计算最大和。
public int maxSubArray(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
int sum = nums[0];
int result = nums[0];
for (int num : nums) {
// 如果 sum + num < num，说明前面的计算结果 sum 没有意义，所以要换掉
sum = sum > 0 ? sum + num : num;
// result永远保存最大值
result = Math.max(sum, result);
}
return result;
}9.将数组中的【奇数】放在【偶数】前 #
题目描述：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。要求：时间复杂度 O（n)，空间复杂度 O（1)
解题思路：冒泡原理，遇到偶数就冒到最后。
public void reOrderArray_2(int[] array) {
if (array == null || array.length == 0) return;
int i = 0, index = 0;
int len = array.length - 1;
while(i < len - index){
if (array[i] % 2 == 0) {
for (int j = i; j < array.length - 1;j++) {
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
index ++;
}
i++;
}
}10.两个数组的【重合】和【不重合】部分
题目描述：A国和B国正在打仗，他们的目的是n块土地。A国希望得到这n块土地中的p块土地，B国希望得到这n块土地中的q块土地。你需要计算，有几块土地是只有A国想要的，有几块土地是只有B国想要的，有几块土地是两个国家都想要的。
解题思路：先排序，然后双指针法取相同部分。
public int[] samedrome(int[] country_a, int[] country_b){
int[] result = new int[3];
Arrays.sort(country_a);
Arrays.sort(country_b);
// i是A指针，j是B指针，index是重合部分的长度
int i=0, j=0, index=0;
while (i < country_a.length && j < country_b.length) {
if (country_a[i] > country_b[j]) {
j++;
} else if (country_a[i] < country_b[j]) {
i++;
} else {
i++;
j++;
index++;
}
}
result[0] = country_a.length - index; // a
result[1] = country_b.length - index; // b
result[2] = index; // 重合
return result;
}11.求两个【乘积最小】的数
题目描述：输入一个【递增排序】的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S，如果有多对数字的和等于 S，输出两个数的乘积最小的。
解题思路：定义两个指针，分别从前面和后面进行遍历。间隔越远乘积越小，所以是最先出现的两个数乘积最小。
public ArrayList<Integer> FindNumbersWithSum(int [] array, int sum) {
ArrayList<Integer> retList = new ArrayList<>();
if (array == null ) return retList;
int left = 0;
int right = array.length - 1;
while (left < right) {
int temp = array[left] + array[right];
if (temp == sum){
retList.add(array[left]);
retList.add(array[right]);
break;
} else if (temp < sum) {
left++;
} else {
right--;
}
}
return retList;
}