"100"<"1000"..(加引號的目的是為了區別數字..與數字串..)
事實上呢.在計算機里...我們會這么看..和之前一樣...我們會首先比較第一個字元...
這裡"1"="1"..(已經可以看到區別了..在數中..數字因為位置的不同會有不同的意義..而這裡.這種分別變的不一樣了...)
..一步比較...還沒有辦法分辨出它們的大小...只好再比較之後的數...
這種情況回直到最後一次嘗試...第一個字元串已經空掉之前...
如果硬要比較的話...
空格的ascii碼值是32.(Ascii碼還是用兩位十六進制表示比較合適)
‘0’的ASCII碼值是48 所以‘100’<'1000'
例子：依次比字母, 如boat < boot <
cap < card < cat < to < too< two < up
字典序法
對於數字1、2、3......n的排列，不同排列的先後關係是從左到右逐個比較對應的數字的先後來決定的。例如對於5個數字的排列 12354和12345，排列12345在前，排列12354在後。按照這樣的規定，5個數字的所有的排列中最前面的是12345，最後面的是 54321。
字典序如下：
設P是1～n的一個全排列:p=p1p2......pn=p1p2......pj-1pjpj+1......pk-1pkpk+1......pn
1）從排列的右端開始，找出第一個比右邊數字小的數字的序號j（j從左端開始計算），即 j=max{i|pi
2）在pj的右邊的數字中，找出所有比pj大的數中最小的數字pk，即 k=max{i|pi>pj}（右邊的數從右至左是遞增的，因此k是所有大於pj的數字中序號最大者）
3） 對換pi，pk
4）再將pj+1......pk-1pkpk+1......pn倒轉得到排列p'=p1p2.....pj-1pjpn.....pk+1pkpk-1.....pj+1，這就是排列p的下一個排列。
程式源碼??
#include "stdio.h"#include "string.h"
int* MediumToPermutation(int* piMedium, int iLen)
{
int* pFlag;
int i, j, sum;
int*piPermutation;
piPermutation= new int[iLen + 1];
pFlag = newint[iLen + 1];
memset(pFlag,0, sizeof(int) * (iLen + 1));
for(i = 0; i< iLen; i++)
{
j = 0;
sum = 0;
while(j< iLen + 1)
{
if(pFlag[j] == 0)sum += 1;
if(sum > piMedium[i])break;
j++;
}
pFlag[j]= 1;
piPermutation[i]= j + 1;
}
for(i = 0; i< iLen + 1; i++)
{
if(pFlag[i] == 0)
{
piPermutation[iLen] = i + 1;
break;
}
}
delete[]pFlag;
returnpiPermutation;
}
int* PermutationToMedium(int* piPermutation, int iLen)
{
int i, j, sum;
int* piMedium;
piMedium = newint[iLen - 1];
memset(piMedium, 0, sizeof(int) * (iLen - 1));
for(i = 0; i< iLen - 1; i++)
{
j = i +1;
while(j< iLen)
{
if(piPermutation[i] > piPermutation[j])piMedium[i]++;
j++;
}
}
returnpiMedium;
}
void NextM(int* piMedium, int iLen, int iM)
{
int i, iAdd;
while(iM >0)
{
iAdd= 2;
piMedium[iLen - 1] = piMedium[iLen - 1] + 1;
for(i= iLen - 1; i > 0; i--)
{
if(piMedium[i] == iAdd)
{
piMedium[i] = 0;
piMedium[i - 1] =piMedium[i - 1] + 1;
}
else break;
iAdd++;
}
if(i== 0)
{
if(piMedium[0] == iAdd)
{
for(i = 0; i < iLen; i++)
{
piMedium[i] =iLen - i;
}
break;
}
}
iM--;
}
}
int* Solve(int* piPermutation, int iLen, int iNext)
{
int* piResult;
int*piTmp;
int i;
piTmp =PermutationToMedium(piPermutation, iLen);
printf("對應的中介數是：");
for(i = 0; i< iLen-1; i++)printf(" %d", piTmp[i]);
printf("\n");
NextM(piTmp,iLen - 1, iNext);
printf("其後第 %d 個排列對應的中介數是：",iNext);
for(i = 0; i< iLen-1; i++)printf(" %d", piTmp[i]);
printf("\n");
piResult =MediumToPermutation(piTmp, iLen - 1);
delete []piTmp;
returnpiResult;
}
void CharToInt(char* pcIn, int* piOut)
{
int i, j, n;
int tmp[128] ={0};
int len =strlen(pcIn);
for(i = 0; i< len; i++)
{
tmp[pcIn[i]] = 1;
}
n = 1;
for(i = 0; i< 128; i++)
{
if(tmp[i] == 1)
{
for(j = 0; j < len; j++)
{
if(i == pcIn[j])
{
piOut[j] = n;
n++;
break;
}
}
}
}
}
void IntToChar(char* pcCmp, int* piCmp, int* piIn, char*pcOut)
{
int i, j;
int len =strlen(pcCmp);
for(i = 0; i< len; i++)
{
for(j =0; j < len; j++)
{
if(piCmp[j] == piIn[i])
{
pcOut[i] = pcCmp[j];
break;
}
}
}
pcOut[len] ="\0";
}
int main()
{
//freopen("input.txt", "r", stdin);
//freopen("output.txt","w", stdout);
char in[128];
int next;
printf("<===================作業二（ 全排列的生成算法）===================>\n");
printf("請輸入排列字元串：");
while(scanf("%s", in) != EOF)
{
printf("預推出其後的第幾個排列：");
scanf("%d", ≠xt);
printf("排列 %s ", in);
int *out;
out = newint[strlen(in)];
CharToInt(in, out);
int* out1;
int i;
char* out2;
out2 = newchar[strlen(in) + 1];
out1 =Solve(out, strlen(in), next);
IntToChar(in, out, out1, out2);
printf("排列 %s 後的第 %d 個排列是：",in, next);
printf("%s\n", out2);
printf("\n");
delete[]out1;
delete[]out2;
delete[]out;
}
return 0;
算法說明?
?設定了中介數的字典序 全排列生成算法，與遞歸直接模擬法和循環直接模擬法的最大不同是，不需要模擬有序全排列的生成過程，也就不需要逐一地生成各個全排列，只要知道初始全排列，就能根據序號（m-1），直接得到第m個全排列，因此速度非常快。它的缺點是在生成序號（m-1）的遞增進進制數時，需要事先創建一個用來存儲n的階乘數n! 的數組p[]，所以n的值不能太大，否則就會溢出，根據我的測試結果，當1<=n<=20時不會溢出，當21<=n時會溢出。設定了中介數的字典序全排列生成算法需要設定中介數，在實際套用中比較繁瑣，不如由前一個排列直接推得下一個排列方便。
