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

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

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

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

——

posted on 2013-03-03 22:09  小城故事  阅读(457)  评论(0编辑  收藏  举报