全排序

 

 

/**
 * 全排列
 * 
 * @author Joeson
 * 
 */
public class AllRange
{
	static int count = 0;

	public static void main(String[] args)
	{
		AllRange allRange = new AllRange();

		char[] a = allRange.init(args);

		System.out.print("排列数组： ");
		allRange.print(a);
		System.out.println();

		allRange.allRange(a);
		System.out.println("共有" + count + "种");

	}

	/**
	 * 初始化字符数组
	 * 
	 * @param args
	 * @return
	 */
	public char[] init(String[] args)
	{
		char[] a = new char[args.length];

		for (int i = 0; i < args.length; i++)
		{
			a[i] = args[i].charAt(0);
		}

		return a;
	}

	/**
	 * 快速排序，增序排序
	 * 
	 * @param a
	 * @param from
	 * @param to
	 *            最大下标
	 */
	public void quickSort(char[] a, int from, int to)
	{
		if (from <= to)
		{
			int midSort = partition(a, from, to);

			quickSort(a, from, midSort - 1);
			quickSort(a, midSort + 1, to);
		}
		return;
	}

	/**
	 * 快速排序核心部分
	 * 
	 * @param a
	 * @param low
	 * @param high
	 * @return
	 */
	public int partition(char[] a, int low, int high)
	{

		char p = a[low];

		while (low < high)
		{
			while (low < high && a[high] >= p)
				high--;
			a[low] = a[high];

			while (low < high && a[low] <= p)
				low++;
			a[high] = a[low];

		}

		a[low] = p;

		return low;
	}

	/**
	 * 全排列非递归算法的
	 * 
	 * @param a
	 */
	public void allRange(char[] a)
	{
		// 先进性一次快排，确保原始排列为递增
		quickSort(a, 0, a.length - 1);

		do
		{
			count++;
			System.out.print("第" + count + "种排列： ");
			print(a);
		} while (nextPermutation(a));

	}

	/**
	 * 找到下个数列<br/><br/>
	 * 
	 * 如何计算字符串的下一个排列了？来考虑"926520"这个字符串，<br/>
	 * 我们从后向前找第一双相邻的递增数字，"20"、"52"都是非递增的，"26 "<br/>
	 * 即满足要求，称前一个数字2为替换数，替换数的下标称为替换点，<br/>
	 * 再从后面从后往前找一个比替换数大的最小数（这个数必然存在），0、2都不行，5可以，<br/>
	 * 将5和2交换得到"956220"，然后再将替换点后的字符串"6220"颠倒即得到"950226"。
	 * 
	 * @param a
	 * @return
	 */
	public boolean nextPermutation(char[] a)
	{

		int cur = a.length - 2;

		// 从后找出第一个两个连续递增(必须'<')的字符，第一个为替换点
		while (cur > 0 && a[cur] >= a[cur + 1])
		{
			cur--;
		}

		// 然后将替换点和后面中比他大的最小的字符交换，再对替换点后面的字符进行反转
		if (cur >= 0 && a[cur] < a[cur + 1])
		{
			int minIndex = a.length - 1;
			int minValue = 200;

			// 注意要从后往前找一个比替换点大的最小数
			for (int i = a.length - 1; i > cur; i--)
			{
				if (a[i] < minValue && a[i] > a[cur])
				{
					minIndex = i;
					minValue = a[i];
				}
			}

			if (a[minIndex] > a[cur])
			{
				swap(a, cur, minIndex);

				reverse(a, cur + 1, a.length - 1);

				return true;
			}

		}

		return false;
	}

	/**
	 * 反转数组
	 * 
	 * @param a
	 * @param begin
	 * @param end
	 */
	public void reverse(char[] a, int begin, int end)
	{
		while (begin < end)
		{
			swap(a, begin++, end--);
		}

	}

	/**
	 * 递归算法核心
	 * 
	 * @param a
	 * @param k
	 *            表示当前选取到第几个数
	 */
	public void allRangeDV(char[] a, int k)
	{
		int m = a.length - 1;

		if (k == m)
		{
			System.out.print("排列结果： ");
			count++;

			print(a);
		}
		else
		{
			// 第i个数分别与它后面的数字交换就能得到新的排列
			for (int i = k; i <= m; i++)
			{
				swap(a, k, i);
				allRangeDV(a, k + 1);
				swap(a, k, i);
			}
		}
	}

	/**
	 * 递归算法核心(考虑相同数)
	 * 
	 * @param a
	 * @param k
	 *            表示当前选取到第几个数
	 */
	public void allRangeDVDif(char[] a, int k)
	{
		int m = a.length - 1;

		if (k == m)
		{
			System.out.print("排列结果： ");
			count++;

			print(a);
		}
		else
		{
			// 第i个数分别与它后面的数字交换就能得到新的排列
			for (int i = k; i <= m; i++)
			{

				if (isSwap(a, k, i))
				{
					swap(a, k, i);
					allRangeDVDif(a, k + 1);
					swap(a, k, i);
				}
			}
		}
	}

	/**
	 * 判断是否交换，即判断数组在下标[begin-end)区间是否有和end相同
	 * 
	 * @param a
	 * @param begin
	 * @param end
	 * @return 没有的话返回true
	 */
	public boolean isSwap(char[] a, int begin, int end)
	{
		for (int i = begin; i < end; i++)
		{
			if (a[i] == a[end])
			{
				return false;
			}
		}

		return true;

	}

	/**
	 * 交换次序
	 * 
	 * @param a
	 * @param k
	 * @param m
	 */
	public void swap(char[] a, int k, int m)
	{
		char temp = a[k];
		a[k] = a[m];
		a[m] = temp;
	}

	/**
	 * 打印
	 * 
	 * @param a
	 */
	public void print(char[] a)
	{
		for (int i = 0; i < a.length; i++)
		{
			System.out.print(a[i] + " ");
		}

		System.out.println();
	}

}