冒泡排序&快速排序&桶排序

时间复杂度：

时间复杂度的计算不是计算程序具体运行的时间，而是算法执行语句的次数，复杂程度。
当有多个算法可以选择时，通过计算时间复杂度，判断出哪个算法在具体执行时使用的时间最少。

常数阶O(1),

对数阶O(log2 n),

线性阶O(n),

线性对数阶O(n log2 n),

平方阶O(n^2)，

立方阶O(n^3)

k次方阶O(n^K),

指数阶O(2^n)。

随着n的不断增大，时间复杂度不断增大，算法花费时间越多。

 

当我们说T(N)=O(f(N))的时候，其实是说函数T(N)以不快于f(N)的速度增长，f(N)是T(N)的一个上界。

 

引入这个概念其实是想对比一下排序的三种算法，冒泡，快速排序，还有桶式排序。

 

 

首先是冒泡排序，时间复杂度O(n²)。

冒泡排序，作为最基础的排序方法，一直是很多人入门排序算法的首选，但是当n数值越来越大的时候，时间耗费也会越来越多，成指数爆炸形式增长。

代码如下（c语言）：

 

int i, j, temp;

    for (j = 0; j < n - 1; j++)

        for (i = 0; i < n - 1 - j; i++)

        {

            if(a[i] > a[i + 1])

            {

                temp = a[i];

                a[i] = a[i + 1];

                a[i + 1] = temp;

            }

        }

 

快速排序，时间复杂度O(nlogn)。

快速排序是对冒泡排序的一种改进，花费时间小于冒泡排序

耗费空间小于桶式排序。是一种比较“全能”的排序算法。

 

代码如下（c语言）：

 

void sort(int left,int right)

{

    int i,j,t;

    int temp;

    

    i = left;

    j = right;

    temp = arr[left];

    

    if(left>right)

    {return;}

    

while(i!=j)

{

    for (; arr[j]>=temp && i<j; ){j--;}

    for (; arr[i]<=temp && i<j; ){i++;}

     

    if (i<j)

    {

        t = arr[i];

        arr[i] = arr[j];

        arr[j] = t;

    }

    

}

    arr[left] = arr[i];

    arr[i] = temp;



    sort(left, i-1);

    sort(i+1, right);

}

 

 

最后是桶式排序，时间复杂度O(N+C)，其中C=N*(logN-logM)。

桶式排序不受到下限O(nlogn)影响，有时候甚至比快速排序还快！但是有一个致命的缺点就是，当n增长时，所耗费的空间也是随之增长，十分占内存。

 

代码如下（c语言）：

 

#include <stdio.h>

      

     int main()

     {

         int book[1001],i,j,t,n;

         for(i=0;i<=1000;i++)

             book[i]=0;   

         scanf("%d",&n);//输入一个数n，表示接下来有n个数

         for(i=1;i<=n;i++)//循环读入n个数，并进行桶排序

         {

             scanf("%d",&t);  //把每一个数读到变量t中

             book[t]++;  //进行计数，对编号为t的桶放一个小旗子

         }

         for(i=1000;i>=0;i--)  //依次判断编号1000~0的桶

             for(j=1;j<=book[i];j++)  //出现了几次就将桶的编号打印几次

                  printf("%d ",i);

      

         getchar();getchar();

         return 0;

     }

 

如果有错漏欢迎指出，入门菜鸡不足之处请勿重喷。