一、题目

输入三个字符串，按由小到大的顺序输出

输入

3行字符串

输出

按照从小到大输出成3行

样例输入

cde
afg
abc
样例输出
abc
afg
cde

二、分析

 要知道怎么判断字符串的大小，我觉得要知道这个字母的ASCII码，从而比较ASCII码的大小。

我查了一下，一般比较字符串的大小的意思是比较字典序的大小，从左到右逐个字符进行比较

我们先循环输入这三个字符串，先比较第一个和第二个的大小，小的赋值给变量t,再拿t和第三个字符进行比较，从而决定最小的。

在冒泡排序中，外层循环和内层循环的条件设置与排序的逻辑密切相关。下面详细解释为什么对于三个字符串，只需要进行**两轮**外层循环，以及内层循环的条件为何设置为 `j < 2 - i`。

### 1. 冒泡排序的基本原理

冒泡排序的核心思想是通过多次比较和交换，将较大的元素逐步“冒泡”到数组的末端。具体来说，冒泡排序通过以下步骤进行：

- **第一轮**：
  - 从数组的第一个元素开始，比较相邻的两个元素。
  - 如果前一个元素大于后一个元素，则交换它们的位置。
  - 这一轮结束后，数组的最后一个元素将是最大的元素。

- **第二轮**：
  - 重复上述过程，但这次只需要比较到倒数第二个元素，因为最后一个元素已经排好序。
  - 这一轮结束后，数组的倒数第二个元素将是第二大的元素。

- **以此类推**，每一轮都会将当前未排序部分的最大元素移动到正确的位置，直到整个数组有序。

### 2. 为什么只需要两轮外层循环？

对于包含 **3 个字符串** 的数组，冒泡排序的逻辑如下：

- **第一轮外层循环**：
  - 比较 `str[0]` 和 `str[1]`。
  - 比较 `str[1]` 和 `str[2]`。
  
  假设输入为 `["cde", "afg", "abc"]`，第一轮比较后：
  - `cde` 和 `afg` 比较，不交换。
  - `afg` 和 `abc` 比较，交换，数组变为 `["cde", "abc", "afg"]`。
  
  第一轮结束后，最大的元素 `afg` 位于数组的最后一个位置。

- **第二轮外层循环**：
  - 比较 `str[0]` 和 `str[1]`。
  
  - `cde` 和 `abc` 比较，交换，数组变为 `["abc", "cde", "afg"]`。
  
  第二轮结束后，数组已经有序。

- **第三轮外层循环**：
  - 对于 3 个元素的数组，第三轮实际上是不需要的，因为数组在前两轮已经有序。

因此，对于 3 个元素的数组，**只需要两轮外层循环** 就可以完成排序。

### 3. 内层循环的条件 `j < 2 - i` 的原因

内层循环的次数取决于当前未排序部分的长度：

- 在第一轮外层循环中，未排序部分的长度为 3，因此内层循环需要比较 `str[0]` 和 `str[1]`，以及 `str[1]` 和 `str[2]`，即需要执行 2 次比较。
- 在第二轮外层循环中，未排序部分的长度为 2，因此内层循环只需要比较 `str[0]` 和 `str[1]`，即需要执行 1 次比较。

因此，内层循环的条件设置为 `j < 2 - i`，其中 `i` 是外层循环的当前轮数：

- 当 `i = 0` 时，内层循环的条件为 `j < 2`，即执行 2 次比较。
- 当 `i = 1` 时，内层循环的条件为 `j < 1`，即执行 1 次比较。

### 4. 总结

- **外层循环** 的次数取决于数组的长度。对于 3 个元素的数组，只需要进行 2 轮外层循环。
- **内层循环** 的次数取决于当前未排序部分的长度，因此内层循环的条件设置为 `j < 2 - i`，以确保不会访问数组越界。

通过这种设置，冒泡排序能够有效地对 3 个字符串进行排序，并且在排序过程中不会发生数组越界错误。

当然还有其他方法可以实现这个功能。以下是几种不同的方法，包括使用不同的数据结构、排序算法以及手动排序的方法。

### 方法一：使用数组和冒泡排序

这种方法不依赖于标准库中的排序函数，而是手动实现排序算法。

```cpp
#include <iostream>
#include <string>

using namespace std;

int main() {
    string arr[3];
    
    // 读取三个字符串
    for(int i = 0; i < 3; i++) {
        getline(cin, arr[i]);
    }
    
    // 使用冒泡排序按字典序排序
    for(int i = 0; i < 2; i++) {
        for(int j = 0; j < 2 - i; j++) {
            if(arr[j] > arr[j + 1]) {
                // 交换两个字符串
                string temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    
    // 输出排序后的字符串
    for(int i = 0; i < 3; i++) {
        cout << arr[i] << endl;
    }
    
    return 0;
}
```

### 方法二：使用 `std::set` 自动排序

`std::set` 是一个自动排序的数据结构，可以用来存储字符串并自动排序。

```cpp
#include <iostream>
#include <set>
#include <string>

using namespace std;

int main() {
    set<string> strings;
    string input;
    
    // 读取三个字符串并插入到 set 中
    for(int i = 0; i < 3; i++) {
        getline(cin, input);
        strings.insert(input);
    }
    
    // 输出排序后的字符串
    for(const auto &s : strings) {
        cout << s << endl;
    }
    
    return 0;
}
```

### 方法三：使用 `std::vector` 和 `std::sort` 与自定义比较函数

如果需要自定义排序逻辑，可以使用 `std::sort` 并提供自定义比较函数。

```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

// 自定义比较函数
bool compare_strings(const string &a, const string &b) {
    return a < b;
}

int main() {
    vector<string> strings(3);
    
    // 读取三个字符串
    for(int i = 0; i < 3; i++) {
        getline(cin, strings[i]);
    }
    
    // 使用自定义比较函数进行排序
    sort(strings.begin(), strings.end(), compare_strings);
    
    // 输出排序后的字符串
    for(const auto &s : strings) {
        cout << s << endl;
    }
    
    return 0;
}
```

### 方法四：使用 `std::priority_queue` 进行排序

`std::priority_queue` 可以用来实现堆排序。

```cpp
#include <iostream>
#include <queue>
#include <string>

using namespace std;

int main() {
    // 创建一个优先队列，默认是最大堆
    priority_queue<string, vector<string>, std::greater<string>> pq;
    string input;
    
    // 读取三个字符串并插入到优先队列中
    for(int i = 0; i < 3; i++) {
        getline(cin, input);
        pq.push(input);
    }
    
    // 输出排序后的字符串
    while(!pq.empty()) {
        cout << pq.top() << endl;
        pq.pop();
    }
    
    return 0;
}
```

### 总结

以上几种方法各有优缺点：

- **冒泡排序**：简单易懂，但效率较低，适用于小规模数据。
- **`std::set`**：自动排序，代码简洁，但插入和查找的时间复杂度较高。
- **`std::vector` 和 `std::sort`**：灵活且效率高，适用于大多数情况。
- **`std::priority_queue`**：适用于需要优先队列的场景。

根据具体需求选择合适的方法即可。

三、代码 

#include<iostream>
using namespace std;
int main()
{
	
	string str[3];
	//键盘读入三个字符串 
	for(int i = 0; i < 3; i++)
	{
		cin >> str[i];	
	}	 
	//冒泡排序，对三个字符串进行排序
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 2-i; j++)
		{
			if(str[j] > str[j+1]){
				string t = str[j];
				str[j] = str[j+1];
				str[j+1] = t;
			}	
		}	
	} 
	//输出排序后的字符
	for(int i = 0; i < 3; i++)
	{
		cout << str[i] << endl;	
	} 
	return 0;		
} 

 还需要思考！！