内部排序 明

2013-01-23

 摘要：内部排序,包括直接插入、冒泡、快速、简单选择，堆排序。

1 插入排序

 基本思想：将一个记录插入到以排好序的有序表中，从而得到一个新的、记录数增1的有序表。

1.1 直接插入排序

 

图1 直接插入排序

public static void InsertSort(int[] arr)
        {
            int i, j;
            int temp;
            for (i = 1; i < arr.Length; i++)
            {
                temp = arr[i];
                for (j = i - 1; j >= 0 && temp < arr[j]; j--)
                {
                    arr[j + 1] = arr[j];
                }
                arr[j + 1] = temp;
            }
        }

2 快速排序

 快速排序时基于“交换”进行排序的方法。

2.1 冒泡排序

 基本思想：1）第一个和第二个比较，若逆序（First>Second），交换。然后进行第二个和第三个，以此类推，直到n-1和n个。这样，第一轮就把最大的“沉”到“底部”。

               2）然后，第二轮比较前n-1个就行，以此类推，得到有序表。

 

图2 冒泡排序

//采用自上向下扫描
        public static void BubbleSort(int[] arr)
        {
            int i, j;
            int temp;
            for (i = arr.Length - 1; i > 0; i--)
            {
                for (j = 0; j < i; j++) //对当前无序区R[0..n-i]自下向上扫描
                {
                    if (arr[j] > arr[j + 1])
                    {
                        temp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }

2.2 快速排序

 基本思想：1）通过一趟排序把待排记录分割成独立的两部分，前一部分都比某个记录效，后一部分都比某个记录大

　　　　　 2）对前一部分和后一部分按1）再分区，直到整个序列有序。

图3 快速排序

public static void QuickSort(int[] arr)
        {
            QSort(arr, 0, arr.Length - 1);
        }

        public static void QSort(int[] arr, int low, int high)
        {
            if (low < high)
            {
                int pivotLoc = Partition(arr, low, high);
                QSort(arr, low, pivotLoc - 1);
                QSort(arr, pivotLoc + 1, high);
            }
        }

        public static int Partition(int[] arr, int low, int high)
        {
            int pivot = arr[low];
            while (low < high)
            {
                while ((high > low) && arr[high] >= pivot) --high;
                arr[low] = arr[high];
                while ((low < high) && (arr[low] <= pivot)) ++low;
                arr[high] = arr[low];
            }
            arr[low] = pivot;
            return low;
        }

3 选择排序

基本思想：每一趟在最后的n-i+1（i=1,2,...,n-1）中取最小的记录作为有序表的第i个记录。

3.1 简单选择排序

 

图4 简单选择排序

public static void SelectSort(int[] arr)
        {
            int i, j;
            int minLoc;
            int temp;
            for (i = 0; i <= arr.Length - 1; i++)
            {
                minLoc = i;

                for (j = i + 1; j <= arr.Length - 1; j++)
                    if (arr[j] < arr[minLoc]) minLoc = j;

                if (minLoc != i)
                {
                    temp = arr[i];
                    arr[i] = arr[minLoc];
                    arr[minLoc] = temp;
                }
            }
        }

3.2 堆排序

堆的定义

图5 堆的定义

我们可以吧这个序列看成一个二叉树，可得， 1）最大堆的根节点最大，2)上层总比下层大

public static void HeapSort(MyArr arr)
        {
            int i; int r;
            for (i = arr.Length / 2; i > 0; --i)
            {  //把H.r[1...H.length]建成大顶堆
                HeapAdjust(arr, i, arr.Length - 1);
            }
            for (i = arr.Length; i > 1; --i)
            {
                //将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换
                r = arr[1]; arr[1] = arr[i]; arr[i] = r;
                HeapAdjust(arr, 1, i - 1);  //将H.r[1..i-1]重新调整为大顶堆
            }
        }

        //小的放在下层
        public static void HeapAdjust(MyArr arr, int s, int m)
        {
            int rc = arr[s];
            for (int j = 2 * s; j <= m; j = 2 * j)
            {  //沿key较大的孩子结点向下筛选
                if (j < m && arr[j] < arr[j + 1]) ++j; //j为key较大的记录的下标
                if (rc >= arr[j]) break; //rc应插入在位置s上
                arr[s] = arr[j]; s = j;
            }
            arr[s] = rc;   //插入
        }

        //因为以零开始的数组，对于堆栈不好操作，也容易误解，所以自定义数组，以1起始
        public class MyArr
        {
            int[] arr;
            public int this[int pos]
            {
                get
                {
                    return arr[pos - 1];
                }
                set
                {
                    arr[pos - 1] = value;
                }
            }
            public int Length
            {
                get
                {
                    return arr.Length;
                }
            }
            public MyArr(int[] arr)
            {
                this.arr = arr;
            }
        }

4 客户端 

class Program
    {
        static void Main(string[] args)
        {
            //1 直接插入排序
            int[] sample = new int[] { 53, 27, 36, 15, 69, 42 };
            DisplayArray("Original Sequence is: ", sample);
            Sort.InsertSort(sample);
            DisplayArray("InsertSort Sequence is: ", sample);
            //2 冒泡排序
            sample = new int[] { 70, 30, 40, 10, 80, 20, 90, 100, 75, 60, 45 };
            DisplayArray("Original Sequence is: ", sample);
            Sort.BubbleSort(sample);
            DisplayArray("BubbleSort Sequence is: ", sample);
            //3 快速排序
            sample = new int[] { 49, 38, 65, 97, 76, 13, 27 };
            DisplayArray("Original Sequence is: ", sample);
            Sort.QuickSort(sample);
            DisplayArray("QuickSort Sequence is: ", sample);
            //4 简单选择排序
            sample = new int[] { 58, 23, 35, 10, 76, 12 };
            DisplayArray("Original Sequence is: ", sample);
            Sort.SelectSort(sample);
            DisplayArray("SelectSort Sequence is: ", sample);
            //5 堆排序
            Sort.MyArr arr = new Sort.MyArr(new int[] { 49, 38, 65, 97, 76, 13, 27, 49 });
            Console.Write("Original Sequence is: ");
            for(int m=1;m<arr.Length;m++)
                Console.Write("{0}  ", arr[m].ToString());
            Sort.HeapSort(arr);
            Console.WriteLine();
            Console.Write("HeapSort Sequence is: ");
            for (int m = 1; m < arr.Length; m++)
                Console.Write("{0}  ", arr[m].ToString());

            Console.Read();
        }

        public static void DisplayArray(string declare, int[] arr)
        {
            Console.Write(declare);
            for (int m = 0; m < arr.Length; m++)
                Console.Write("{0}  ", arr[m].ToString());
            Console.WriteLine();
        }
    }

5 各种内部排序比较

排序方法	平均情况	最坏情况	辅助空间
直接插入排序	O(n2)	O(n2)	O(1)
起泡排序	O(n2)	O(n2)	O(1)
快速排序	O(nlogn)	O(n2)	O(logn)
简单选择排序	O(n2)	O(n2)	O(1)
堆排序	O(nlogn)	O(nlogn)	O(1)