论述冒泡法算法思想及步骤，绘制程序流程图，绘制PAD分析图

冒泡排序算法是一种简单的排序算法，它重复地交换相邻的未按顺序排列的元素。算法的思想是每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来，直到没有相邻元素需要交换。

下面是冒泡排序算法的步骤：

1. 从第一个元素开始比较相邻的元素，如果前一个元素比后一个元素大，则交换它们的位置。
2. 继续比较下一对相邻元素，重复步骤1，直到比较到最后一对相邻元素。
3. 重复步骤1和步骤2，直到所有元素都被排序。

下面是冒泡排序算法的程序流程图：

  +-------+
  | Start |
  +-------+
      |
      v
  +--------+
  | i = 0  |
  | j = 0  |
  +--------+
      |
      v
  +--------------+
  | i < n - 1     |
  | j < n - i - 1 |
  +--------------+
      |
      v
  +-----------------+
  | a[j] > a[j + 1]  |
  +-----------------+-------+
      |                       |
      v                       v
  +-----------------+  +------------------+
  | swap(a[j], a[j+1])|  | j = j + 1        |
  +-----------------+  +------------------+
                          |
                          v
                  +----------------+
                  | i = i + 1      |
                  | j = 0          |
                  +----------------+
                          |
                          v
                      +------+
                      | End  |
                      +------+

PAD分析图如下：

┌─────────┐                                                    
│ Start   │                                                    
└───┬─────┘                                                    
    │                                                           
    v                                                           
┌─────────┐                                                    
│ i = 0   │                                                    
│ j = 0   │                                                    
└───┬─────┘                                                    
    │                                                           
    v                                                           
┌─────────────┐                                                
│ i < n - 1    │                                                
│ j < n - i - 1│                                                
└───┬─────────┘                                                
    │                                                           
    v                                                           
┌──────────────────┐                                           
│ a[j] > a[j + 1]   │                                           
└───┬──────────────┘                                           
    │                                                           
    v                                                           
┌──────────────────┐                                           
│ swap(a[j], a[j+1])│                                           
└───┬──────────────┘                                           
    │                                                           
    v                                                           
┌─────────────┐                                                
│ j = j + 1   │                                                
└───┬─────────┘                                                
    │                                                           
    v                                                           
┌──────────────────┐                                           
│ i = i + 1        │                                           
│ j = 0            │                                           
└───┬──────────────┘                                           
    │                                                           
    v                                                           
┌─────────┐                                                    
│ End     │                                                    
└─────────┘