小算法，求一个数列的全排列

with t as
(select '1' from dual union all
select '5' from dual union all
select '6' from dual)
select * from t t1,t t2,t t3
SQL给出的，算不？

public class TestA {

public static void main(String[] args){
int a[] = {1,5,6};
int b[] = new int[10];
allArr(3, 3, a, b);

}
public static void allArr(int n, int sum, int[] a, int[] b){
int i,j;
int sign; //标记是否选择重复的
if(n==0)
{
for(i=sum-1;i>=0;i--)
System.out.print(b[i]);
System.out.println();
}
else
for(i=0;i<sum;i++)
{
sign=1;
for(j=sum-1;j>=n;j--)
{
if(b[j]==a[i])
{
sign=0;
break;
}
}
if(sign==1)
{
b[n-1]=a[i];
allArr(n-1,sum,a,b);
}

}
}
}

public class PermuteTest {
public static void main(String[] args) {
char[] a = {'1', '5', '6'};
permute(a, 0, a.length-1);
} static void swap(char[] a, int i, int j) {
char tmp = a[i];
a[i] = a[j];
a[j] = tmp;
} static void permute(char[] a, int start, int end) {
if(start == end)
System.out.println(new String(a));
else {
for(int i=start; i<=end; i++) {
swap(a, start, i);
permute(a, start+1, end);
swap(a, start, i);
}
}
}
}

import java.util.*;public class TestFullArrangement {
    public static void main(String[] args) {
ArrayList<Integer> integers = new ArrayList<Integer>();
integers.add(1);
integers.add(5);
integers.add(6);
ArrayList<ArrayList<Integer>> result = getFullArrangement(integers);
for (int i = 0; i < result.size(); i++) {
    System.out.println(result.get(i));
}
    }    static ArrayList<ArrayList<Integer>> getFullArrangement(
    ArrayList<Integer> integers) {
if (integers == null)
    return null; ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();//存放返回的各张表
if (integers.size() == 1) {
    ArrayList<Integer> tempIntegers = new ArrayList<Integer>();
    tempIntegers.add(integers.get(0));
    result.add(tempIntegers); } else {
    for (int i = 0; i < integers.size(); ++i) {
Integer integer = integers.get(i); //新建表存放剩余的元素
ArrayList<Integer> tempIntegers = new ArrayList<Integer>();
tempIntegers.addAll(integers);
tempIntegers.remove(i);

//递归获取结果
ArrayList<ArrayList<Integer>> d = getFullArrangement(tempIntegers); for (int j = 0; j < d.size(); j++) {
    d.get(j).add(integer);//尾部添加一个
    result.add(d.get(j));//添加到将每张表result中
}
    }
}
return result;
    }}

package com.meran.perm;import java.util.Arrays;public class AllArray {
public static void handle(int [] a,int p,int n){
if(p<n){
for(int i=p;i<=n;i++){
swap(a,p,i);
handle(a,p+1,n);
swap(a,p,i);
}
}
if(p==n){
print(a);
}
}
public static void print(int [] a){
System.out.println(Arrays.toString(a));
}
public static void swap(int [] a,int f,int t) {
int temp =a[f];
a[f]=a[t];
a[t]=temp;

}
public static void main (String [] args){
int [] a ={1,2,3,4};
AllArray.handle(a, 0, 3);
}
}

import java.util.ArrayList;public class AllArr {
public static void main(String args[]){
int a[] = {1, 5, 6};
allArr(a);
}

public static void allArr(int[] a){
ArrayList<Integer> arrList;
for(int i=0; i<a.length; i++){
for(int j=0; j<a.length;j++){
if(i==j) continue;
for(int k=0; k<a.length; k++){
if(i==k||j==k) continue;
int num = 100*a[i] + 10*a[j] + a[k];
System.out.println(num);
}
}
}
}
}水平有限，只能实现三个数的

import java.util.Scanner;
public class PaiLieTest
{
public static void main(String args[])
{
Scanner input = new Scanner(System.in);
int i,j,k;
System.out.println("Enter number:");
i = input.nextInt();
System.out.println("Enter number:");
j = input.nextInt();
System.out.println("Enter number:");
k = input.nextInt();
System.out.printf("%d%d%d\n",i,j,k);
System.out.printf("%d%d%d\n",i,k,j);
System.out.printf("%d%d%d\n",j,i,k);
System.out.printf("%d%d%d\n",j,k,i);
System.out.printf("%d%d%d\n",k,j,i);
System.out.printf("%d%d%d\n",k,i,j);
}
}
刚学java 只能实现三个数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
/*
* 这道题要仔细考虑怎么循环了
*/
namespace ArrayInput
{
    public  class ArrayInput
    {
        public static int count;
        public static void Main(string[] args)
        {
            Console.WriteLine("请输入字符串：");
            string input = Console.ReadLine();
            Console.WriteLine("------输出-------");
            displayArray("",input);
            Console.WriteLine("\n-------总数-------");
            Console.WriteLine("\t"+count);
            Console.ReadLine();
        }        public static void displayArray(string s)
        {
            displayArray("",s);
        }        public static void displayArray(string s1, string s2)
        {
            if (s2.Trim()=="")
            {
                Console.WriteLine(s1.Trim());
                count++;
            }
            else
            {
                StringBuilder sb = null;
                for (int i = 0; i < s2.Length; i++)
                {
                    sb = new StringBuilder(s2);
                    string first = s1 + sb.ToString().Substring(i,1);
                    displayArray(first, sb.Remove(i, 1).ToString());
                }
            }
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;public class SortDemo { public static void main(String[] args) {
StringBuilder s  = new StringBuilder();
ArrayList<Integer> list = new ArrayList<Integer>();
Set<Integer>  temp = new HashSet<Integer>();

System.out.println("请输入数字：");
while(true){
Scanner console = new Scanner(System.in);
list.add(console.nextInt());
if(list.size()==3){
break;
}
}   //用来获得输入所要进行运算的数列例（1,5,6），将所有元素都存放到list中

Random ran = new Random();
int length = list.size();
int sum = 1;
for(int i=1;i<=length;i++){
sum *= i;
}//获得目标数列元素能组成的所有数字数量

while(true){
ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.addAll(list);
for(int j=0;j<length;j++){
int n =list1.size();
// System.out.println(list1);
if(n==0){
break;
}
s.append(list1.remove(ran.nextInt(n)));
}//从list1中随机获取一个元素将其放入s中，remove方法保证不会取到重复元素
//for循环结束s中得到一个完整的组合数
//System.out.println("s"+s);

temp.add(Integer.parseInt(s.toString()));//将s中得这个元素转换成int放入temp中
s.delete(0, s.length());//清空s 继续循环
if(temp.size() == sum){
break;
}//set保证temp中不会有重复元素,当temp拿到所有组合数后跳出循环
}
List<Integer> x = new ArrayList<Integer>();
for(Integer b: temp){
x.add(b);
}
Collections.sort(x);//排序
System.out.println(x);//输出排序后的Array
}
}这个试了试结果正确新手想不出啥简单的方法

package com.cn;/**
* 这个可以画一个树来表示每一次去哪一个，然后层层递归。
* @author Administrator
*
*/
public class Composite {
public static void main(String[] args) {
int[] a = new int[] { 1, 2, 3 ,4};
boolean[] b = new boolean[a.length];
for (int i = 0; i < b.length; i++) {
b[i] = true;
}
int[] c = new int[a.length];
print(a, b, c, 0);
} private static void print(int[] a, boolean[] b, int[] c, int g) {

for (int i = 0; i < a.length; i++) {
if (b[i] != false) {
b[i] = false;//表示这一个已经取过了
boolean[] bool = new boolean[b.length];
for (int y = 0; y < b.length; y++) {
bool[y] = b[y];//新生成一个标记传给下一层递归表示在该层i已经使用过了，那么下一层就只能取别的了。
}
b[i] = true;
c[g] = a[i];
print(a, bool, c, g+1);
}
}
//下面表示已经递归到最后一层了，全部都为false了，现在就打印。
int k = 0;
for (int i = 0; i < b.length; i++) {
if (true == b[i]) {
k++;
}
}
if (k == 0) {
for (int i = 0; i < c.length; i++) {
System.out.print(c[i]);
}
System.out.println();
return;
}
}
}

public static void main(String[] args) {
        int[] a = new int[] { 1, 2, 3 ,4};
        boolean[] b = new boolean[a.length];
        for (int i = 0; i < b.length; i++) {
            b[i] = true;
        }
        int[] c = new int[a.length];
        print(a, b, c, 0);
    }    private static void print(int[] a, boolean[] b, int[] c, int g) {

        for (int i = 0; i < a.length; i++) {
            if (b[i] != false) {
                b[i] = false;//表示这一个已经取过了
                boolean[] bool = new boolean[b.length];
                for (int y = 0; y < b.length; y++) {
                    bool[y] = b[y];//新生成一个标记传给下一层递归表示在该层i已经使用过了，那么下一层就只能取别的了。
                }
                b[i] = true;
                c[g] = a[i];
                print(a, bool, c, g+1);
            }
        }
        //下面表示已经递归到最后一层了，全部都为false了，现在就打印。
        int k = 0;
        for (int i = 0; i < b.length; i++) {
            if (true == b[i]) {
                k++;
            }
        }
        if (k == 0) {
            for (int i = 0; i < c.length; i++) {
                System.out.print(c[i]);
            }
            System.out.println();
            return;
        }
    }

public class PermutCombi {
public static void main(String[] args){
int[] num = {1, 5, 6};
int[] = {0, 0, 0, 0};
int i, j;
while([3] <= 0){
++[0];
for(i = 0; i < 3; ++i){
if([i] == 3){
[i] = 0;
++[i+1];
}
}
if([0] == [1] || [0] == [2] || [1] == [2])
continue;
for(i = 0; i < 3; ++i)
System.out.print(num[[i]] + " ");
System.out.println();
}
}
}

楼主看一下计算机算法，在递归那里有这个题，下面的是我用C++写的楼主自己看看改一下，不懂可以去我空间留言
#include<iostream>
using namespace std;void perm(int list[],int k,int m)
{
if(k==m)
{
for(int i = 0;i<=m;i++)
cout<<list[i];
cout<<endl;
}
else
for(int i = k;i<=m;i++)
{
swap(list[k],list[i]);
perm(list,k+1,m);
swap(list[k],list[i]);
}
}inline void swap(int &a,int &b)
{
int temp;
temp = a;
a = b;
b = temp;
}
int main()
{
int list[]={1,2,3};
perm(list,0,2); return 0;}

CSDN这么强大啊，好多程序罗列啊。我要好好学习啦。

//这个怎么越看越像 #6 的
    public static void main(String[] args) {
        Object[] t = {1, '5', "6"};
        start(t);
    }    /**递归初始化*/
    static <T> void start(T[] keys) {
        int indexs[] = new int[keys.length];
        for (int i = 0; i < keys.length; i++) {
            indexs[i] = i;
        }
        op(indexs, keys, 0);
    }    /**递归*/
    private static <T> void op(int[] indexs, T[] keys, int post) {
        if (post < indexs.length) {
            for (int i = post; i < indexs.length; i++) {
                //交换
                int sw = indexs[i];
                indexs[i] = indexs[post];
                indexs[post] = sw;                op(indexs, keys, post + 1);                //还原
                sw = indexs[i];
                indexs[i] = indexs[post];
                indexs[post] = sw;
            }
        } else {
            print(indexs, keys);
        }
    }    /**打印*/
    static <T> void print(int[] indexs, T[] keys) {
        for (int i = 0; i < indexs.length; i++) {
            System.out.print(keys[indexs[i]]);
        }
        System.out.println();
    }

post 是当前的位置for (int i = post; i < indexs.length; i++) {
是当前位置可以选择的值，有indexs.length-post 个，全排列，每个都要，所以用个for循环，然后再递归一下

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;/**
* 生成数据全排列
* @author LCF
*
*/
public class QuanPaiLie {
/**
* 生成全排列的递归调用方法
* @param listInt 所要生成全排列的数据
* @param set 判断数据是否被占用的集合
* @param str 生成元素的半成品完成后放入listStr
* @param listStr 存放结果的集合
*/
private void qpl(List<Integer> listInt ,Set<Integer> set,String str,List<String> listStr){
if(str.length()==listInt.size()){
listStr.add(str);
}else{
for(int i = 0;i<listInt.size();i++){
if(!set.contains(i)){
int num = listInt.get(i);
String str1 = str+num;
set.add(i);
qpl(listInt,set,str1,listStr);
set.remove(i);
}
}
}
}
/**
* 重写qpl方法简化接口
* @param listInt
* @return
*/
public List<String> qpl(List<Integer> listInt){
List<String> listStr  = new LinkedList<String>();
Set<Integer> set = new HashSet<Integer>();
qpl(listInt, set, "", listStr);
return listStr;
}
/**
* @param args
*/
public static void main(String[] args) {
List<Integer> listInt  = new ArrayList<Integer>();
listInt.add(5);
listInt.add(6);
listInt.add(7);
listInt.add(8);

QuanPaiLie q  = new QuanPaiLie();

System.out.println(q.qpl(listInt));

}}

调试易

小算法，求一个数列的全排列

解决方案 »