全排列

 #region

        /// <summary>

        /// 全排列 递归 考虑重复

        /// Peter

        /// </summary>

        public static String[] Permutation(String s)

        {

            if (s.Length == 1)

            {

                String[] res = new String[1];

                res[0] = s;

                return res;

            }

            else

            {

                StringBuilder sbuilder = new StringBuilder();



                Char[] cs = s.ToCharArray();

                Array.Sort(cs);

                s = new String(cs);

                Char pre = '0';

                for (Int32 i = 0; i < s.Length; i++)

                {

                    if (i == 0)

                    {

                        pre = s[i];

                        sbuilder.Append(String.Join(",", Merge(s[i], Permutation(s.Substring(0, i) + s.Substring(i + 1)))) + ",");

                    }

                    else

                    {

                        if (s[i] == pre)

                        {

                            continue;

                        }

                        else

                        {

                            sbuilder.Append(String.Join(",", Merge(s[i], Permutation(s.Substring(0, i) + s.Substring(i + 1)))) + ",");

                            pre = s[i];

                        }

                    }

                }

                return sbuilder.ToString().Split(new char[]{','},StringSplitOptions.RemoveEmptyEntries);

            }

        }



        public static String[] Merge(Char c, String[] s)

        {

            for (Int32 i = 0; i < s.Length; i++)

            {

                s[i] = c + s[i];

            }

            return s;

        }



        #endregion





        #region

        /// <summary>

        /// 全排列 非递归 没有重复元素！

        /// Peter

        /// 给定已知序列 P =  A1A2A3An ( Ai!=Aj , (1<=i<=n  , 1<=j<=n, i != j  ) )

        /// 方法为:

        /// 1.从低位到高位（从后向前），找出“不符合趋势”的数字。即找到一个Pi，使P(i) < P(i+1)。

        /// 若找不到这样的pi，说明我们已经找到最后一个全排列，可以返回了。

        /// 2.在 P(i+1)P(i+2)Pn 中,找到一个P(j),便得 P(j)"刚刚好大于"P(i). 

        /// ("刚刚好大于"的意思是:在 P(i+1)P(i+2)Pn 中所有大于P(i)的元素构成的集合中最小的元素.)

        /// 3.交换 P(i) , P(j) 的位置.注意:此处不改变i和j的值,改变的是P(i)和P(j).

        /// 4.交换后， P(1)P(2)P(3)P(n)  并不是准确的后一个排列。因为根据第1步的查找，我们有P(i+1) > P(i+2) > . > Pn

        /// 即使进行了Pi和Pj的交换,这仍然是这一部分最大的一个排列。将此排列逆序倒置(变成最小的排列)即为所求的下一个排列.

        /// 5.重复步骤1-4,直到步骤1中找不到“不符合趋势”的数字.

        /// </summary>

        

        public static List<String> Permutation1(String s)

        {

            Char[] cs = s.ToCharArray();

            Array.Sort(cs);

            s = new String(cs);

            List<String> list = new List<String>();

            list.Add(s);



            while (true)

            {

                s = FindNext(s);



                if (s == null)

                    break;



                list.Add(s);

            }

            return list;



        }

        public static String FindNext(String cur)

        {

            Int32 p1, p2;

            for (Int32 i = cur.Length - 1; i > 0; i--)

            {

                if (cur[i - 1] < cur[i])

                {

                    p1 = i - 1;

                    char min = cur[i];

                    p2 = i;

                    for (Int32 j = i; j < cur.Length; j++)

                    {

                        if (cur[j] > cur[p1])

                        {

                            if (cur[j] < min)

                            {

                                min = cur[j];

                                p2 = j;

                            }

                        }

                    }

                    Char[] cs = cur.ToCharArray();

                    char temp = cs[p1];

                    cs[p1] = cs[p2];

                    cs[p2] = temp;

                    Array.Reverse(cs, p1 + 1, cs.Length - p1 - 1);



                    return new String(cs);

                }

            }



            return null;

        }



        #endregion



        static void Main(string[] args)

        {



            Program p = new Program();



            String str = "abcc";



            Int32 start = Environment.TickCount;

            String[] res = Program.Permutation(str);

            Console.WriteLine("time :" + (Environment.TickCount - start));



            Console.WriteLine(res.Length);

            foreach (String s in res)

                Console.WriteLine(s);



            Console.WriteLine("--------------");

            start = Environment.TickCount;

            List<String> res2 = Program.Permutation1(str);

            Console.WriteLine("time :" + (Environment.TickCount - start));



            Console.WriteLine(res2.Count);

            foreach (String s in res2)

                Console.WriteLine(s);

        }