全排列算法分析（原创方法/一般方法/字典序法）

public class FullPermutation {
	
	static int count = 0;

	/**
	 * 递归实现全排列
	 * <br />程序思路是：依次确定第一位到最后一位，与人的一般思维方式一致
	 */
	public static void main(String[] args) {
		String str = "13234";
		str = check(str);//去除重复元素
		fullPermutate(0, "", str);
		System.out.print(count);
	}
	
	/**
	 * @param index 本次调用确定第index位
	 * @param path 已经确定顺序的串
	 * @param string 待全排列的串
	 */
	static void fullPermutate(int index, String path, String string)
	{
		String restStr = strSub(string, path);
		if(index == string.length())
		{
			System.out.println(path + restStr);
			count++;//
			return;
		}
		else
		{
			for(int i = 0;i < string.length() - index;i++)
				fullPermutate(index + 1, path + restStr.charAt(i), string);
		}
	}
	
	/**
	 * @param full 完整的串
	 * @param part 部分子串
	 * @return rest 返回full与part的差集
	 */
	static String strSub(String full, String part)
	{
		String rest = "";
		
		for(int i = 0;i < full.length();i++)
		{
			String c = full.charAt(i) + "";
			if(!part.contains(c))
				rest += c;
		}
		
		return rest;
	}
	
	/**
	 * @param str 待检查的串
	 * @return 返回不含重复元素的串
	 */
	static String check(String str)
	{
		for(int i = 0;i < str.length() - 1;i++)
		{
			String firstPart = str.substring(0, i + 1);
			String restPart = str.substring(i + 1);
			str = firstPart + restPart.replace(str.charAt(i) + "", "");
		}
		
		return str;
	}
}

#include <stdio.h>  

int n = 0;  

void swap(int *a, int *b) 
{     
    int m;     
    m = *a;     
    *a = *b;     
    *b = m; 
}  
void perm(int list[], int k, int m) 
{     
    int i;     
    if(k > m)     
    {          
        for(i = 0; i <= m; i++)             
            printf("%d ", list[i]);         
        printf("\n");         
        n++;     
    }     
    else     
    {         
        for(i = k; i <= m; i++)         
        {             
            swap(&list[k], &list[i]);             
            perm(list, k + 1, m);             
            swap(&list[k], &list[i]);         
        }     
    } 
} 
int main() 
{     
    int list[] = {1, 2, 3, 4, 5};     
    perm(list, 0, 4);     
    printf("total:%d\n", n);     
    return 0; 
}

public class DictionaryOrder {

	/**
	 * 按字典序输出全排列
	 * <br />按照字典序可以得到已知序列的下一个序列，可以用于不需要得到所有全排列的场合（例如数据加密）
	 */
	public static void main(String[] args) {
		int arr[] = new int[]{4, 3, 1, 2};
		/*
		boolean exist = nextPermutation(arr);
		if(exist)
		{
			for(int value : arr)
				System.out.print(value);
			System.out.println();
		}
		else
			System.out.println("当前序列已经是最大字典序列");
		*/
		///*
		//对给定序列排序（升序）
		sort(arr);
		for(int value : arr)
			System.out.print(value);
		System.out.println();
		//求全排列并输出
		int count = 1;//第一个已经在上面输出了
		while(nextPermutation(arr))
		{
			for(int value : arr)
				System.out.print(value);
			System.out.println();
			count++;
		}
		System.out.println("共 " + count + " 个");
		//*/
	}

	/**
	 * @param arr 当前序列
	 * @return 字典序中的下一个序列，没找到则返回false
	 */
	public static boolean nextPermutation(int[] arr)
	{
		int pos1 = 0, pos2 = 0;
		//1.从右向左找出满足arr[i] < arr[i + 1]的i
		//（就是找出相邻位中满足前者小于后者关系的前者的位置）
		boolean find = false;
		for(int i = arr.length - 2;i >= 0;i--)
			if(arr[i] < arr[i + 1])
			{
				pos1 = i;
				find = true;
				break;
			}
		if(!find)//若没找到，说明当前序列已经是最大字典序了
			return false;
		//2.从pos1向后找出最小的满足arr[i] >= arr[pos1]的i
		//（就是找出pos1后面不小于arr[pos1]的最小值的位置）
		int min = arr[pos1];
		for(int i = pos1 + 1;i < arr.length;i++)
		{
			if(arr[i] >= arr[pos1])
			{
				min = arr[i];
				pos2 = i;
			}
		}
		//3.交换pos1与pos2位置上的值
		int temp = arr[pos1];
		arr[pos1] = arr[pos2];
		arr[pos2] = temp;
		//4.对pos1后面的所有值做逆序处理（转置）
		int i = pos1 + 1;
		int j = arr.length - 1;
		for(;i < j;i++, j--)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		return true;
	}
	
	/**
	 * 对给定数组做升序排序（冒泡法）
	 * @param arr 待排序数组
	 */
	public static void sort(int[] arr)
	{
		for(int i = 0;i < arr.length - 2;i++)
			for(int j = 0;j < arr.length - i - 1;j++)
				if(arr[j] > arr[j + 1])
				{
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
	}
}