Java 在随机数列表中查找三角形

我把每个元素取为“和”、“第一”和“秒”。如果（first+sec

public void findTriangle(int[] a){

    HashSet<HashSet<Integer>> triangle = new HashSet<HashSet<Integer>>();
    HashSet<Integer> tmp;
    for(int i=0;i<a.length;i++){
        int sum=a[i];
        for(int j=0;j<a.length;j++){
            int first = a[j];
            if(first!=sum){
                for(int k=0;k<a.length;k++){
                    int sec = a[k];
                    if(sec!=first && sec!=sum && (first + sec < sum)){
                        tmp = new HashSet<Integer>();
                        tmp.add(first);
                        tmp.add(sec);
                        tmp.add(sum);
                        triangle.add(tmp);
                    }
                }       
            }
        }

    }

    for(HashSet<Integer> hs : triangle)
        System.out.println(hs);
}

public void findTriangle（int[]a）{
HashSet三角形=新HashSet（）；
HashSet-tmp；
对于（int i=0；i对数组排序并将三元组添加到列表中-

public static ArrayList<ArrayList<Integer>> get(int[] input) {
    ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
    if (input.length < 3) {
      return result;
    }
    Arrays.sort(input);
    for (int i = 0; i < input.length - 2; i++) {
      int k = i + 2;
      for (int j = i + 1; j < input.length; j++) {
        while (k < input.length && input[i] + input[j] > input[k]) {
          ArrayList<Integer> inner = new ArrayList<Integer>();
          inner.add(input[i]);
          inner.add(input[j]);
          inner.add(input[k]);
          result.add(inner);
          k++;
        }
      }
    }
    return result;
  }

publicstaticarraylistget（int[]input）{
ArrayList结果=新建ArrayList（）；
如果（输入长度<3）{
返回结果；
}
数组。排序（输入）；
对于（int i=0；iinput[k]）{
ArrayList内部=新的ArrayList（）；
添加（输入[i]）；
inner.add（输入[j]）；
inner.add（输入[k]）；
结果：添加（内部）；
k++；
}
}
}
返回结果；
}
还没有达到最佳效果。我尝试测试了上述两种解决方案，但它们似乎不起作用。可能是我遗漏了什么。因此决定将测试过的解决方案发布在此处。它不会检查重复的解决方案。
找到三角形的条件：

import java.util.ArrayList；
导入java.util.HashSet；
导入java.util.List；
导入java.util.array；
阶级三角{
INTA；
int b；
INTC；
公共三角形（整数a、整数b、整数c）{
这个a=a；
这个.b=b；
这个.c=c；
}
@凌驾
公共字符串toString（）{
返回此.a+“”+此.b+“”+此.c；
}
}
公共类FindTriangle{
公共列表findTriangle（列表点）{
列表结果=新建ArrayList（）；
系统输出打印项次（“输入”）；
对于（int i=0；i0；j++）{
int pt1=点。获取（j）；
int pt2=点。获取（j+1）；
布尔isTri=isTriangle（pt0，pt1，pt2）；
if（isTri.equals（Boolean.TRUE））{
三角形t=新三角形（pt0、pt1、pt2）；
结果：添加（t）；
}
}
//决赛
int-pt1，pt2；
如果（i==0）{
pt1=点。获取（i+1）；
pt2=points.get（points.size（）-1）；
}else if（i==points.size（）-1）{
pt1=点。获取（0）；
pt2=点.get（i-1）；
}否则{
pt1=点。获取（i+1）；
pt2=点.get（i-1）；
}
布尔isTri=isTriangle（pt0，pt1，pt2）；
if（isTri.equals（Boolean.TRUE））{
三角形t=新三角形（pt0、pt1、pt2）；
结果：添加（t）；
}
}
返回结果；
}
公共布尔isTriangle（整数pt1、整数pt2、整数pt3）{
系统输出打印项次（“Pt1，Pt2，Pt3:+Pt1+”：“+Pt2+”：“+Pt3”）；
如果（（pt1+pt2）>pt3&&（pt1+pt3）>pt2&&（pt2+pt3）>pt1）{
System.out.println（“这是三角形”）；
返回Boolean.TRUE；
}
返回Boolean.FALSE；
}
公共数组列表getTri（int[]输入）{
ArrayList结果=新建ArrayList（）；
如果（输入长度<3）{
返回结果；
}
数组。排序（输入）；
对于（int i=0；iinput[k]）{
ArrayList内部=新的ArrayList（）；
添加（输入[i]）；
inner.add（输入[j]）；
inner.add（输入[k]）；
结果：添加（内部）；
k++；
}
}
}
返回结果；
}
公共无效findTriangleW（int[]a）{
HashSet三角形=新HashSet（）；
HashSet-tmp；
for（int i=0；i
如果它已经在工作，可能更适合CodeReview。一个改进是不从方法内部打印到标准输出。返回哈希集。这是一个糟糕的做法
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Arrays;

class Triangle {
    int a;
    int b;
    int c;

    public Triangle(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    @Override
    public String toString() {
        return this.a + " " + this.b + " " + this.c;
    }
}

public class FindTriangle {

    public List<Triangle> findTriangle(List<Integer> points) {
        List<Triangle> result = new ArrayList<Triangle>();
        System.out.println("Entered");

        for (int i = 0; i < points.size(); i++) {
            int pt0 = points.get(i);
            System.out.println("Entered i:" + i);

            for (int j = i + 1; j < points.size() - 2; j++) {
                int pt1 = points.get(j);
                int pt2 = points.get(j + 1);
                Boolean isTri = isTriangle(pt0, pt1, pt2);
                if (isTri.equals(Boolean.TRUE)) {
                    Triangle t = new Triangle(pt0, pt1, pt2);
                    result.add(t);
                }
            }
            for (int j = 0; j < (i - 1) && j > 0; j++) {
                int pt1 = points.get(j);
                int pt2 = points.get(j + 1);
                Boolean isTri = isTriangle(pt0, pt1, pt2);
                if (isTri.equals(Boolean.TRUE)) {
                    Triangle t = new Triangle(pt0, pt1, pt2);
                    result.add(t);
                }
            }

            // final
            int pt1, pt2;
            if (i == 0) {
                pt1 = points.get(i + 1);
                pt2 = points.get(points.size() - 1);
            } else if (i == points.size() - 1) {
                pt1 = points.get(0);
                pt2 = points.get(i - 1);
            } else {
                pt1 = points.get(i + 1);
                pt2 = points.get(i - 1);
            }

            Boolean isTri = isTriangle(pt0, pt1, pt2);
            if (isTri.equals(Boolean.TRUE)) {
                Triangle t = new Triangle(pt0, pt1, pt2);
                result.add(t);
            }
        }
        return result;
    }

    public Boolean isTriangle(Integer pt1, Integer pt2, Integer pt3) {
        System.out.println("Pt1, Pt2, Pt3: " + pt1 + ":" + pt2 + ":" + pt3);

        if ((pt1 + pt2) > pt3 && (pt1 + pt3) > pt2 && (pt2 + pt3) > pt1) {
            System.out.println("This is triangle");
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    public ArrayList<ArrayList<Integer>> getTri(int[] input) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if (input.length < 3) {
            return result;
        }
        Arrays.sort(input);
        for (int i = 0; i < input.length - 2; i++) {
            int k = i + 2;
            for (int j = i + 1; j < input.length; j++) {
                while (k < input.length && input[i] + input[j] > input[k]) {
                    ArrayList<Integer> inner = new ArrayList<Integer>();
                    inner.add(input[i]);
                    inner.add(input[j]);
                    inner.add(input[k]);
                    result.add(inner);
                    k++;
                }
            }
        }
        return result;
    }

    public void findTriangleW(int[] a) {

        HashSet<HashSet<Integer>> triangle = new HashSet<HashSet<Integer>>();
        HashSet<Integer> tmp;
        for (int i = 0; i < a.length; i++) {
            int sum = a[i];
            for (int j = 0; j < a.length; j++) {
                int first = a[j];
                if (first != sum) {
                    for (int k = 0; k < a.length; k++) {
                        int sec = a[k];
                        if (sec != first && sec != sum && (first + sec < sum)) {
                            tmp = new HashSet<Integer>();
                            tmp.add(first);
                            tmp.add(sec);
                            tmp.add(sum);
                            triangle.add(tmp);
                        }
                    }
                }
            }

        }

        for (HashSet<Integer> hs : triangle)
            System.out.println(hs);
    }

    public static void main(String[] args) {
        FindTriangle f = new FindTriangle();
        List<Integer> points = new ArrayList<Integer>();
        points.add(1);
        points.add(5);
        points.add(10);
        points.add(7);

        System.out.println("Printing final results");
        List<Triangle> result = f.findTriangle(points);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i).toString());
        }
    }
}