详解冒泡排序

冒泡排序

概念

何为冒泡排序，字如其意，就如同鱼的冒泡一般，由小到大逐渐有序（当然也可以从大到小）

举例（以从小到大的）：

【2 4 9 1 5 6 4 5 】
【2 4 1 5 6 4 5 9 】
【2 1 4 5 4 5 6 9】
【1 2 4 4 5 5 6 9】
如上，我给了8个无序的整数【2 4 9 1 5 6 4 5 】，进行冒泡排序，先选出最大的整数，怎么选？首先2和4进行比较，2比4小，不交换，比较对象换成4，然后4和9进行比较，4比9小，不交换，比较对象换成9，9和1进行比较，9比1大，交换，9再和5比较，9比5大，交换，9和6比较，9比6大，交换，9和4比较，9比6大，交换，最后9和5进行比较，9比5大，交换。最后得到 【2 4 1 5 6 4 5 9 】。之后的依次如此。
通过这一趟的冒泡排序我们可知，冒泡排序就是先选出一个最大的，然后选出次大的，然后选出次次大的……最终得到有序的结果。

代码

//Sort.h
#include<stdio.h>
#include<stdlib.h>

void PrintArray(int* a,int n);
void Swap(int*p1,int*p2);
void BubbleSort(int* a,int n);

//Sort.c
#include"Sort.h"
void PrintArray(int* a,int n)
{
   for(int i=0;i<n;i++)
   {
     printf("%d " ,a[i]);
     }
     printf("\n");
}


void Swap(int* p1,int* p2)
{
   int* temp=*p1;
   *p1=*p2;
   *p2=temp;
}

//核心代码
void BubbleSort(int* a,int n)
{
   for(int i=0;i<n;i++)
   {
     for(int j=0;j<n-1-i;j++)
     {
       if(a[j]>a[j+1])
        {
         Swap(&a[i],&a[j+1]);
         }
      }
   }
}

//Test.c
#include"Sort.h"
void BubbleSortTest(int* a,int n)
{
  int a[]={2 ,4 ,9 ,1 ,5 ,6, 4, 5};
  BubbleSort(a,sizeof(a)/sizeof(int));
  PrintArray(a,sizeof(a)/sizeof(int));
}

int main()
{
  BubbleSortTest();
  return 0;
 }
  

优化

//Sort.h
#include<stdio.h>
#include<stdlib.h>

void PrintArray(int* a,int n);
void Swap(int*p1,int*p2);
void BubbleSort(int* a,int n);

//Sort.c
#include"Sort.h"
void PrintArray(int* a,int n)
{
   for(int i=0;i<n;i++)
   {
     printf("%d " ,a[i]);
     }
     printf("\n");
}


void Swap(int* p1,int* p2)
{
   int* temp=*p1;
   *p1=*p2;
   *p2=temp;
}

//核心代码
void BubbleSort(int* a,int n)
{
   for(int i=0;i<n;i++)
   {
      int temp=1;          //优化
     for(int j=0;j<n-1-i;j++)
     {
       if(a[j]>a[j+1])
        {
         Swap(&a[i],&a[j+1]);
         temp=0;        //优化
         }
         if(temp==1)    //优化
         {
         break;
         }
      }
   }
}

//Test.c
#include"Sort.h"
void BubbleSortTest(int* a,int n)
{
  int a[]={2 ,4 ,9 ,1 ,5 ,6, 4, 5};
  BubbleSort(a,sizeof(a)/sizeof(int));
  PrintArray(a,sizeof(a)/sizeof(int));
}

int main()
{
  BubbleSortTest();
  return 0;
 }

你看出来，什么地方优化了吗？
其实就加了一个temp，这样做的好处在于，如果排序的元素集合接近于有序的时候我不再需要还要一个一个比，直接break了，对于时间效率会有所提升。

冒泡排序的特性

1. 时间复杂度：O(N^2)
2. 空间复杂度：O(1)，它是一种稳定的排序算法
3. 稳定性：稳定