JAVA组合函数Combination

最新推荐文章于 2023-03-09 22:49:48 发布
最新推荐文章于 2023-03-09 22:49:48 发布
阅读量3.7k 收藏 3
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010157717/article/details/8811923
版权

JDK，Apache commons math里都没有发现组合函数，因而自己写了一个。

首先定义接口

package math.combination;

import java.util.Collection;
import java.util.List;

/**
 * the interface for combination
 * @author jhren
 *
 * @param <T>
 */
public interface Combinationable<T> {
	/**
	 * get combinations from start to end [start, end]
	 * it equals findCombiantions(start),findCombiantions(start+1), 
	 * ......
	 * findCombinations(end-1), findCombinations(end)
	 */
	public List<List<T>> findCombinations(int start, int end);
	/**
	 * get all combinations
	 * it equals findCombinations(0, size)
	 */
	public List<List<T>> findCombinations();
	
	/**
	 * find a combinations for size
	 * @param size
	 * @return
	 */
	public List<List<T>> findCombinations(int size);
	
	public Collection<T> getElements();
}

第一个个实现，输出的组合会按照类型T升序排列

例如输入为[3,2,1]的全组合为

[]
[3]
[2]
[1]
[2, 3]
[1, 3]
[1, 2]
[1, 2, 3]

package math.combination;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * the T should be Comparable the T in one combination list is sort by the
 * Comparable T
 * 
 * @author jhren
 * 
 * @param <T>
 */
public class ComparableCombination<T extends Comparable<? super T>> implements
		Combinationable<T> {

	private Collection<T> elements = new ArrayList<T>();

	public ComparableCombination(Collection<T> elements) {
		this.elements.addAll(elements);

	}

	@Override
	public List<List<T>> findCombinations(int start, int end) {
		if (start < 0) {
			throw new IllegalArgumentException("start can't be negative: "
					+ start);
		}
		if (end > elements.size()) {
			throw new IllegalArgumentException(
					"end can't be larger than elements size: " + end + ">"
							+ elements.size());
		}
		if(start > end) {
			throw new IllegalArgumentException(
					"start can't be larger than end: " + start + ">"
							+ end);
		}
		List<List<T>> result = new ArrayList<List<T>>();

		for (int i = start; i <= end; i++) {
			result.addAll(findCombinations(i));
		}

		return result;
	}

	@Override
	public List<List<T>> findCombinations() {
		return findCombinations(0, elements.size());
	}

	@Override
	public List<List<T>> findCombinations(int size) {
		if (size < 0) {
			throw new IllegalArgumentException("size can't be negative: "
					+ size);
		}
		if (size > elements.size()) {
			throw new IllegalArgumentException(
					"size can't be larger than elements size: " + size + ">"
							+ elements.size());
		}

		List<List<T>> result = new ArrayList<List<T>>();

		if (size == 0) {
			result.add(new ArrayList<T>());
			return result;
		}

		List<List<T>> combinations = findCombinations(size - 1);
		for (List<T> combination : combinations) {
			for (T element : elements) {
				if (combination.contains(element)) {
					continue;
				}

				List<T> list = new ArrayList<T>();

				list.addAll(combination);

				if (list.contains(element))
					continue;

				list.add(element);
				Collections.sort(list);

				if (result.contains(list))
					continue;

				result.add(list);
			}
		}

		return result;

	}

	@Override
	public Collection<T> getElements() {
		return elements;
	}

}

第二个实现，会保持元素的输入顺序

例如输入为[3,2,1]的全组合为

[]
[3]
[2]
[1]
[3, 2]
[3, 1]
[2, 1]
[3, 2, 1]


package math.combination;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;




/**
 * the T in one combination list is sort by the input sequence
 * @author jhren
 *
 * @param <T>
 */
public class CombinationSortByInput<T> implements Combinationable<T> {
	static private class Element<E> implements Comparable<Element<E>> {
		private int rank;
		private E e;

		public E getE() {
			return e;
		}

		private Element(E e, int rank) {
			this.e = e;
			this.rank = rank;
		}

		@Override
		public int compareTo(Element<E> o) {
			return this.rank - o.rank;
		}

	}

	private Combinationable<Element<T>> combination = null;
	public CombinationSortByInput(Collection<T> elements) {
		Collection<Element<T>> elementsInput = convertCollection(elements);
		combination = new ComparableCombination<Element<T>>(elementsInput);
		
	}
	@Override
	public List<List<T>> findCombinations(int start, int end) {
		List<List<Element<T>>> elementsOutput = combination.findCombinations(start, end);
		List<List<T>> output = convertListOfList(elementsOutput);
		return output;
	}

	@Override
	public List<List<T>> findCombinations() {
		return findCombinations(0, combination.getElements().size());
	}

	@Override
	public List<List<T>> findCombinations(int size) {
		return findCombinations(size,size);
	}

	private static <T> Collection<Element<T>> convertCollection(Collection<T> input) {
		Collection<Element<T>> elementCollectionInput = new ArrayList<Element<T>>();
		Iterator<T> iterator = input.iterator();
		int i = 0;
		while(iterator.hasNext()) {
			T t = iterator.next();
			Element<T> element = new Element<T>(t, i++);
			elementCollectionInput.add(element);
		}
		return elementCollectionInput;
	}
	
	private static <T> List<List<T>> convertListOfList(
			List<List<Element<T>>> elementsOutput) {
		List<List<T>> output = new ArrayList<List<T>>();
		for(List<Element<T>> elementList : elementsOutput) {
			List<T> tlist = convertList(elementList);
			output.add(tlist);
		}
		return output;
	}



	private static <T> List<T> convertList(Collection<Element<T>> elementList) {
		List<T> tlist = new ArrayList<T>();
		for(Element<T> element: elementList) {
			T t = element.getE();
			tlist.add(t);
		}
		return tlist;
	}
	@Override
	public Collection<T> getElements() {
		return convertList(combination.getElements());
	}
}

顺便附上TestNG unitestcode 

package math.combination;

import java.util.Arrays;
import java.util.List;

import math.combination.Combinationable;
import math.combination.ComparableCombination;

import org.testng.annotations.Test;
import org.testng.annotations.BeforeClass;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
public class TestComparableCombination {
	private Combinationable<Integer> combination= null;
	@Test
	public void testGetElements() {
		assertNotNull(combination.getElements());
		assertEquals(3, combination.getElements().size());
	}
	
	@Test
	public void testFindCombinationsSizeZero() {
		List<List<Integer>> lists = combination.findCombinations(0);
		assertNotNull(lists);
		assertEquals(1, lists.size());
		assertNotNull(lists.get(0));
		assertEquals(0, lists.get(0).size());
	}
	
	@Test (expectedExceptions = IllegalArgumentException.class)
	public void testFindCombinationsSizeMinus() {
		combination.findCombinations(-1);
		
	}
	
	@Test (expectedExceptions = IllegalArgumentException.class)
	public void testFindCombinationsStartMinus() {
		combination.findCombinations(-1,2);
		
	}
	
	@Test (expectedExceptions = IllegalArgumentException.class)
	public void testFindCombinationsSizeOverflow() {
		combination.findCombinations(combination.getElements().size() + 1);
		
	}
	
	@Test (expectedExceptions = IllegalArgumentException.class)
	public void testFindCombinationsEndOverflow() {
		combination.findCombinations(0,combination.getElements().size() + 1);
		
	}
	
	@Test (expectedExceptions = IllegalArgumentException.class)
	public void testFindCombinationsStartEndWrongOrder() {
		combination.findCombinations(1,0);
		
	}
	
	@Test
	public void testFindCombinationsSizeTwo() {
		List<List<Integer>> lists = combination.findCombinations(2);
		assertNotNull(lists);
		assertEquals(3, lists.size());
		for(List<Integer> list: lists) {
			assertEquals(2, list.size());
			int element0 = list.get(0);
			int elements1 = list.get(1);
			assertTrue(element0 < elements1);
		}
	}
	
	@Test
	public void testFindAllCombinations1() {
		List<List<Integer>> lists = combination.findCombinations();
		assertNotNull(lists);
		assertEquals(8, lists.size());
		
		for(List<Integer> list : lists) {
			System.out.println(list);
		}
	}
	
	@Test
	public void testFindAllCombinations2() {
		List<List<Integer>> lists = combination.findCombinations(0, combination.getElements().size());
		assertNotNull(lists);
		assertEquals(8, lists.size());
	}
	
	@Test(timeOut=20000)
	public void testPerformance() {
		combination = new ComparableCombination<Integer>(Arrays.asList(3,2,1,4,5));
		for(int i = 0;i < 100000; i++) {
			combination.findCombinations();
		}
	}

	@BeforeClass
	public void beforeClass() {
		combination = new ComparableCombination<Integer>(Arrays.asList(3,2,1));
	}

}


package math.combination;

import java.util.Arrays;
import java.util.List;

import math.combination.CombinationSortByInput;
import math.combination.Combinationable;

import org.testng.annotations.Test;
import org.testng.annotations.BeforeClass;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
public class TestCombinationSortByInput {
	private Combinationable<Integer> combination= null;
	@Test
	public void testGetElements() {
		assertNotNull(combination.getElements());
		assertEquals(3, combination.getElements().size());
	}
	
	@Test
	public void testFindCombinationsSizeZero() {
		List<List<Integer>> lists = combination.findCombinations(0);
		assertNotNull(lists);
		assertEquals(1, lists.size());
		assertNotNull(lists.get(0));
		assertEquals(0, lists.get(0).size());
	}
	
	@Test (expectedExceptions = IllegalArgumentException.class)
	public void testFindCombinationsSizeMinus() {
		combination.findCombinations(-1);
		
	}
	
	@Test (expectedExceptions = IllegalArgumentException.class)
	public void testFindCombinationsSizeOverflow() {
		combination.findCombinations(combination.getElements().size() + 1);
		
	}
	
	@Test
	public void testFindCombinationsSizeTwo() {
		List<List<Integer>> lists = combination.findCombinations(2);
		assertNotNull(lists);
		assertEquals(3, lists.size());
		for(List<Integer> list: lists) {
			assertEquals(2, list.size());
			int element0 = list.get(0);
			int elements1 = list.get(1);
			assertTrue(element0 > elements1);
		}
	}
	
	@Test
	public void testFindAllCombinations1() {
		List<List<Integer>> lists = combination.findCombinations();
		assertNotNull(lists);
		assertEquals(8, lists.size());
		
		for(List<Integer> list : lists) {
			System.out.println(list);
		}
	}
	
	@Test
	public void testFindAllCombinations2() {
		List<List<Integer>> lists = combination.findCombinations(0, combination.getElements().size());
		assertNotNull(lists);
		assertEquals(8, lists.size());
	}

	@BeforeClass
	public void beforeClass() {
		combination = new CombinationSortByInput<Integer>(Arrays.asList(3,2,1));
	}
	
	@Test(timeOut=20000)
	public void testPerformance() {
		combination = new CombinationSortByInput<Integer>(Arrays.asList(3,2,1,4,5));
		for(int i = 0;i < 100000; i++) {
			combination.findCombinations();
		}
	}

}


u010157717
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java版排列组合工具类 - Java Permutation and Combination Tools
Code.JAR
08-08 1万+
最近在整理个人代码，有些觉得可能有用的，拿出来共享一下 先上用法示例代码： 问题一： 有三个字符串 "a", "b", "c"，进行排列，列出共有多少种排列方式 public class PNCDemo { public static void main(String[] args) { System.out.println("=====
Java排列组合算法分析和代码实现
10-02
本资源附带文档解释了排列组合算法的实现和原理。其中排列算法是基于递归实现的，组合算法是基于高效的位移法实现的。代码是使用Java版实现的。
java combination_组合模式Combination
weixin_36073654的博客
02-19 579
组合模式Combination一 概述抽象理念：由于事物与事物之间存在某种关系，通过组织起来并形成某种结构并且可以共同发挥作用；组合模式本质：二叉树--根部分出来两个枝杈(左节点，右节点)，每个枝杈上又可以继续分叉，直到末端的叶子为止： 分形理论：不管是连绵的山川、飘浮的云朵、岩石的断裂口、树冠、花菜、还是人类的大脑皮层，把这些部分与整体以某种方式相似的形体呈现出来就称为分形；部分/整体的结构：从...
java 组合_java 全组合 与全排列
weixin_34576446的博客
02-16 370
一、全组合public static voidCombination( ) {/*基本思路：求全组合，则假设原有元素n个，则最终组合结果是2^n个。原因是：* 用位操作方法：假设元素原本有：a,b,c三个，则1表示取该元素，0表示不取。故去a则是001，取ab则是011.* 所以一共三位，每个位上有两个选择0,1.所以是2^n个结果。* 这些结果的位图值都是0,1,2....2^n。所以可以类似...
java 实现排列组合Permutation and Combination和链式不相邻排列组合和环形不相邻排列
CopyCat
10-01 1870
java 实现排列组合的所有情况，是一个常用的工具，为所需要的业务逻辑提供基本的构件
java.combination
03-10
下面是一个使用递归实现的Java组合示例： ```java import java.util.ArrayList; import java.util.List; public class Combination { public static List<List<Integer>> combine(int[] nums, int k) { List...
java从n个数组中取出所有的组合
06-22
2. **递归函数**：设计一个递归函数，接受当前组合（初始为空）和剩余的数组列表。 3. **基本情况**：如果所有数组都被遍历过，则将当前组合添加到结果列表中。 4. **递归步骤**：对于每个未处理的数组，选择一个...
lettercombination:DFS解决字母组合问题
03-30
标题中的"lettercombination:DFS解决字母组合问题"指的是在编程领域中使用深度优先搜索（Depth-First Search，简称DFS）算法来生成特定字符集（通常是字母）的所有可能组合。在这个问题中，通常是为了找到电话号码上...
【Java】阶乘和组合数.zip
02-08
在Java中，我们可以直接使用阶乘函数来计算组合数： ```java public class Combination { public static int combination(int n, int k) { return factorial(n) / (factorial(k) * factorial(n - k)); } } ``` ...
Leetcode 77. 组合 Combinations 回溯法 Java
rendalian的博客
03-09 163
剪枝需要记住一个公式，n - ( k-path.size() ) + 1，其中括号内的内容为还需要几个数字才能满足k。需要一个startIndex变量记录下一层for循环应该从哪里开始；n为1234，即树的宽度；每一次递归函数都是一个for循环；
combination
03-22
排列组合01法的Java实现，实现基于字典排序的结果输出
经典java组合算法源码--TryCombination(算法源码)
01-14
package com.hexiang.utils.arrange; public class TryCombination{ public static void main(String[] args){ System.out.println("对整数数组进行组合:C(n,n)"); int[] intArray=new int[4]; for(int i=0;i<intArray.length;i++){ intArray[i]=i+1; } System.out.println("对整数数组进行组合:C(4,4)"); Combination intCombination1=new Combination(intArray.length); while(intCombination1.hasMore()){ int[] index=intCombination1.getNext(); for(int i=0;i<intArray.length;i++){ if(index[i]!=0){ System.out.print(intArray[index[i]*i]+" "); } } System.out.println(); } System.out.println("对整数数组进行组合:C(4,3)"); Combination intCombination2=new Combination(intArray.length,3); while(intCombination2.hasMore()){ int[] index=intCombination2.getNext(); for(int i=0;i<intArray.length;i++){ if(index[i]!=0){ System.out.print(intArray[index[i]*i]+" "); } } System.out.println(); } String str="abcd"; char[] chArray=str.toCharArray(); System.out.println("对字符数组进行组合:C(4,4)"); Combination strCombination1=new Combination(chArray.length); while(strCombination1.hasMore()){ int[] index=strCombination1.getNext(); for(int i=0;i<chArray.length;i++){ if(index[i]!=0){ System.out.print(chArray[index[i]*i]+" "); } } System.out.println(); } System.out.println("对字符数组进行组合:C(4,3)"); Combination strCombination2=new Combination(chArray.length,3); while(strCombination2.hasMore()){ int[] index=strCombination2.getNext(); for(int i=0;i<chArray.length;i++){ if(index[i]!=0){ System.out.print(chArray[index[i]*i]+" "); } } System.out.println(); } } }
combinations java_77. Combinations
weixin_39871162的博客
02-15 121
题目描述(中等难度)给定 n ，k ，表示从 { 1, 2, 3 … n } 中选 k 个数，输出所有可能，并且选出数字从小到大排列，每个数字只能用一次。解法一 回溯法这种选数字很经典的回溯法问题了，先选一个数字，然后进入递归继续选，满足条件后加到结果中，然后回溯到上一步，继续递归。直接看代码吧，很好理解。publicList>combine(intn,intk){List>ans=n...
每日一题@52组合
iMark
10-07 249
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。 示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/combinations 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 写了这么久的回溯 还是不会写 继续抄 不行不行 class Sol
combinations java_生成所有可能的組合 - Java [重復]
weixin_39709674的博客
02-15 150
This question already has an answer here:這個問題在這里已有答案:I have a list of items {a,b,c,d} and I need to generate all possible combinations when,我有一個項目列表{a,b,c,d},我需要生成所有可能的組合,you can select any number of ...
【LeetCode-面试算法经典-Java实现】【077-Combinations（组合数）】
https://github.com/Wang-Jun-Chao
07-30 3144
【077-Combinations（组合数）】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题　　Given two integers n and k, return all possible combinations of k numbers out of 1 … n. 　　For example, 　　If n = 4 and k = 2, a solution is
77. Combinations (java 求C(n,k)的组合，排除重复元素)
weixin_34268843的博客
08-13 147
题目： Given two integersnandk, return all possible combinations ofknumbers out of 1 ...n. 解析：同求全部组合的过程一样，只是这里限制每个组合中元素的个数为k，求所有组合时并不限制元素个数。 若要排除重复的元素，则首先对所有元素进行排序。 代码： publi...
用java实现combin函数_【算法-Java实现】组合总和
weixin_33514277的博客
02-16 461
【算法-Java实现】组合总和一.问题描述：给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的数字可以无限制重复被选取。比如：输入：[2,3,6,7]；输出：[[7], [2, 2, 3]]输入：[3,4,5,6,7,8,9]；输出：[[8], [4, 4], [3, 5]...
(java)Combinations
martinmateng的博客
01-09 468
Given two integers n and k, return all possible combinations of k numbers out of 1 ... n. For example, If n = 4 and k = 2, a solution is: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]
java排列组合代码实现
最新发布
06-08
其中，`permutation`和`combination`函数分别计算排列数和组合数，`permutation`函数使用阶乘实现，`combination`函数使用排列数实现。 `permutation`函数使用递归实现全排列，`swap`函数用于交换数组中两个元素的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值