好吧，承认标题有点绕，文字不太好描述，还是举例吧，
比如我们知道字符串1234的全排列有4！=24种，把24种排列按字典顺序排列如下：
1234 1
1243 2
1324 3
1342 4
1423 5
1432 6
2134 7
2143 8
2314 9
2341 10
2413 11
2431 12
3124 13
3142 14
3214 15
3241 16
3412 17
3421 18
4123 19
4132 20
4213 21
4231 22
4312 23
4321 24
那么问题来了，求某算法或思路，满足根据序号求排列，
比如给出20,怎么得出4132，给出13，怎么得出3124
解答如下：
public class ChoiceDict {
public static void main(String[] args) {
ChoiceDict a = new ChoiceDict();
int count = 4;//输入元素个数按照 1234
int choice=13;
int[] p = new int[count];
for (int i = 1; i <= p.length; i++) {
p[i - 1] = i;
}
boolean con;
// long start=System.currentTimeMillis();
do {
if(choice--==0)
a.pr(p);// 输出排列
con = a.next(p);// 求出按字典序排列的下一个排列p
} while (con);
//System.out.println(System.currentTimeMillis()-start);
}
public int indexof(int[] n) {
int index = -1;
for (int i = n.length - 1; i >= 1; i--) {
if (n[i - 1] < n[i]) {
index = i - 1;
break;
}
}
return index;
}
public int indexmin(int ini, int[] n) {
int index = n.length - 1;
int min = n[ini + 1];
for (int i = ini + 1; i < n.length; i++) {
if (n[i] <= min && n[i] > n[ini]) {
min = n[i];
index = i;
}
}
return index;
}
public void swap(int index1, int index2, int[] n) {
int temp;
temp = n[index1];
n[index1] = n[index2];
n[index2] = temp;
}
public void oppositeDirection(int index1, int[] n) {
for (int i = index1 + 1, j = n.length - 1, k = 0, temp; k <= (n.length - i) / 2; i++, j--, k++) {
temp = n[i];
n[i] = n[j];
n[j] = temp;
}
}
public boolean next(int[] n) {
int index1 = indexof(n);
if (index1 == -1) {
return false;
}
int index2 = indexmin(index1, n);
swap(index1, index2, n);
oppositeDirection(index1, n);
return true;
}
public void pr(int[] n) {
for (int i = 0; i < n.length; i++) {
System.out.print(n[i] + " ");
}
System.out.println();
}
}
js实现方法
getNum(bits, index)
1. 0 < bits < 10
2. index > 0
3. 所有不合理的结果都返回 -1
example:
getNum(4, 2);
getNum(5, 11);
在浏览器控制台 即可测试
function getNum(bits, index)
{
if(index <= 0 || bits < 1 || bits > 9)
{
alert("out of list");
return -1;
}
var nums =[];
var steps =[];
var j=1;
var i;
var tem=1;
var result = [];
for( i= bits; i>0; i--)
{
tem= tem *j;
j++;
if(index >= tem)
{
steps.push(tem);
nums.push(i);
}
else
{
break;
}
}
if(index > tem)
{
alert("out of list");
return -1;
}
for(var k= 1; k<=i;k++)
{
result.push(k);
}
for(var m= steps.length-1; m>=0; m--)
{
var times = parseInt(index/steps[m]);
index = index%steps[m];
if(index ==0)
{
if(times== 1)
{
for( var v=0; v< nums.length; v++)
{ result.push(nums[v]); }
}
else if(times >1)
{
for(var bb=nums.length -1; bb >=0; bb--)
{
if(times == 2)
{
var ttt = result[result.length-1];
result[result.length-1] = nums[bb];
nums[bb] = ttt;
break;
}
else
{
times--;
}
}
nums.sort(function(m, n){return m-n;}).reverse();
for( var vv=0; vv< nums.length; vv++)
{ result.push(nums[vv]); }
}
break;
}
else if(index >0)
{
if(times ==0)
{
result.push(nums[nums.length-1]);
nums.pop();
}
else if(times >0)
{
for(var b=nums.length -1; b >=0; b--)
{
if(times == 1)
{
var tt = result[result.length-1];
result[result.length-1] = nums[b];
nums[b] = tt;
break;
}
else
{
times--;
}
}
// result[result.length-1] += times;
// nums[nums.length -1 -times+1] -= times;
nums.sort(function(m, n){return m-n;}).reverse();
result.push(nums[nums.length-1]);
nums.pop();
}
}
}
return parseInt(result.join(""));
}
