三个数相加等于目标数的问题

问题阐述

  遇到了一个算法问题,话说三个数相加等于目标数,并且时间复杂度为最小。例如{1,3,5,9,6,8,7,2,4},其中三个数相加等于15,找出这些数。

  思考:对于这个问题,时间复杂度要求最小,那么只有一层循环来做,找到三个数的和是目标数,需要先排序,然后通过三个指针来进行移动,比如说i,j,k,

  i=0,j=i+1,k=arr.length-1,首先要排序,有了顺序之后就好做了。若arr[i]+arr[j]+arr[k] < target  则 j 进行移动,若arr[i]+arr[j]+arr[k] > target 则k进行移动,若相等,则打印出来。

  这就是指针的思想。有了这个想法,代码就好说了,

代码实现

  代码实现如下,其中也有快排,如果不知道快排的同学,可以看下我写的这篇快排文章:https://www.cnblogs.com/lixiaochao/p/10029968.html

 @Test
    public void test(){
        int[] array = {1,3,5,9,6,8,7,2,4};
        sanAdd(array,15);
    }

    /**
     * 三个数相加等于目标数
     * @param array
     * @param target
     */
    private void sanAdd(int[] array,int target){

        if(array == null){
            return;
        }
        //排序
        quickSort(array);

        //三个数相加等于target
        sanshu(array,target);

    }

    /**
     * 快排
     * @param array
     */
    private void quickSort(int[] array){
        int high = array.length-1,low=0;
        subSort(array,high,low);
        for(int i = 0; i<array.length; i++){
            System.out.println(array[i]);
        }
    }

    private int getMiddle(int[] array,int high,int low){

        int key = array[low];
        while (low < high) {
            while (low < high && array[high] >= key){
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= key){
                low++;
            }
            array[high] = array[low];
        }
        array[low] = key;
        return low;
    }

    private void subSort(int[] array,int high,int low){
        if(low>high){
            return;
        }
        int result = getMiddle(array, high, low);
        subSort(array,result - 1,low);
        subSort(array, high,result + 1);
    }

    private void sanshu(int[] array,int target){

        int i = 0,j,k;

        for(i = 0,j=i+1,k = array.length-1; i < array.length && j<array.length && k>=0;){

            int sum = array[i]+array[j]+array[k];

            if(sum < target){
                j++;
            }else if(sum > target){
                k--;
            }else {
                System.out.println("三个数为:i,j,k:"+array[i]+","+array[j]+","+array[k]);
                j++;
            }
            if(j==k){
                //进入i的大循环
                i++;
                j=i+1;
                k = array.length-1;
            }

        }
    }

 

转载于:https://www.cnblogs.com/lixiaochao/p/10029986.html

可以使用回溯法来解决这个问题。具体步骤如下: 1. 定义一个全局变量sum,用来保存当前组合的和。 2. 定义一个全局变量min_gap,用来记录当前组合的和与目标之间的最小差值。 3. 定义一个递归函,该函接收三个:一个数组nums,数组的长度len,以及目标target。 4. 在递归函中,使用一个循环遍历数组nums,每次取出一个num,将其加入到sum中。 5. 如果当前的sum已经大于等于target,计算当前sum与target之间的差值gap,并与min_gap比较,更新min_gap的值。 6. 如果当前的sum还没有达到target,继续递归调用自己,传入新的参:nums、len、target。 7. 在递归结束后,将sum减去num,回溯到上一层递归。 8. 最后返回min_gap的值,即为最接近或等于目标的组合和与目标之间的差值。 以下是代码示例: ```c #include <stdio.h> #include <stdlib.h> #include <limits.h> int sum = 0; // 当前组合的和 int min_gap = INT_MAX; // 当前组合的和与目标之间的最小差值 void backtrack(int *nums, int len, int target) { for (int i = 0; i < len; i++) { sum += nums[i]; if (sum >= target) { int gap = abs(sum - target); if (gap < min_gap) { min_gap = gap; } } else { backtrack(nums, len, target); } sum -= nums[i]; } } int main() { int nums[] = {1, 2, 3, 4, 5}; int len = sizeof(nums) / sizeof(int); int target = 8; backtrack(nums, len, target); printf("min_gap = %d\n", min_gap); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值