三个数的最大乘积

//先对其数组进行冒泡排序（升序排列）。
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;
    }
}

    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;
    }
}

package main

import "sort"

/**
 * 最大乘积
 * @param A int整型一维数组 
 * @return long长整型
*/
func solve( A []int ) int64 {
    sort.Ints(A)
    n:=len(A)
    a,b:=A[0]*A[1]*A[n-1],A[n-1]*A[n-2]*A[n-3]
    if a>b{
        return int64(a)
    }
    return int64(b)
}

/**
 * 最大乘积
 * @param A int整型一维数组 
 * @param ALen int A数组长度
 * @return long长整型
 */
 int cnp(const void *e1,const void *e2){
    return *(int*)e1-*(int *)e2;
 }
long long solve(int* A, int ALen ) {
    // write code here
    qsort(A,ALen,sizeof(int),cnp);
    if(A[1]>=0)
        return (long long)A[ALen-1]*A[ALen-2]*A[ALen-3];
    else{
        //if(A[3]>=0)
           return (((long long)A[ALen-1]*A[ALen-2]*A[ALen-3]>(long long)A[ALen-1]*A[0]*A[1])?(long long)A[ALen-1]*A[ALen-2]*A[ALen-3]:(long long)A[ALen-1]*A[0]*A[1]);  
        }
    }

long long solve(int* A, int ALen ) 
{
    int i,j,temp;
    long produce;
    for(i=0;i<ALen-1;i++)
    {
        for(j=i+1;j<ALen;j++)
        {
            if(A[i]>A[j])
            {
                temp = A[i];
                A[i] = A[j];
                A[j] = temp;

            }
        }
    }

    if(A[ALen-2] * A[ALen-3]>=A[0] * A[1])
    {
        produce = (long) A[ALen-1] * A[ALen-2] * A[ALen-3];
        return produce;
    }
    else
    {
         produce = (long) A[0] * A[1] * A[ALen-1];
        return produce;
    }
}

class Solution:
    def solve(self , A: List[int]) -> int:
        # write code here
        A = sorted(A)
        # 两个负数 + 一个正数 / 三个正数
        return max(A[0]*A[1]*A[-1], A[-3]*A[-2]*A[-1])