现在的位置: 首页 > 综合 > 正文

排序总结

2013年10月03日 ⁄ 综合 ⁄ 共 2546字 ⁄ 字号 评论关闭

对数组排序的三种通用方法:

交换排序Exchange

选择排序Selection

插入排序Insertion

我们通过一叠扑克牌形象地理解以上三种方法。

用交换方法对扑克牌排序时,把扑克牌摊在桌上,花色朝上然后交换顺序已乱的牌,直到一副牌都有序为止。

 

用选择方法对扑克牌排序时,把牌摊在桌上,把数值最小的牌抽出,放在手中。然后在剩余牌中再找到最小者,把其放在手中,如此继续到桌上无牌时,手中的牌就排好序了。

 

用插入方法对扑克牌排序时,把牌都拿在手中,每次从手中取一张放在桌上,每次放到桌上时,都插入适当位置,如此继续,手中无牌时,桌上的一副牌就变成有序的了。

 

交换排序中,最著名(也是最声名狼藉)的排序似乎冒泡排序,出名在于名字形象且操作简单,其名声狼藉在于它是目前最差的排序之一。两个for循环重复了指定的次数,外部循环执行n-1次,内部循环执行你n/2次。

 

选择排序中,先选择最小的元素并将其与第一元素交换,然后在剩余n-1个元素中选择最小者并与第二个元素交换等等,

不幸的是和冒泡算法一样,,外部循环执行n-1次,内部循环执行你n/2

 

插入排序,与冒泡和选择排序不同,插入排序的比较次数与被排表的初始排列有关。如表是完全有序的,比较次数为n-1,否则按n平方次序列排序。

 

快速排序基于交换排序,与基于交换排序的冒泡排序相比,其效果是令人吃惊的。

 

快速排序的基本思想是分区。一般过程是先选一个称为比较数的值,然后把数组分成两段。大于或等于分区值的元素都放在一边,小于分区值的元素都放另一边。然后对两段用递归排序。

 

快速排序算法如下:

 

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. namespace ConsoleApplication1
  5. {
  6.     class DataStructDemo
  7.     {
  8.        public static void QuickSort(int [] items, int left, int right){
  9.            int i,j,x,y;
  10.            i=left;
  11.            j=right;
  12.            x=items[(left+right)/2];
  13.         do
  14.         {
  15.             while ((items[i] < x) && (i < right))
  16.                 i++;
  17.             while ((items[j] > x) && (j > left))
  18.                 j--;
  19.             if (i <= j)
  20.             {
  21.                 y = items[i];
  22.                 items[i] = items[j];
  23.                 items[j] = y;
  24.                 i++;
  25.                 j--;
  26.             }
  27.         } while (i <= j);
  28.                  if(left<j)QuickSort(items,left,j);
  29.                  if(right>i)QuickSort(items,i,right);
  30.          }
  31.              
  32.         [STAThread]
  33.         static void Main(string[] args)
  34.         {
  35.             int[] arr ={ 2, 4, 65, 76, 87, 90, 56, 89, 78 };
  36.             QuickSort(arr, 0, arr.Length - 1);
  37.             Console.WriteLine(" Quick Sort Test!!!");
  38.             for (int i = 0; i < arr.Length; i++)
  39.             {
  40.                 Console.WriteLine(arr[i]);
  41.             }
  42.         }
  43.     }
  44. }

 

该例中,x=items[(left+right)/2]值为87,当第一次

 

  1. do
  2.         {
  3.             while ((items[i] < x) && (i < right))
  4.                 i++;
  5.             while ((items[j] > x) && (j > left))
  6.                 j--;
  7.             if (i <= j)
  8.             {
  9.                 y = items[i];
  10.                 items[i] = items[j];
  11.                 items[j] = y;
  12.                 i++;
  13.                 j--;
  14.             }
  15.         } while (i <= j);

 这段代码执行完毕后,i值为6j值为5,执行的结果为

2,   4  65  76  78  56  90  89  87

 

中间过程为

2,  4  65  76  87  90  56  89  78

 

 2   4  65  76  78  90  56  89  87

 

 

 2   4  65  76  78  90  56  89  87

 

2,   4  65  76  78  56  90  89  87

这时j左边及i右边被分成了两段,左段都比x=items[(left+right)/2]=87小。右段都比x=items[(left+right)/2]=87,同时if(left<j)QuickSort(items,left,j)条件满足,if(right>i)QuickSort(items,i,right)条件也满足,将递归对两段排序。

算法最后的执行结果为

 

 

 

 

抱歉!评论已关闭.