三个数的最大乘积

//先对其数组进行冒泡排序（升序排列）。
int temp=0; for (int i=0;i<in.length-1;i++)
{ for (int j=0;j<in.length-1-i;j++)
   { if (in[j] > in[j+1]) 
      { // 相邻元素两两对比  temp = in[j+1];  in[j+1] = in[j]; // 元素交换   in[j] = temp;
      }
   }
}
long negative=Math.abs(in[0])*Math.abs(in[1]);       //对最小的两个负数进行乘积 
long positiveNumber=in[in.length-2]*in[in.length-3]; //对倒数第二、第三的两个正数进行乘积 if(negative>positiveNumber)
{ return negative*in[in.length-1];  //最后乘以数组最后一个元素（最大的数） } else { return positiveNumber*in[in.length-1]; }

long long solve(int* A, int ALen) {
        // write code here
        int min1 = INT_MAX, min2 = INT_MAX;
        // 最大的、第二大的和第三大的
        int max1 = INT_MIN, max2 = INT_MIN, max3 = INT_MIN;

        for (int i=0;i<ALen;i++) {
            if (A[i] < min1) {
                min2 = min1;
                min1 = A[i];
            } else if (A[i] < min2) {
                min2 = A[i];
            }

            if (A[i] > max1) {
                max3 = max2;
                max2 = max1;
                max1 = A[i];
            } else if (A[i] > max2) {
                max3 = max2;
                max2 = A[i];
            } else if (A[i] > max3) {
                max3 = A[i];
            }
        }

        return max((long long)min1 * min2 * max1,(long long) max1 * max2 * max3);

    }

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class T_57 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a[] = {3472,7789,7955,-7098,-9281,6101,5051,7778,3090,7423,-7151,5652,1595,-8094,677,-8324,8347,-2482,9313,-9338,-3157,8559,6945,3618,3087,121,-8468,3225,1356,6939,2799,-7231,-6309,-5453,633,-8689,-4776,2714,-2743,-1409,5918,-3333,1803,8330,-2206,-6117,-4486,-7903,-4375,-3739,2897,8056,-5864,-522,7451,-4541,-2813,5790,-532,-6517,925};
		System.out.println(solve(a));
	}
	public static BigInteger solve (int[] A) {
		int n = A.length;
		if(n<3)
			return new BigInteger("0");
		Arrays.sort(A);
        // 比较这两个位置的大小即可
		BigInteger a = new BigInteger(A[n-1]+"");
		BigInteger b = new BigInteger(A[n-2]+"");
		BigInteger c = new BigInteger(A[n-3]+"");
		BigInteger d = new BigInteger(A[0]+"");
		BigInteger e = new BigInteger(A[1]+"");
		BigInteger r1 = a.multiply(b).multiply(c);
		BigInteger r2 = d.multiply(e).multiply(a);
		if(r1.compareTo(r2)>=0)
                    // 转成long类型
			return r1.longValueExact();
		else
			return r2.longValueExact();
    }
}

import java.util.*;


public class Solution {
    /**
     * 最大乘积
     * @param A int整型一维数组 
     * @return long长整型
     */
    public long solve (int[] A) {
        // write code here
        Arrays.sort(A);//排序，排序后取最小两个数和最大数的乘积与三个最大数相比取大者返回
        long a=A[A.length-1];
        long b=A[A.length-2];
        long c=A[A.length-3];
        long d=A[0];
        long e=A[1];
        if(a*b*c>a*d*e)
        return a*b*c;
        else
            return a*d*e;
    }
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 最大乘积
 * @param A int整型一维数组
 * @return long长整型
 */
function solve(A) {
    //三个数的最大乘积有两种可能
    //1.三个最大的数相乘
    //2.两个最小的数（负数）和一个最大的正数相乘
    if (A.length < 3) return 0;

    // 初始化最大和最小值
    let max1 = -Infinity,
        max2 = -Infinity,
        max3 = -Infinity; // 三个最大的数
    let min1 = Infinity,
        min2 = Infinity; // 两个最小的数

    for (let num of A) {
        // 更新最大值
        if (num > max1) {
            max3 = max2;
            max2 = max1;
            max1 = num;
        } else if (num > max2) {
            max3 = max2;
            max2 = num;
        } else if (num > max3) {
            max3 = num;
        }

        // 更新最小值
        if (num < min1) {
            min2 = min1;
            min1 = num;
        } else if (num < min2) {
            min2 = num;
        }
    }

    // 计算两种可能的最大乘积
    const res1 = max1 * max2 * max3; // 三个最大值的乘积
    const res2 = min1 * min2 * max1; // 两个最小值和一个最大值的乘积

    // 返回较大的乘积
    return Math.max(res1, res2);
}
module.exports = {
    solve: solve,
};

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 最大乘积
     * @param A int整型一维数组
     * @return long长整型
     */
    public long solve (int[] A) {
        // write code here
        Arrays.sort(A);
        return Math.max((long)A[0] * (long)A[1] * (long)A[A.length - 1],
                        (long)A[A.length - 3] * (long)A[A.length - 2] * (long)A[A.length - 1]);
    }
}

    public long solve (int[] A) {
        // write code here
        int len=A.length;
        Arrays.sort(A);
        return Math.max((long)A[len-1]*A[len-2]*A[len-3] ,(long)A[len-1]*A[0]*A[1]);
    }

 public long solve (int[] A) {
        // write code here
        //全正:最后三个相乘
        //全负：最后三个相乘
        //有正有负：要么是最后三个相乘，要么是第1个元素*第二个元素*最后一个元素
        Arrays.sort(A);
        int num = A.length;
        long end1 = (long)A[num - 1] * A[num - 2] * A[num - 3];
        long end2 = (long)A[0]*A[1]*A[num-1];
        long max = Math.max(end1,end2);
        return max;
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 最大乘积
     * @param A int整型一维数组 
     * @return long长整型
     */
    public long solve (int[] A) {
        // write code here
        // 两种情况：2 负 + 1 正 -> 最小的两个数 + 最大数
        // 3 正 最大的三个数
        Arrays.sort(A);
        long max = Long.MIN_VALUE;
        if(A[1] < 0) {
            max = Math.max((long)A[1] * (long)A[0] * (long)A[A.length - 1], max);
        } 
        max = Math.max((long)A[A.length - 1] * (long)A[A.length - 2] * (long)A[A.length - 3], max);
        return max;
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 最大乘积
     * @param A int整型一维数组
     * @return long长整型
     */
    public long solve (int[] A) {
        Arrays.sort(A);
        long min1=A[0],min2=A[1];
        int length=A.length;
        long max1=A[length-1],max2=A[length-2],max3=A[length-3];
        return min1*min2*max1 > max1*max2*max3 ? min1*min2*max1 : max1*max2*max3;
    }
}