//这个程序是以前用高分求来的,现在稍作修改，呵呵
站在用户的角度思考问题，与客户深入沟通，找到灵武网站设计与灵武网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：网站设计制作、网站制作、企业官网、英文网站、手机端网站、网站推广、申请域名、网络空间、企业邮箱。业务覆盖灵武地区。
public class Zuhe {
public static void main(String[] args) {
String s = "122345";//这里是要用到的所有数组成的一个字符串,其它字符同样适用
char[] c = s.toCharArray();
new Zuhe().zuhe(c,c.length,0);
System.out.println("可能的组合数："+kk);
}
static int kk=0;
private void zuhe(char[] array, int n, int k) {
if (n == k) {
if(array[2]!='4'){//第三个位置不能出现4
String str = new String(array);
if(str.indexOf("53")0str.indexOf("35")0){//3，5不能连续出现
System.out.println(str);
++kk;
}
}
} else {
for (int i = k; i n; i++) {
swap(array, k, i);
zuhe(array, n, k + 1);
swap(array, i, k);
}
}
}
private void swap(char[] a, int x, int y) {
char temp = a[x];
a[x] = a[y];
a[y] = temp;
}
}
========结果=========
122345
122543
123245
123254
123425
123452
125432
125423
125243
125234
122345
122543
123245
123254
123425
123452
125432
125423
125243
125234
132245
132254
132425
132452
132542
132524
132245
132254
132425
132452
132542
132524
142325
142523
143225
143252
143225
143252
142325
142523
145232
145223
145223
145232
152342
152324
152432
152423
152243
152234
152342
152324
152432
152423
152243
152234
212345
212543
213245
213254
213425
213452
215432
215423
215243
215234
221345
221543
223145
223154
223415
223451
225431
225413
225143
225134
232145
232154
232415
232451
232541
232514
231245
231254
231425
231452
231542
231524
242315
242513
243215
243251
243125
243152
241325
241523
245132
245123
245213
245231
252341
252314
252431
252413
252143
252134
251342
251324
251432
251423
251243
251234
221345
221543
223145
223154
223415
223451
225431
225413
225143
225134
212345
212543
213245
213254
213425
213452
215432
215423
215243
215234
231245
231254
231425
231452
231542
231524
232145
232154
232415
232451
232541
232514
241325
241523
243125
243152
243215
243251
242315
242513
245231
245213
245123
245132
251342
251324
251432
251423
251243
251234
252341
252314
252431
252413
252143
252134
322145
322154
322415
322451
322541
322514
321245
321254
321425
321452
321542
321524
325142
325124
325412
325421
325241
325214
322145
322154
322415
322451
322541
322514
321245
321254
321425
321452
321542
321524
325142
325124
325412
325421
325241
325214
312245
312254
312425
312452
312542
312524
312245
312254
312425
312452
312542
312524
315242
315224
315422
315422
315242
315224
342125
342152
342215
342251
342521
342512
341225
341252
341225
341252
341522
341522
342125
342152
342215
342251
342521
342512
345122
345122
345212
345221
345221
345212
422315
422513
423215
423251
423125
423152
421325
421523
425132
425123
425213
425231
422315
422513
423215
423251
423125
423152
421325
421523
425132
425123
425213
425231
432215
432251
432125
432152
432512
432521
432215
432251
432125
432152
432512
432521
431225
431252
431225
431252
431522
431522
412325
412523
413225
413252
413225
413252
412325
412523
415232
415223
415223
415232
452312
452321
452132
452123
452213
452231
451322
451322
451232
451223
451223
451232
452312
452321
452132
452123
452213
452231
522341
522314
522431
522413
522143
522134
523241
523214
523421
523412
523142
523124
521342
521324
521432
521423
521243
521234
522341
522314
522431
522413
522143
522134
523241
523214
523421
523412
523142
523124
521342
521324
521432
521423
521243
521234
542321
542312
542231
542213
542123
542132
543221
543212
543221
543212
543122
543122
542321
542312
542231
542213
542123
542132
541322
541322
541232
541223
541223
541232
512342
512324
512432
512423
512243
512234
513242
513224
513422
513422
513242
513224
512342
512324
512432
512423
512243
512234
可能的组合数：396
import java.util.ArrayList;
import java.util.List;
public class AllSort {
/**
* 从数组中选出所有组合
* @param source
* @param arrayList
* @param num
*/
public static void select(char[] source, ListString arrayList, int num) {
int lg = source.length;
char[] temp = new char[num];
System.arraycopy(source, 0, temp, 0, num);
// 首次填充数组
arrayList.add(new String(temp));
// 逐个(位置)替换方式实现不重复全选
for (int i = num; i lg; i++) {
for (int j = 0; j num; j++) {
char tempChar = temp[j];
temp[j] = source[i];
arrayList.add(new String(temp));
temp[j] = tempChar;
}
}
}
/**
* 全排序
* @param source
* @param start
* @param end
*/
public static void perm(char[] source, int start, int end) {
if (start == end) {// 递归出口，最简单的情况，只取出1个
for (int i = 0; i = end; i++) {
System.out.print(source[i]);
}
System.out.println();
} else {// 多个全排列
for (int i = start; i = end; i++) {
char temp = source;// 逐位交换
source = source[i];
source[i] = temp;
perm(source, start + 1, end);// 递归全排列
// 还原，为下个替换做准备
temp = source;
source = source[i];
source[i] = temp;
}
}
}
public static void main(String[] args) {
//char[] source = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'Aa-Zz...'};
char[] source = { '0', '1', '2', '3', '4','5','6','7','8','9' };
ArrayListString list = new ArrayListString();
for (int i = 1; i = source.length; i++) {
list.clear();
//选出
select(source, list, i);
System.out.println("===========取出"+i+"个==============");
//排列
for (String str : list) {
char[] temp = str.toCharArray();
perm(temp, 0, temp.length - 1);
}
}
}
}
之前在远标java时接触过！
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// 创建Scanner对象，用于获取用户输入
Scanner scanner = new Scanner(System.in);
System.out.print("请输入任意字符序列：");
// 获取用户输入的字符序列
String str = scanner.nextLine();
// 循环遍历字符序列中的每个字符
for (int i = 0; i str.length(); i++) {
// 获取字符序列中的第i个字符
char c1 = str.charAt(i);
// 循环遍历字符序列中的每个字符
for (int j = 0; j str.length(); j++) {
// 获取字符序列中的第j个字符
char c2 = str.charAt(j);
// 如果第i个字符不等于第j个字符，则输出它们的排列
if (i != j) {
System.out.println(c1 + "" + c2);
}
}
}
}
}
完成了一种实现，发给你参考下。
不过感觉应该还有更好的办法，有时间我会继续研究下.
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class TestQiuhe {
//集合a{1，2，3，5，7，10}，输出不多于4个元素（不重复）的加和为22的组合。
public static void main(String[] args) {
int[] nums={1,2,3,5,7,10};
int l = nums.length;
Listint[] results=new ArrayListint[]();
for(int i1=0;i1l;i1++){
for(int i2=0;i2l;i2++){
if(nums[i1]==22){
results.add(new int[]{nums[i1]});
}
if(i2!=i1){
if(nums[i1]+nums[i2]==22){
results.add(new int[]{nums[i1],nums[i2]});
}
for(int i3=0;i3l;i3++){
if(i3!=i1 i3!=i2){
if(nums[i1]+nums[i2]+nums[i3]==22){
results.add(new int[]{nums[i1],nums[i2],nums[i3]});
}
for(int i4=0;i4l;i4++){
if(i4!=i1 i4!= i2 i4!=i3){
if(nums[i1]+nums[i2]+nums[i3]+nums[i4]==22){
results.add(new int[]{nums[i1],nums[i2],nums[i3],nums[i4]});
}
}
}
}
}
}
}
}
//去重
SetString reSet=new HashSet();
for(int[] r:results){
Arrays.sort(r);
reSet.add(Arrays.toString(r));
}
System.out.println("一共得到结果集："+reSet.size());
System.out.println(reSet);
}
}
运行结果：
一共得到结果集：2
[[5, 7, 10], [2, 3, 7, 10]]
char[] a={'1','2','3','4'};
String b= "";
String c= "";
for (int i = 0; i a.length-1; i++) {
b="["+a[i]+","+a[i+1]+"]";
c+=b;
}
System.out.println(c);
import java.util.Arrays;
import java.util.LinkedList;
public class RecursionNArray
{
private static LinkedListchar[] recursionSub ( LinkedListchar[] list, int count, char[][] array, int ind,
int start, int... indexs )
{
start++;
if (start count - 1)
{
return null;
}
if (start == 0)
{
indexs = new int[array.length];
}
for ( indexs = 0; indexs array.length; indexs++ )
{
recursionSub (list, count, array, 0, start, indexs);
if (start == count - 1)
{
char[] temp = new char[count];
for ( int i = count - 1; i = 0; i-- )
{
temp[start - i] = array[start - i][indexs[start - i]];
}
list.add (temp);
}
}
return list;
}
public static void main ( String[] args )
{
char[] a = { '中','国','有','个','人' };
char[] b = { '中','国','有','个','人' };
char[] c = { '中','国','有','个','人' };
char[] d = { '中','国','有','个','人' };
char[][] temp = { a, b, c, d };
LinkedListchar[] list = new LinkedListchar[] ();
recursionSub (list, temp.length, temp, 0, -1);
for ( int i = 0; i list.size (); i++ )
{
System.out.println (Arrays.toString (list.get (i)).replaceAll ("[\\[\\]\\,\\s]", ""));
}
}
}