哪位高手帮我用JAVA写几行代码啊？急求？
请你用Java解决下面的问题：
1） 对于输入的任意自然数n，作排列组合显示
如输入3，则应打印出
1-> 2-> 3
1-> 3-> 2
2-> 1-> 3
2-> 3-> 1
3-> 1-> 2
3-> 2-> 1
哪位大哥大姐帮帮小弟呀，实在是写不出来代码啊？
[解决办法]
網上找的:
import java.math.*;
public class nest
{
private int[] a;
private BigInteger numLeft;
private BigInteger total;
// -----------------------
// Constructor. WARNING: Don 't make n too large.
// Recall that the number of permutations is n!
// which can be very large, even when n is as small as 20 --
// 20! = 2,432,902,008,176,640,000 and
// 21! is too big to fit into a Java long, which is
// why we use BigInteger instead.
// ----------------------
public nest(int n)
{
if (n < 1)
{
throw new IllegalArgumentException( "Min 1 ");
}
a = new int[n];
total = getFactorial(n);
reset();
}
// ------
// Reset
// ------
public void reset()
{
for (int i = 0; i < a.length; i++)
{
a[i] = i;
}
numLeft = new BigInteger(total.toString());
}
// ------------------------------------------------
// Return number of permutations not yet generated
// ------------------------------------------------
public BigInteger getNumLeft()
{
return numLeft;
}
// ------------------------------------
// Return total number of permutations
// ------------------------------------
public BigInteger getTotal()
{
return total;
}
// -----------------------------
// Are there more permutations?
// -----------------------------
public boolean hasMore()
{
return numLeft.compareTo(BigInteger.ZERO) == 1;
}
// ------------------
// Compute factorial
// ------------------
private static BigInteger getFactorial(int n)
{
BigInteger fact = BigInteger.ONE;
for (int i = n; i > 1; i--)
{
fact = fact.multiply(new BigInteger(Integer.toString(i)));
}
return fact;
}
// --------------------
// Generate next permutation (algorithm from Rosen p. 284)
// --------------------
public int[] getNext()
{
if (numLeft.equals(total))
{
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
int temp;
// Find largest index j with a[j] < a[j+1]
int j = a.length - 2;
while (a[j] > a[j + 1])
{
j--;
}
// Find index k such that a[k] is smallest integer
// greater than a[j] to the right of a[j]
int k = a.length - 1;
while (a[j] > a[k])
{
k--;
}
// Interchange a[j] and a[k]
temp = a[k];
a[k] = a[j];
a[j] = temp;
// Put tail end of permutation after jth position in increasing order
int r = a.length - 1;
int s = j + 1;
while (r > s)
{
temp = a[s];
a[s] = a[r];
a[r] = temp;
r--;
s++;
}
numLeft = numLeft.subtract(BigInteger.ONE);
return a;
}
public static void main(String[] args)
{
int[] indices;
String[] elements =
{ "1-> ", "2-> ", "3-> ", "4-> ", "5-> " };
nest x = new nest(elements.length);
StringBuffer permutation;
int xx = 0;
while (x.hasMore())
{
permutation = new StringBuffer();
indices = x.getNext();
for (int i = 0; i < indices.length; i++)
{
permutation.append(elements[indices[i]]);
}
System.out.print(permutation.toString().substring(0, permutation.toString().lastIndexOf( "- ")) + "\t ");
xx++;
if (xx % 10 == 0)
System.out.println();
}
}
}
[解决办法]
簡單點的:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class StringTest
{
private int count = 0;
public void permutation(String a[], int m, int n)
{
int i;
String t;
if (m < n - 1)
{
permutation(a, m + 1, n);
for (i = m + 1; i < n; i++)
{
t = a[m];
a[m] = a[i];
a[i] = t;
permutation(a, m + 1, n);
t = a[m];
a[m] = a[i];
a[i] = t;
}
} else
{
StringBuffer sb = new StringBuffer();
for (String test : a)
{
sb.append(test+ "-> ");
}
System.out.print(sb.toString().substring(0,sb.toString().lastIndexOf( "- ")));
System.out.print( "\t ");
count++;
if(count%n==0)
{
System.out.println();
count%=n;
}
}
}
public void printf()
{
int n = 0;
System.out.println( "請輸入正整數: ");
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String line = null;
try
{
while ((line = bufferedReader.readLine()) != null)
{
if(line.equalsIgnoreCase( "exit "))
break;
try
{
n = Integer.parseInt(line);
String[] strings = new String[n];
for(int i=0;i <n;i++)
strings[i] = String.valueOf(i+1);
permutation(strings,0,n);
} catch (NumberFormatException nfe)
{
System.err.println( "請正確輸入! ");
}
}
} catch (IOException e)
{
e.printStackTrace();
}
}
public static void main(String args[])
{
new StringTest().printf();
}
}
[解决办法]
str=[1,2,3,4];
len=str.size();
def roat(j){
def f=str[j];
for(i in j.. <len-1){
str[i]=str[i+1];
}
str[-1]=f;
}
def test1(j){
if(j==len-1) return ;
for(i in j.. <len){
test1(j+1)
if(len-j==2){
display();
}
roat(j);
}
}
def display(){
str.eachWithIndex{x,y ->
if(y==len-1){
print x
}else
print x+ "-> "
}
println " "
}
test1(0)
1-> 2-> 3-> 4
1-> 2-> 4-> 3
1-> 3-> 4-> 2
1-> 3-> 2-> 4
1-> 4-> 2-> 3
1-> 4-> 3-> 2
2-> 3-> 4-> 1
2-> 3-> 1-> 4
2-> 4-> 1-> 3
2-> 4-> 3-> 1
2-> 1-> 3-> 4
2-> 1-> 4-> 3
3-> 4-> 1-> 2
3-> 4-> 2-> 1
3-> 1-> 2-> 4
3-> 1-> 4-> 2
3-> 2-> 4-> 1
3-> 2-> 1-> 4
4-> 1-> 2-> 3
4-> 1-> 3-> 2
4-> 2-> 3-> 1
4-> 2-> 1-> 3
4-> 3-> 1-> 2
4-> 3-> 2-> 1
groovy程序
