【算法之家】——交换排序之冒泡排序与快速排序

来源：互联网发布：virtualbox安装软件编辑：程序博客网时间：2024/05/09 13:15

【前言】

冒泡排序和快速排序属于交换排序，快速排序是冒泡排序的一种改进算法。我更觉得冒泡排序像是一种特殊的二分查找，从两头开始查找，用法更加的巧妙！

【内容】

冒泡排序的基本过程用如下的动态图表示：

冒泡排序的c++代码如下：

#include <iostream.h>#define N 10void sort(int A[N],int n){  //外循环  int temp;//将第一个数看成是最小的   for(int i=0;i<n-1;i++){ //内循环，从大到小排序   for(int j=0;j<n-1-i;j++){   if(A[j]>A[j+1]){ min=A[j+1];     A[j+1]=A[j]; A[j]=min;   }   }   }}//主函数---------------------------int main(){  int A[N]={5,7,6,10,13,78,-4,9,20}  sort(A,10);for(int i=0;i=sizeof(A)/sizeof(int);i++){  cout<<A[i]<<' ';}cout<<endl;return 0;}

c#写成的冒泡排序：

   static void Main(string[] args)        {            int[] a = { 12, 23, 25, 2, 7, 1, 10 };            BuddleSort(a);            Console.WriteLine("排序后的数组：");            foreach (var item in a)            {                Console.Write(item + ",");            }            Console.WriteLine();            Console.ReadKey();        }        #region        ///稳定性的排序；        #endregion        /// <summary>        /// 冒泡排序-常银玲-2016-9-10 11:20:44        /// </summary>        /// <param name="a">待排序的数组</param>        static void BuddleSort(int[] a) {            int temp = 0;            for (int i = 0; i < a.Length-1; i++)            {                //内循环的开始，将大的数组移到a.lentgh-1-i位！                for (int j = 0; j < a.Length-1-i; j++)                {                    if (a[j]>a[j+1])                    {                        temp = a[j+1];                        a[j + 1] = a[j];                        a[j] = temp;                    }                }            }                }    }

快速排序的基本流程可以用以下的一个动态图表示：

用c#代码可以表示如下：

        /// <summary>        /// 第一趟快速排序-常银玲-2016-9-29 16:29:01        /// </summary>        /// <param name="a"></param>        /// <param name="low"></param>        /// <param name="high"></param>        static void Quicksort(int[] a,int low,int high) {           //第一趟排序             int key = a[low]; //将第一个数设置为他的比较的基准数。            while(low<high)            {                while (low < high && a[high] > key) {                    high--;                }                //如果右边的数小于左边的数，就将低位和高位的位置进行交换。                a[low] = a[high];                while (low < high && a[low] < key) {                    low++;                }                //如果左边的数大于右边的数，就将低位和高位的位置进行交换。                a[high] = a[low];            }            a[low] = key;        }

这是第一趟的比较完成之后，完整的快速排序可以写成如下的递归算法：

 static void  quicksort(int[] a, int left, int right){        if(left < right){                int key = a[left];                int low = left;                int high = right;                while(low < high){                        while(low < high && a[high] > key){                                high--;                        }                        a[low] = a[high];                        while(low < high && a[low] < key){                                low++;                        }                        a[high] = a[low];                }                a[low] = key;            //递归，将第一位比较数作为一个分界线，将它前面的数和后面的数按照上面的方法，进行比较            //只是下标进行了改动。                quicksort(a,left,low-1);                quicksort(a,low+1,right);        }}

【总结】

每一个算法都有他们各自独特的特征，对于冒泡排序和快速排序来说都属于是交换排序，对于简单的一系列数，即n值很小的情况下，冒泡排序就可以简单解决；而对于数量极大的一系列数来言快速就有很大的优势，可以很快的解决我们的问题。对于一个已经是排好序的输入序列，快速排序的算法是较低的，近似于O（n^2）。

0 0