准备从头复习算法

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

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

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

		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中用栈结构比递归的函数栈调用还要慢呢？

——