Anagrams 字符串回文组合 cyber-dojo 编程操练

最新推荐文章于 2024-06-11 09:46:05 发布

原创最新推荐文章于 2024-06-11 09:46:05 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Anagrams 字符串回文组合 cy

本文介绍了一种使用Java实现字符串所有可能的全排列的方法。通过自定义的Letter类和LetterHandler辅助类，实现了字符串的拆分与重组，最终生成了输入字符串的所有全排列组合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是编程操练的一道题目。题目是：

Write a program to generate all potential
anagrams of an input string.

For example, the potential anagrams of "biro" are

biro bior brio broi boir bori
ibro ibor irbo irob iobr iorb
rbio rboi ribo riob roib robi
obir obri oibr oirb orbi orib

接下来是我的编程实现，这是我设计与重构的最后版本，或许还会重构，我会发布到Github网站上，这是链接，欢迎一起讨论。https://github.com/Blue-Child/Anagrams

Letter类：

//单词或字母
public class Letter {
	
	private String content;
	
	public Letter(String content) {
		this.content = content;
	}
	
	@Override
	public String toString() {
		return this.getContent();
	}

	public String getContent() {
		return content;
	}

	
}

LetterHandler类：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//letter的协助类
public class LetterHandler {

	//处理字符串，得到回文字符串组合(形式：分隔+组合)
	public static Map<String, Letter> handler(String anagram) {
		List<Letter> letterList = split(anagram);
		Map<String, Letter> letterMap = composite(letterList);
		return letterMap;
	}

	//分隔字符串
	private static List<Letter> split(String anagram) {
		List<Letter> letterList = new ArrayList<Letter>();
		for (int i = 0; i < anagram.length(); i++) {
			char c = anagram.charAt(i);
			Letter letter = new Letter(c + "");
			letterList.add(letter);
		}
		return letterList;
	}
	
	//排列组合字符串回文
	private static Map<String, Letter> composite(List<Letter> letterList) {
		Map<String, Letter> letterMap = new HashMap<String, Letter>();
		recComposite(letterList, letterMap, "", new int[]{});
		return letterMap;
	}
	
	//递归组合字符串回文
	private static void recComposite(List<Letter> letterList, Map<String, Letter> letterMap, String beforeStr, int[] targetIndex) {
		for (int k = 0; k < letterList.size(); k++) {
			String composite = "";
			if (!isContainSameIndex(k, targetIndex)) {
				composite = beforeStr + letterList.get(k);  
				if (isTheLastChar(targetIndex, letterList)) {
					addToMap(letterMap, composite);
					break;
				} else {
					int[] targetIndexs = appendTargetIndexs(k, targetIndex);
					recComposite(letterList, letterMap, composite, targetIndexs);
				}
			} else {
				continue;
			}
		}
	}

	//判断下标是否一样
	private static boolean isContainSameIndex(int sourceIndex, int... targetIndex) {
		for (int i = 0; i < targetIndex.length; i++) {
			int target = targetIndex[i];
			if (sourceIndex == target) {
				return true;
			}
		}
		return false;
	}

	//判断是否是最后一个字符
	private static boolean isTheLastChar(int[] targetIndex, List<Letter> letterList) {
		return (targetIndex.length + 1) == (letterList.size());
	}
	
	//将字符串排列结果添加到map中
	private static void addToMap(Map<String, Letter> letterMap, String composite) {
		letterMap.put(composite, new Letter(composite));
	}
	
	//组转下标数组
	private static int[] appendTargetIndexs(int beforeIndex, int[] targetIndex) {
		int[] targetIndexs = new int[targetIndex.length + 1];
		targetIndexs[0] = beforeIndex;
		for (int i = 0; i < targetIndex.length; i++) {
			targetIndexs[i + 1] = targetIndex[i];
		}
		return targetIndexs;
	}
	
	//展示
	public static void show(Map<String, Letter> letterMap) {
		int n = 0;
		for (String key : letterMap.keySet()) {
			Letter letter = letterMap.get(key);
			System.out.print(letter.toString() + "	");
			if ((++n % 6) == 0) {
				System.out.println();
			}
		}
	}
}

LetterTest测试类：

import java.util.Map;

import org.junit.Test;

public class LetterTest {
	
	@Test
	public void testAnagramWithFour() {
		String anagram = "biro";
		Map<String, Letter> letterMap = LetterHandler.handler(anagram);
		LetterHandler.show(letterMap);
	}
	
	@Test
	public void testAnagramWithFourHasSameLetter() {
		String anagram = "bibo";
		Map<String, Letter> letterMap = LetterHandler.handler(anagram);
		LetterHandler.show(letterMap);
	}
	
	@Test
	public void testAnagramWithFive() {
		String anagram = "biroe";
		Map<String, Letter> letterMap = LetterHandler.handler(anagram);
		LetterHandler.show(letterMap);
	}
}

总结：不断的进行编程操练，可以巩固设计方面和重构方面的知识，提高编程设计能力。