简单算法之冒泡排序

冒泡排序：

1. 临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

   这样一趟过去后,最大或最小的数字被交换到了最后一位,

   然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子

   例子为从小到大排序,

   原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

   
   

   第一趟排序(外循环)

   第一次两两比较6 > 2交换(内循环)

   交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

   交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

    

   第二次两两比较,6 > 4交换

   交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

   交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

    

   第三次两两比较,6 > 1交换

   交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

   交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

    

   第四次两两比较,6 > 5交换

   交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

   交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

    

   第五次两两比较,6 < 9不交换

   交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

   交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

    

   第二趟排序(外循环)

   第一次两两比较2 < 4不交换

   交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

   交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

    

   第二次两两比较,4 > 1交换

   交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 
   交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

    

   第三次两两比较,4 < 5不交换

   交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 
   交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

    

   第四次两两比较,5 < 6不交换

   交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

   交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

    

   第三趟排序(外循环)

   第一次两两比较2 > 1交换

   交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

    

   第二次两两比较,2 < 4不交换

   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

    

   第三次两两比较,4 < 5不交换

   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

    

   第四趟排序(外循环)无交换

   第五趟排序(外循环)无交换

   
   

   排序完毕,输出最终结果1 2 4 5 6 9

   分析过了之后，直接上代码了：

   #include 
   
     
    void BubbleSort(int arr[], int length)
    {
         int temp;
         for (int i = 0; i < length; ++i)
         {
              for (int j = 0; j < length - i - 1; ++j)
              {
                   if (arr[j] > arr[j + 1])
                   {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                   }
              }
         }
    }
     
    int main()
    {
         int arr[6] = {6,2,4,1,5,9};
     
         BubbleSort(arr, sizeof(arr) / sizeof(arr[0]));
     
         for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
         {
   		  std::cout<