C#版排序之交换排序

排序
外部	内部
	交换排序 冒泡排序 快速排序 插入排序 直接插入排序 希尔排序 选择排序 直接选择排序 堆排序 归并排序 归并排序 分配排序 箱排序 基数排序

排序：
       就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。其确切定义如下：
      输入：n个记录R ₁，R ₂，…，R _n，其相应的关键字分别为K ₁，K ₂，…，K _n。
      输出：R _il，R _i2，…，R _in，使得K _i1≤K _i2≤…≤K _in。(或K _i1≥K _i2≥…≥K _in)。
外部排序：
      排序过程中要进行数据的内、外存交换。
内部排序：
     在排序过程中，整个文件都是放在内存中处理，排序时不涉及数据的内、外存交换。
外部排序：
     排序过程中要进行数据的内、外存交换
交换排序：
     两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
冒泡排序：
     将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
快速排序：
   分治法的基本思想
    　将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
   快速排序的基本思想
    　设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：
    　在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。

冒泡排序与快速排序
using System;
using System.Collections.Generic;
using System.Text;

namespace Sort
{
    class SwapSort
    {
        static int[] array ={ 2, 45, 78, 98, 67, 5, 8 };
        static void Main(string[] args)
        {
            Console.WriteLine("原数组：");
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
            //
            Console.WriteLine("交换排序◆冒泡排序（∧）：");
            SwapSort.BubbleSortUp(array);
            for (int i = 0; i < array.Length; i++)
                Console.WriteLine(array[i]);
            //
            Console.WriteLine("交换排序◆冒泡排序（∨）：");
            SwapSort.BubbleSortDown(array);
            for (int i = 0; i < array.Length; i++)
                Console.WriteLine(array[i]);
            //
            Console.WriteLine("交换排序◆快速排序（∧）：");
            SwapSort.QuickSortUp(array, 0, array.Length - 1);
            for (int i = 0; i < array.Length; i++)
                Console.WriteLine(array[i]);
            //
            Console.WriteLine("交换排序◆快速排序（∨）：");
            SwapSort.QuickSortDown(array, 0, array.Length - 1);
            for (int i = 0; i < array.Length; i++)
                Console.WriteLine(array[i]);
            //
                Console.ReadLine();

        }
        /**//// <summary>
        /// 交换排序  冒泡排序（升序）
        /// </summary>
        public static void BubbleSortUp(int[] arr)
        {
            int i, j;
            int temp;
            int len = arr.Length;

            for (i = 0; i < len; i++)
            {
                for (j = len - 1; j >= 1; j--)
                {
                    if (arr[j] < arr[j - 1])
                    {
                        temp = arr[j];
                        arr[j] = arr[j - 1];
                        arr[j - 1] = temp;
                    }
                }
            }
        }
        /**//// <summary>
        /// 交换排序  冒泡排序（降序）
        /// </summary>
        public static void BubbleSortDown(int[] arr)
        {
            int i, j;
            int temp;
            int len = arr.Length;

            for (i = 0; i < len; i++)
            {
                for (j = len - 1; j >= 1; j--)
                {
                    if (arr[j] > arr[j - 1])
                    {
                        temp = arr[j];
                        arr[j] = arr[j - 1];
                        arr[j - 1] = temp;
                    }
                }
            }
        }
        /**//// <summary>
        /// 交换排序 快速排序（升序）
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        public static void QuickSortUp(int[] arr, int low, int high)
        {
            int pivotpos;
            if (low < high)
            {
                pivotpos = PartitionUp(arr, low, high);
                QuickSortUp(arr, low, pivotpos - 1);//对左区间递归排序
                QuickSortUp(arr, pivotpos + 1, high);//对右区间递归排序
            }
        }
        /**//// <summary>
        /// 对arr[i..j]做划分,并返回基准记录的位置
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public static int PartitionUp(int[] arr, int i, int j)
        {
            int pivot = arr[i];//用区间的第1个记录作为基准
            while (i < j)
            {
                //从区间两端交替向中间扫描，直至i=j为止
                while (i < j && arr[j] > pivot)//pivot相当于在位置i上
                    j--;//从右向左扫描，查找第1个小于pivot的记录arr[j]
                if (i < j)//表示找到的arr[j]<pivot
                    arr[i++] = arr[j];//相当于交换arr[i]和arr[j]，交换后i加1
                while (i < j && arr[i] <= pivot)//pivot相当于在位置j上
                    i++;//从左向右扫描，查找第1个大于pivot的记录arr[i]
                if (i < j)//表示找到了arr[i]，使arr[i]>pivot
                    arr[j--] = arr[i];//相当于交换arr[i]和arr[j]，交换后j减1
            }
            arr[i] = pivot;//基准记录已被最后定位
            return i;
        }
        /**//// <summary>
        /// 交换排序 快速排序（降序）
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        public static void QuickSortDown(int[] arr,int low,int high)
        {
            int pivotpos;
            if (low < high)
            {
                pivotpos = PartitionDown(arr, low, high);
                QuickSortDown(arr, low, pivotpos - 1);//对左区间递归排序
                QuickSortDown(arr, pivotpos + 1, high);//对右区间递归排序
            }
        }
        /**//// <summary>
        /// 对arr[i..j]做划分,并返回基准记录的位置
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public static int PartitionDown(int[] arr, int i, int j)
        {
            int pivot=arr[i];
            while (i < j)
            {
                while (i < j && arr[j] < pivot)
                    j--;
                if (i < j)
                    arr[i++] = arr[j];
                while (i < j && arr[i] >= pivot)
                    i++;
                if (i < j)
                    arr[j--] = arr[i];
            }
            arr[i] = pivot;
            return i;
        }
        
    }
}