准备从头复习算法

半年多没更新了，太懒了。工作上业务逻辑真是无穷无尽，变更无休无止，还是回来，哪怕随便写点也好。

今天就是个微不足道的东西，不过也有点可以深入思考的东西。

快速排序一般都是递归实现，我一直以为递归性能上差一点，但可读性。但我前几天试写了一个不用递归的快速排序，发现反而不如递归的版本快：

		static void StackQuickSort<T>(T[] array, int start, int end) where T : IComparable<T>{

			var stack = new Stack<int>();

			stack.Push(start);stack.Push(end);

			

			int left, right;

			T pivot;

			while (stack.Count > 0) {

				end = right = stack.Pop(); start = left = stack.Pop();

				pivot = array[left];

				

				while (true)

				{

					while (array[right].CompareTo(pivot) > 0) right--;

					if (right == left) break;

					Swap(array, left++, right);



					while (array[left].CompareTo(pivot) < 0) left++;

					if (right == left) break;

					Swap(array, left, right--);

				}



				if (left - start > 1) {

					//如子区间块长大于1，则继续对区间排序

					stack.Push(start);

					stack .Push(left-1);

				}

				if (end - left > 1) {

					stack.Push(left + 1);

					stack.Push(end);

				}

			}

		}

 时间对比是(ms):

非递归：   80　　77　　78　　77

递归：      73　　74　　72　　71

常规实现代码

        internal static void QuickSort<T>(T[] array, int start, int end) where T : IComparable<T>

        {

            var left = start;

            var right = end;

            var pivot = array[start];



            while (true)

            {

                while (array[right].CompareTo(pivot) > 0) right--;

                if (right == left) break;

                Swap(array, left++, right);



                while (array[left].CompareTo(pivot) < 0) left++;

                if (right == left) break;

                Swap(array, left, right--);

            }



            if (left - start > 1) QuickSort(array, start, left - 1);  //如子区间块长大于1，则继续对区间排序

            if (end - left > 1) QuickSort(array, left + 1, end);

        }

我想应该，是不是因为.NET中用栈结构比递归的函数栈调用还要慢呢？

——