一个朋友面试时遇到的算法题（怎么组合后得到最大整数）

　　首先，这篇的标题是我借来的，两周前，我看过MrWrong发的一篇帖子（http://www.cnblogs.com/MrWrong/p/3986158.html），初看时感觉就是一个排列问题，然后洒洒水般的写了一段，结果被版主指出误点，当时我真的头蒙了，坐在那里两个小时，想不出比较好的方法（全排列，然后比较大小的方法排除，这个不借鉴，如果有十个不一样的元素，全排列方法有3628800中，如果在多一位元素就是39916800，已经比前一个多十倍了，需要的内存指数上升），然后又碰到十一国庆，也把这个问题滞后了（当初给版主回复：这个问题很好，稍等，一等就是两周...），昨天才想到还有这么回事，回家就认真看了看问题，小子虽然不才，但是也把它解决了。

---

题目如下：

一个正整数数组：如， 14 32 133 152

将其串起来得到能表示的最大整数（这里就是3215214133）

　　这道题原贴主提供的几种方法，当时我看看也是云里雾里的，不明觉厉。可能技术层次上有差异吧，毕竟人家是只老雕，咱不过是只小鸟。

这道题我采用的方法：集合分类；从首到尾逐个字符处理，排除非最大字符的元素。（中间集合元素会衍生）

处理过程看下代码，比较清晰：

//如果长度比需求的小，向后补【补的时候注意已经存在的项不再添加】
CheckLength(curIndex, ref eList);
//找出最大字符
Char maxChar = GetMaxChar(eList, curIndex);
//删除非最大字符
DelNoMaxChar(curIndex, maxChar, ref eList);

举例吧：14 32 133 152

1.分集合（集合模型定义{ {可能最大元素} , {剩余元素} } ）：{ {14,32,133,152} , { } } ，从第一位开始检查。

2.首先检查每个字符的长度是否足够1（看来都足够长）

3.然后找出最大字符 maxChar = 3

4.将首字符非3的移到其他集合{{32} , {14,133,152}}

5.检查第二字符，由于现在最大集合只有一个元素，所以就是它自己，现在集合仍是{{32} , {14,133,152}}

6.检查第三字符，由于最大集合32不足三位，需要补数，补后集合{ {32|14,32|133,32|152} , {  } }

7.找出第三个字符最大 maxChar = 1 ,都是1 ,集合保持不变 { {32|14,32|133,32|152} , {  } }

8.找出第四个字符最大 maxChar = 5, 最大集合排除非5 ,执行后集合{ {32|152} , {14,133} }

....  之后方法如上。

注：代码中部分实现跟以上稍有不同，但是主要解决方式是相同的。

---

 以下是源代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication2
{
    public class Cluster
    {
        /// <summary>
        /// 已使用
        /// </summary>
        public List<string> UseList;
        /// <summary>
        /// 未使用
        /// </summary>
        public List<string> RemainingList;

        private string stringValue = "";
        public string StringValue
        {
            get { return stringValue; }
        }

        public Cluster()
        {
            this.UseList = new List<string>();
            this.RemainingList = new List<string>();
        }

        public Cluster(string stringValue)
            : this()
        {
            this.stringValue = stringValue;
        }

        public void Add(string item)
        {
            int index = -1;
            for (int i = 0; i < RemainingList.Count; i++)
            {
                if (RemainingList[i] == item)
                {
                    index = i;
                }
            }

            if (index >= 0)
            {
                RemainingList.RemoveAt(index);
                UseList.Add(item);
                this.stringValue += item;
            }
            else
            {
                throw new ArgumentException("剩余中不存在该元素:" + item);
            }
        }

        public Cluster Clone()
        {
            Cluster ret = new Cluster(this.stringValue);
            ret.UseList.AddRange(this.UseList.ToArray());
            ret.RemainingList.AddRange(this.RemainingList.ToArray());

            return ret;
        }
    }

    public class Program
    {
        static void Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += (s, e) => { Console.WriteLine(e.ExceptionObject.ToString()); Console.ReadKey(); };

            //List<string> orgList = new List<string>() { "33", "48", "5", "53", "54", "544", "54444", "546", "55" };
            List<string> orgList = null;

            if (args.Length > 0)
            {
                orgList = new List<string>();
                orgList.AddRange(args);
            }
            else
            {
                orgList = new List<string>() { "33", "48", "5", "53", "54", "544", "54444", "546", "55" };
            }
              
            CheckNum(orgList);
            List<Cluster> eList = new List<Cluster>();
            //连接后的字符串最大长度
            int maxLength = 0;
            foreach (var item in orgList)
                maxLength += item.Length;

            foreach (var item in orgList)
            {
                Cluster el = new Cluster();
                el.RemainingList.AddRange(orgList.ToArray());
                el.Add(item);

                eList.Add(el);
            }

            for (int curIndex = 0; curIndex < maxLength; curIndex++)
            {
                //如果长度比需求的小，向后补【补的时候注意已经存在的项不再添加】
                CheckLength(curIndex, ref eList);
                //找出最大字符
                Char maxChar = GetMaxChar(eList, curIndex);
                //删除非最大字符
                DelNoMaxChar(curIndex, maxChar, ref eList);
            }

            var list = eList;

            Console.WriteLine(eList[0].StringValue);
            Console.ReadKey();
        }

        static void DelNoMaxChar(int index, char maxChar, ref List<Cluster> list)
        {
            for (int i = list.Count - 1; i >= 0; i--)
            {
                Cluster el = list[i];
                if (el.StringValue[index] < maxChar)
                {
                    list.RemoveAt(i);
                }
            }
        }

        static void CheckNum(List<string> list)
        {
            Regex regNumber = new Regex(@"^d+$");
            foreach (var item in list)
            {
                if (!regNumber.IsMatch(item))
                {
                    throw new ArgumentException("数组中有非数字符号: " + item);
                }
            }
        }

        static void CheckLength(int index, ref List<Cluster> list)
        {
            for (int i = 0; i < list.Count;)
            {
                if (list[i].StringValue.Length <= index)
                {
                    Cluster curCluster = list[i];

                    foreach (var item in curCluster.RemainingList)
                    {
                        #region 去除可能重复
                        bool flag = false; //重复标志
                        string stringvalue = curCluster.StringValue + item;

                        for (int j = 0; j < list.Count; j++)
                        {
                            if (String.Equals(list[j].StringValue, stringvalue))
                            {
                                flag = true;
                                break;
                            }
                        }
                        #endregion

                        if (!flag)
                        {
                            Cluster clone = curCluster.Clone();
                            clone.Add(item);
                            list.Add(clone);
                        }
                    }

                    list.RemoveAt(i);
                    continue;
                }
                i++;
            }
        }

        static Char GetMaxChar(List<Cluster> list, int index)
        {
            Char targetChar = '';

            for (int i = 0; i < list.Count; i++)
            {
                if (list[i].StringValue[index] > targetChar)
                    targetChar = list[i].StringValue[index];
            }

            if (targetChar != '')
                return targetChar;
            else
                throw new Exception("查找最大字符时出错");
        }
    }
}

---

从此向下为后补内容，觉得应该加上去，很多人来讨论，当然方法一个比一个好，以下方法是我精简出来的一套好方法，跟大家养养眼，呵呵：

var list = new List<string>() { "33", "48", "5", "53", "54", "544", "54444", "546", "55" };
list.Sort(delegate(string x,string y){return string.CompareOrdinal(y + x,x + y);});
string result = string.Join("", list.ToArray());