特殊排序之红白球

特殊排序之红白球

今天去面试，做了一道上机题，感觉有点意思，记录一下。
设有红色、白色两种球若干，放在一个数组里，请实现算法：把红球排到白球前面。

先设置好要操作的类：

    enum EBallColor
    {
        Red,
        White,
    }
    class Ball : IComparable<Ball>
    {
        public EBallColor BallColor { get; set; }
        public Ball(EBallColor color)
        {
            this.BallColor = color;
        }
        public override string ToString()
        {
            return string.Format("{0}", BallColor);
            //return base.ToString();
        }

        /// <summary>
        /// Red &gt; White
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public int CompareTo(Ball other)
        {
            if (other == null)
            {
                return -1;
            }

            if (this.BallColor == other.BallColor)
            {
                return 0;
            }

            if (this.BallColor == EBallColor.Red)
            {
                return 1;
            }

            return -1;
        }
    }

 

当然用排序的方式是可以的：

        private static void BallArrange(Ball[] ballList)
        {
            if (ballList == null || ballList.Length < 2)
            {
                return;
            }

            for (int i = 0; i < ballList.Length; i++)
            {
                int p = i;

                for (int j = i + 1; j < ballList.Length; j++)
                {
                    if (ballList[p].CompareTo(ballList[j]) < 0)
                    {
                        p = j;
                    }
                }

                if (p != i)
                {
                    var tmp = ballList[p];
                    ballList[p] = ballList[i];
                    ballList[i] = tmp;
                }
            }
        }

 

写的时候就想到排序是很浪费的，各个球没有大小，只有两个值，然后就想到直接把白球放到最后就可以了。于是又写了一种算法。（名字很猥琐）

        static void BallArrange2(IList<Ball> ballList)
        {
            if (ballList == null || ballList.Count < 2)
            {
                return;
            }

            int arranged = 0, index = 0;

            while (index < ballList.Count - arranged)
            {
                var ball = ballList[index];
                if (ball.BallColor == EBallColor.White)
                {
                    ballList.Remove(ball);
                    ballList.Add(ball);
                    arranged--;
                }
                else
                {
                    index++;
                }
            }
        }

 

要是就这么简单，我觉得面试官不会拿来考我。所以应该有优化的算法。在人家明确提出用一次循环搞定问题之后。我想出了下面的算法。

         static void BallArrange3(Ball[] ballList)
         {
             if (ballList == null || ballList.Length < 2)
             {
                 return;
             }
 
             int left = 0, right = ballList.Length - 1;
 
             while (left < right)
             {
                 if (ballList[left].BallColor == EBallColor.Red)
                 {
                     if (ballList[right].BallColor == EBallColor.Red)
                     {
                         left++;
                     }
                     else
                     {
                         left++;
                         right--;
                     }
                 }
                 else
                 {
                     if (ballList[right].BallColor == EBallColor.White)
                     {
                         right--;
                     }
                     else
                     {
                         var tmp = ballList[left];
                         ballList[left] = ballList[right];
                         ballList[right] = tmp;
                         left++;
                         right--;
                     }
                 }
             }
         }

 

写出来就觉得是对了，果然面试官说想要的就是这种“交换”的思路。
这个算法的思路是：从左开始，发现是红球的，说明符合条件，抛弃之不再管（left++）；从右开始，发现是白球的，符合条件，抛弃之不再管（right--），只有左白右红时，交换，然后抛弃之不再管。直到left >= right时，左右都符合条件，结束。

最后面试官又问了一下Main函数里的测试代码的问题，说能不能只写一个BallArrange函数就实现多种排序算法的测试？我听明白了他想问什么，但是脑子一时堵塞，没有想起那个名词来，于是pardon了一下，然后就明白了，说可以对每个算法分别设置一个类，使其继承一个基类，BallArrange方法继承自基类的虚方法。后来回想起来，这个好像是策略模式吧。然后面试官就说没问题了，想问的就是这个了。

        static void Main(string[] args)
        {
            Ball[] ballList = new Ball[]
            {
                new Ball(EBallColor.Red),
                new Ball(EBallColor.White),
                new Ball(EBallColor.White),
                new Ball(EBallColor.Red),
                new Ball(EBallColor.Red),
            };

            Console.WriteLine("Before arrange: ");
            foreach (var item in ballList)
            {
                Console.WriteLine(item);
            }

            //BallArrange(ballList);
            //BallArrange2(ballList);
            BallArrange3(ballList);

            Console.WriteLine("After arrange: ");
            foreach (var item in ballList)
            {
                Console.WriteLine(item);
            }
        }