c++ 直接插入排序 输入n（n<20）个整数，输出其升序排序的结果。 输入说明： 第一行输入n 第二行输入n个整数 输入说明： 输出n个整数升序排序的结果 输入示例： 5 3 2 1 5 4 输出示例： 1 2 3 4 5

下面是 C++ 实现直接插入排序的代码：

#include <iostream>
using namespace std;

void insertSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int j = i - 1;
        int temp = arr[i];
        while (j >= 0 && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
}

int main() {
    int n;
    cin >> n;
    int arr[20];
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    insertSort(arr, n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

输入示例：

5
3 2 1 5 4

输出示例：

1 2 3 4 5

相关问题

1、输入n个不为零的整数作为节点元素值，遇到0代表输入结束(不创建元素值为0的节点)，创建第一个有序链表。输出整个链表。如果输入的第一个数为0，则创建空链表（没有任何元素的链表）。

在C++中，你可以使用双向链表（因为链表可以更方便地插入和删除节点）来实现这个功能。以下是一个简单的实现步骤：

1. 定义一个`Node`结构体或类，表示链表中的每个节点，包含数据域（存储整数值）和两个指针（前驱和后继）。

struct Node {
    int data;
    Node* prev;
    Node* next;
};

2. 创建一个`LinkedList`类或结构体，用于管理链表的操作，包括插入节点和遍历链表。

class LinkedList {
private:
    Node* head;
    Node* tail;

public:
    LinkedList() : head(nullptr), tail(nullptr) {}

    void insert(int value) {
        if (value == 0) {
            return; // 如果输入0，直接返回，不做任何操作
        }

        Node* newNode = new Node{value, nullptr, nullptr};

        if (!head) { // 链表为空，设置头和尾
            head = tail = newNode;
        } else {
            newNode->prev = tail;
            tail->next = newNode;
            tail = newNode; // 更新尾部指针
        }
    }

    // 添加其他辅助方法，如打印链表等

    // 返回链表的遍历函数，可以按照升序输出
    void printList() {
        Node* current = head;
        while (current) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << "\n";
    }
};

3. 使用时，首先实例化一个`LinkedList`对象，然后根据输入依次调用`insert`方法。

int main() {
    LinkedList list;
    int input;
    std::cin >> input;
    while (input != 0) {
        list.insert(input);
        std::cin >> input;
    }
    list.printList();
    return 0;
}

当你运行这段代码，程序会读取用户输入的整数序列，直到遇到0为止，然后构建并打印出排序后的链表。如果输入开始就是0，则链表将是空的。

设x和y为非负整数，对于集合{2^x3^y|x>=0,y>=0},写一个c++程序输出集合中小于整数n的元素个数，并求这些元素从小到大排序的第m项元素。

为了实现这个功能，你可以使用两个嵌套循环遍历所有可能的`x`和`y`组合，计算它们对应的值`2^x * 3^y`，然后检查这个值是否小于给定的`n`。同时，你需要维护一个有序列表（例如优先队列或有序数组），以便在满足条件时插入并保持顺序。

以下是一个简单的C++程序，使用了`std::priority_queue`来存储结果：

#include <iostream>
#include <queue>
#include <vector>

int count_and_find(int n, int m) {
    std::priority_queue<int> pq; // 用于存储小于n的数，并按升序排列
    int count = 0;
    
    for (int x = 0; ; x++) { // 遍历所有正整数x
        long long num = 1LL << x; // 2^x
        for (int y = 0; num * 3 <= n; y++) { // 只需考虑3^y <= n / 2^x的情况
            num *= 3; // 2^x * 3^y
            if (num < n) {
                pq.push(num); // 插入小于n的数
                count++;
                if (count == m) {
                    return num; // 找到了第m个数，直接返回
                }
            } else {
                break; // 当num >= n时，停止当前的y循环
            }
        }
        if (num >= n) {
            break; // 当num >= n时，所有的y值都不满足条件，跳出x循环
        }
    }

    return count; // 返回小于n的元素个数
}

int main() {
    int n, m;
    std::cout << "Enter a number n: ";
    std::cin >> n;
    std::cout << "Enter the index m (1-based): ";
    std::cin >> m;

    int count = count_and_find(n, m);
    std::cout << "Number of elements less than " << n << ": " << count << "\n";
    if (count > 0) {
        int result = count_and_find(n, m - 1); // 由于优先级队列是升序的，所以找到的是第m-1个数
        std::cout << "The " << m << "-th smallest element is: " << result << "\n";
    } else {
        std::cout << "There are no elements smaller than " << n << ".\n";
    }

    return 0;
}

在这个程序中，`count_and_find` 函数首先初始化一个空的优先队列，然后从最小的`x=0`开始递增，直到找到第`m`个元素。注意，因为优先队列保证了插入的元素始终是最小的，所以在找到第`m`个元素后，可以直接返回队列顶元素，而无需额外操作。