SCAU8638--直接插入排序

8638 直接插入排序

时间限制:1000MS  代码长度限制:10KB
提交次数:2050 通过次数:1393

题型: 编程题   语言: G++;GCC

Description

用函数实现直接插入排序，并输出每趟排序的结果.

 

输入格式

第一行：键盘输入待排序关键的个数n
第二行：输入n个待排序关键字，用空格分隔数据

 

输出格式

每行输出一趟排序结果，数据之间用一个空格分隔

 

输入样例

10
5 4 8 0 9 3 2 6 7 1

 

输出样例

4 5 8 0 9 3 2 6 7 1
4 5 8 0 9 3 2 6 7 1
0 4 5 8 9 3 2 6 7 1
0 4 5 8 9 3 2 6 7 1
0 3 4 5 8 9 2 6 7 1
0 2 3 4 5 8 9 6 7 1
0 2 3 4 5 6 8 9 7 1
0 2 3 4 5 6 7 8 9 1
0 1 2 3 4 5 6 7 8 9

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <set>
#include <string>
#include <queue>
#include <stack>
using namespace std;

// 直接插入排序函数：对数组 a 进行排序，并在每趟结束后输出当前结果
void insertionSort(vector<int>& a) {
    int n = a.size();
    // 从下标 1 开始，每次将 a[i] 插入到前面已经排好序的区间
    for (int i = 1; i < n; ++i) {
        int key = a[i];      // 待插入元素
        int j = i - 1;
        // 将大于 key 的元素统一后移
        while (j >= 0 && a[j] > key) {
            a[j + 1] = a[j];
            --j;
        }
        a[j + 1] = key;      // 插入到正确位置

        // 输出当前趟排序结果
        for (int k = 0; k < n; ++k) {
            if (k) cout << ' ';
            cout << a[k];
        }
        cout << '\n';
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    insertionSort(a);
    return 0;
}

在插入排序中，**每一趟排序**都会将当前未排序部分的第一个元素插入到已排序部分的正确位置，逐步扩大已排序的序列。下面我们结合代码和具体例子详细说明每一趟的排序过程。

---

### **插入排序的步骤（结合代码）**
1. **初始状态**：数组分为两部分：
   - **已排序部分**：初始时只有第一个元素（`a[0]`），默认已排序。
   - **未排序部分**：从第二个元素（`a[1]`）到最后一个元素（`a[n-1]`）。
2. **每一趟排序**：
   - 取出未排序部分的第一个元素（`key = a[i]`）。
   - 从后往前扫描已排序部分，将所有比 `key` 大的元素向后移动一位。
   - 将 `key` 插入到正确的位置。
   - 输出当前数组状态（调用 `printArray`）。

---

### **具体例子演示**
假设输入数组为 `[5, 2, 4, 6, 1, 3]`，我们逐步分析每一趟排序：

#### **初始数组**：
```
5 2 4 6 1 3
```
（注：代码中未输出初始状态，但为了理解，我们这里标出）

---

#### **第 1 趟（i = 1，key = 2）**：
- 已排序部分：`[5]`  
- 未排序部分：`[2, 4, 6, 1, 3]`  
- 比较 `key=2` 和 `5`：
  - `5 > 2`，所以 `5` 向后移动，覆盖 `2` 的位置 → `[5, 5, 4, 6, 1, 3]`  
  - 到达数组开头，插入 `key=2` → `[2, 5, 4, 6, 1, 3]`  
- **输出**：
  ```
  2 5 4 6 1 3
  ```

---

#### **第 2 趟（i = 2，key = 4）**：
- 已排序部分：`[2, 5]`  
- 未排序部分：`[4, 6, 1, 3]`  
- 比较 `key=4` 和 `5`：
  - `5 > 4`，所以 `5` 向后移动 → `[2, 5, 5, 6, 1, 3]`  
  - 比较 `key=4` 和 `2`：
    - `2 < 4`，停止移动，插入 `key=4` → `[2, 4, 5, 6, 1, 3]`  
- **输出**：
  ```
  2 4 5 6 1 3
  ```

---

#### **第 3 趟（i = 3，key = 6）**：
- 已排序部分：`[2, 4, 5]`  
- 未排序部分：`[6, 1, 3]`  
- 比较 `key=6` 和 `5`：
  - `5 < 6`，无需移动，直接保留 → `[2, 4, 5, 6, 1, 3]`  
- **输出**：
  ```
  2 4 5 6 1 3
  ```
  （数组未变化，因为 `6` 已经在正确位置）

---

#### **第 4 趟（i = 4，key = 1）**：
- 已排序部分：`[2, 4, 5, 6]`  
- 未排序部分：`[1, 3]`  
- 比较 `key=1` 和 `6`：
  - `6 > 1`，`6` 向后移动 → `[2, 4, 5, 6, 6, 3]`  
  - 比较 `key=1` 和 `5`：
    - `5 > 1`，`5` 向后移动 → `[2, 4, 5, 5, 6, 3]`  
  - 比较 `key=1` 和 `4`：
    - `4 > 1`，`4` 向后移动 → `[2, 4, 4, 5, 6, 3]`  
  - 比较 `key=1` 和 `2`：
    - `2 > 1`，`2` 向后移动 → `[2, 2, 4, 5, 6, 3]`  
  - 到达数组开头，插入 `key=1` → `[1, 2, 4, 5, 6, 3]`  
- **输出**：
  ```
  1 2 4 5 6 3
  ```

---

#### **第 5 趟（i = 5，key = 3）**：
- 已排序部分：`[1, 2, 4, 5, 6]`  
- 未排序部分：`[3]`  
- 比较 `key=3` 和 `6`：
  - `6 > 3`，`6` 向后移动 → `[1, 2, 4, 5, 6, 6]`  
  - 比较 `key=3` 和 `5`：
    - `5 > 3`，`5` 向后移动 → `[1, 2, 4, 5, 5, 6]`  
  - 比较 `key=3` 和 `4`：
    - `4 > 3`，`4` 向后移动 → `[1, 2, 4, 4, 5, 6]`  
  - 比较 `key=3` 和 `2`：
    - `2 < 3`，停止移动，插入 `key=3` → `[1, 2, 3, 4, 5, 6]`  
- **输出**：
  ```
  1 2 3 4 5 6
  ```

---

### **最终排序结果**
```
1 2 3 4 5 6
```