简单算法的实现——集合

集合论中算法——并、交、差、笛卡尔积

import java.io.*;
import java.util.*;
public class Union {
    public static void main(String[] args) throws IOException{
        int i=0,j=0,k=0;
        Set<Integer> A =new HashSet<Integer>();
        Set<Integer> B =new HashSet<Integer>();
        Set<Integer> C =new HashSet<Integer>();

        System.out.println("请输入集合A、B的元素个数：");
        Scanner s=new Scanner(System.in);
        int m=s.nextInt();
        int n=s.nextInt();
        System.out.println("请输入集合A元素：");
        for(;i<m;i++){
            int a=s.nextInt();
            A.add(a);
        }
        System.out.println("请输入集合B元素：");
        for(;j<n;j++){
            int b=s.nextInt();
            B.add(b);
        }
        System.out.println("集合A中的元素："+A.toString());
        System.out.println("集合B中的元素："+B.toString());
        System.out.print("请输入数字选择集合A、B的运算（1 并集 2 交集 3差集 4 笛卡尔积）：" );

        int x=s.nextInt();
        if(x==1){
                //并集
                C.clear();
                C.addAll(A);
                C.addAll(B);
                System.out.println("并集结果："+C.toString());

            }
            else if(x == 2){
                //交集
                C.clear();
                C.addAll(A);
                C.retainAll(B);
                System.out.println("交集结果："+C.toString());
            }
            else if(x == 3){
                //差集
                C.clear();
                C.addAll(A);
                C.removeAll(B);
                System.out.println("差集结果："+C.toString());

            }
            else if(x==4){
            List<String> list1 = new ArrayList<String>();
            list1.add("a");
            list1.add("b");
            List<String> list2 = new ArrayList<String>();
            list2.add("0");
            list2.add("1");
            list2.add("2");
            List<List<String>> dimValue = new ArrayList<List<String>>();
            dimValue.add(list1);
            dimValue.add(list2);

            // 递归实现笛卡尔积
            Solution sol = new Solution();
            List<List<String>> res = sol.descartes(dimValue);
            System.out.println("递归实现笛卡尔乘积: 共 " + res.size() + " 个结果");
            for (List<String> list : res) {
                for (String string : list) {
                    System.out.print(string + " ");
                }
                System.out.println();
            }


        }
            else return;
        }
    }
    class Solution{
        public List<List<String>> descartes(List<List<String>> dimValue) {
            List<List<String>> res = new ArrayList<>();
            if (dimValue == null || dimValue.size() == 0)
                return res;
            backtrace(dimValue, 0, res, new ArrayList<>());
            return res;

        }
        //递归求解
        //param dimValue 原始数据集合
        //param index 当前执行的集合索引
        //param result 结果集合
        //param curList 当前的单个结果集
        private void backtrace(List<List<String>> dimValue, int index,
                               List<List<String>> result, List<String> curList) {
            if (curList.size() == dimValue.size())
                result.add(new ArrayList<>(curList));
            else
                for (int j = 0; j < dimValue.get(index).size(); j++) {
                    curList.add(dimValue.get(index).get(j));
                    backtrace(dimValue, index + 1, result, curList);
                    curList.remove(curList.size() - 1);
                }

        }
    }