这里介绍三种方法
方法1
思路:
双重for循环,每一个数和所有其他的数进行相加,如果等于目标值则打印出
时间复杂度 :
O(N2)
空间复杂度 :
O(1)
public static void main(String[] args) {
int[] nums = new int[]{1, 8, 9, 6, 4, 3, 7};
int target = 10;
method1(nums, target);
}
public static void method1(int[] nums, int target) {
for (int i = 0, size = nums.length; i < size; i++) {
for (int j = 0; j < size; j++) {
if (nums[i] + nums[j] == target) {
System.out.println(nums[i] + "+" + nums[j] + "=" + target);
break;
}
}
}
}
结果:
1+9=10
9+1=10
6+4=10
4+6=10
3+7=10
7+3=10
方法2
思路:
1.先将数组进行排序
2.从两边进行遍历数组(left,right指针)
2.1:num[left]+num[right]=target,则打印出,则left++,right–
2.2:num[left]+num[right]<target,则left++
2.3:num[left]+num[right]>target,right–
时间复杂度:
排序算法复杂度+O(N)
空间复杂度:
排序算法复杂度+O(1)
public static void main(String[] args) {
int[] nums = new int[]{1, 8, 9, 6, 4, 3, 7};
int target = 10;
method2(nums, target);
}
public static void method2(int[] nums, int target) {
//1.先排序(这里使用的是快速排序){1,3,4,6,7,8,9};
quickSort(nums, 0, nums.length - 1);
//2.次数num是已经排序好的数组,从两边遍历已排序的数组
for (int left = 0, right = nums.length - 1; left < right; ) {
//2.1.相等的话,直接输出即可
if (nums[left] + nums[right] == target) {
System.out.println(nums[left] + "+" + nums[right] + "=" + target);
left++;
right--;
} else if (nums[left] + nums[right] < target) {
//2.2.相加小于目标值,则left++
left++;
} else {
//2.3.相加小于目标值,则 right--
right--;
}
}
}
快排方法
/**
* 快排
*
* @param nums
* @param startIndex
* @param endIndex
*/
private static void quickSort(int[] nums, int startIndex, int endIndex) {
if (startIndex < endIndex) {
//第一次划分
int partition = partition(nums, startIndex, endIndex);
//递归调用左侧排序
quickSort(nums, startIndex, partition - 1);
//递归调用右侧排序
quickSort(nums, partition + 1, endIndex);
}
}
快排中的一次划分
/**
* @param nums 待排序数组
* @param startIndex 开始位置
* @param endIndex 结束位置
* @return 排序后:关键字的索引
*/
private static int partition(int[] nums, int startIndex, int endIndex) {
int key = nums[startIndex];
while (startIndex < endIndex) {
//从右往左
while (startIndex < endIndex && nums[endIndex] > key) {
endIndex--;
}
if (startIndex < endIndex) {
nums[startIndex] = nums[endIndex];
startIndex++;
}
//从左往右
while (startIndex < endIndex && nums[startIndex] < key) {
startIndex++;
}
if (startIndex < endIndex) {
nums[endIndex] = nums[startIndex];
endIndex--;
}
}
//等到左右重合有,相当于此位置已经分出了三个区域
//[小于flagNum][flagnum][大于flagNum]
nums[startIndex] = key;
return startIndex;
}
结果:
1+9=10
3+7=10
4+6=10
方法3
思路:
限制条件:1.数组中的数字不会很大.2.前提是知道素组中的最大值(否则的话还要遍历一遍找出最大值,时间复杂度就会加O(N))
因为要创建一个数组中最大值长度的数组.就是将遍历数组的值对应的就是temp的角标, temp的值就是其是否遍历过.
1.准备好一个数组temp[maxnum]
2.遍历待排序数组:int sub=target-num[i];
3.如果temp[sub-1]不为0,则说明找到了一对,输出即可.将temp[sub]=0,后面若有重复的数据,可再次存储.
4.否则:将temp[nums[i]-1]++;
时间复杂度:
O(N)
空间复杂度:
O(N)—>其实是:O(maxNum)
public static void main(String[] args) {
int[] nums = new int[]{1, 8, 9, 6, 4, 3, 7};
int target = 10;
method3(nums, target,9);
}
public static void method3(int[] nums, int target, int maxNum) {
int[] temp = new int[maxNum];
int sub;
for (int i = 0, size = nums.length; i < size; i++) {
sub = target - nums[i];
if (temp[sub - 1] > 0) {
System.out.println(sub + "+" + nums[i] + "=" + target);
//然后清除此位置的数据
temp[sub - 1] = 0;
} else {
temp[nums[i] - 1]++;
}
}
}
结果:
1+9=10
6+4=10
3+7=10
总结:
方法1是最先想到(时间复杂度比较大)
方法2是相对比较好的方法,(时间复杂度和空间复杂度相对比较适中)这个就得看排序算法选择的是否合适.
其他的排序算法:
冒泡排序,快速排序,堆排序
箱排序,基数排序
方法3是对数组的元素有一定的限制,最大值合理,是空间换时间.
如果大家有什么好的方法,希望大家可以提出来.共同学习.