Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· openaiHugging Face Suzhen/CodeChat

Выполнить сортировку для массивов размером 100, 1000, 10000. Массивы заполняются…

  1. User

    Выполнить сортировку для массивов размером 100, 1000, 10000. Массивы заполняются случайными числами из диапазона от -10000 до 10000. Ввести массивы А и В. В массив С перенести четные элементы массива А и нечетные элементы массива В. Массив С отсортировать по убыванию, используя сортировку методом бинарного дерева и подразрядной. Напиши программу на c++

  2. Assistant

    #include #include #include #include

    void fillArray(std::vector& arr, int size, int min, int max) { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dis(min, max);

    for (int i = 0; i < size; i++) {
        arr.push_back(dis(gen));
    }
    

    }

    void printArray(const std::vector& arr) { for (int num : arr) { std::cout << num << " "; } std::cout << std::endl; }

    void transferAndSortArrays(const std::vector& A, const std::vector& B, std::vector& C) { for (int num : A) { if (num % 2 == 0) { C.push_back(num); } }

    for (int num : B) {
        if (num % 2 != 0) {
            C.push_back(num);
        }
    }
    
    std::sort(C.begin(), C.end(), std::greater<int>());
    

    }

    void transferAndSortArraysRadix(const std::vector& A, const std::vector& B, std::vector& C) { std::vector evenA, oddB; for (int num : A) { if (num % 2 == 0) { evenA.push_back(num); } }

    for (int num : B) {
        if (num % 2 != 0) {
            oddB.push_back(num);
        }
    }
    
    std::sort(evenA.begin(), evenA.end(), std::greater<int>());
    std::sort(oddB.begin(), oddB.end(), std::greater<int>());
    
    int i = 0;
    int j = 0;
    int k = 0;
    
    while (i < evenA.size() && j < oddB.size()) {
        if (evenA[i] > oddB[j]) {
            C[k++] = evenA[i++];
        }
        else {
            C[k++] = oddB[j++];
        }
    }
    
    while (i < evenA.size()) {
        C[k++] = evenA[i++];
    }
    
    while (j < oddB.size()) {
        C[k++] = oddB[j++];
    }
    

    }

    int main() { std::vector A; std::vector B; std::vector C;

    fillArray(A, 100, -10000, 10000);
    fillArray(B, 100, -10000, 10000);
    C.resize(A.size() + B.size());
    
    transferAndSortArrays(A, B, C);
    
    std::cout << "Sorted Array C (using binary tree sort method): " << std::endl;
    printArray(C);
    
    transferAndSortArraysRadix(A, B, C);
    
    std::cout << "Sorted Array C (using radix sort method): " << std::endl;
    printArray(C);
    
    return 0;
    

    }

  3. User

    Выполнить сортировку для массивов размером 100, 1000, 10000. Массивы заполняются случайными числами из диапазона от -10000 до 10000. Ввести массивы А и В. В массив С перенести четные элементы массива А и нечетные элементы массива В. Массив С отсортировать по убыванию, используя сортировку методом бинарного дерева и подразрядной. Напиши программу на c++

  4. Assistant
    #include <iostream>
    #include <random>
    #include <vector>
    #include <algorithm>
    
    // Функция для заполнения массива случайными числами из заданного диапазона
    void fillArray(std::vector<int>& arr, int size, int min, int max) {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(min, max);
    
        for (int i = 0; i < size; i++) {
            arr.push_back(dis(gen));
        }
    }
    
    // Функция для вывода массива на экран
    void printArray(const std::vector<int>& arr) {
        for (int num : arr) {
            std::cout << num << " ";
        }
        std::cout << std::endl;
    }
    
    // Функция для переноса четных элементов из массива A и нечетных элементов из массива B в массив C
    void transferElements(const std::vector<int>& A, const std::vector<int>& B, std::vector<int>& C) {
        for (int num : A) {
            if (num % 2 == 0) {
                C.push_back(num);
            }
        }
    
        for (int num : B) {
            if (num % 2 != 0) {
                C.push_back(num);
            }
        }
    }
    
    // Функция для сортировки массива C по убыванию методом бинарного дерева
    void binaryTreeSort(std::vector<int>& arr) {
        std::make_heap(arr.begin(), arr.end());
        std::sort_heap(arr.begin(), arr.end(), std::greater<int>());
    }
    
    // Функция для сортировки массива C по убыванию методом подразрядной
    void radixSort(std::vector<int>& arr) {
        int maxElement = *std::max_element(arr.begin(), arr.end());
        for (int div = 1; maxElement / div > 0; div *= 10) {
            std::vector<int> buckets(10, 0);
            std::vector<int> output(arr.size());
    
            for (int num : arr) {
                int index = (num / div) % 10;
                buckets[index]++;
            }
    
            for (int i = 1; i < buckets.size(); i++) {
                buckets[i] += buckets[i - 1];
            }
    
            for (int i = arr.size() - 1; i >= 0; i--) {
                int index = (arr[i] / div) % 10;
                output[buckets[index] - 1] = arr[i];
                buckets[index]--;
            }
    
            arr = output;
        }
    }
    
    int main() {
        std::vector<int> A;
        std::vector<int> B;
        std::vector<int> C;
    
        fillArray(A, 100, -10000, 10000);
        fillArray(B, 100, -10000, 10000);
        C.reserve(A.size() + B.size());
    
        transferElements(A, B, C);
    
        binaryTreeSort(C);
    
        std::cout << "Sorted Array C (using Binary Tree sort method): " << std::endl;
        printArray(C);
    
        radixSort(C);
    
        std::cout << "Sorted Array C (using Radix sort method): " << std::endl;
        printArray(C);
    
        return 0;
    }
    
  5. User

    Выполнить сортировку для массивов размером 100, 1000, 10000. Массивы заполняются случайными числами из диапазона от -10000 до 10000. Ввести массивы А и В. В массив С перенести четные элементы массива А и нечетные элементы массива В. Массив С отсортировать по убыванию, используя сортировку методом бинарного дерева и подразрядной. Напиши программу на c++

  6. Assistant
    #include <iostream>
    #include <random>
    #include <vector>
    #include <algorithm>
    
    void fillArray(std::vector<int>& arr, int size, int min, int max) {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(min, max);
    
        for (int i = 0; i < size; i++) {
            arr.push_back(dis(gen));
        }
    }
    
    void printArray(const std::vector<int>& arr) {
        for (int num : arr) {
            std::cout << num << " ";
        }
        std::cout << std::endl;
    }
    
    void transferElements(const std::vector<int>& A, const std::vector<int>& B, std::vector<int>& C) {
        for (int num : A) {
            if (num % 2 == 0) {
                C.push_back(num);
            }
        }
    
        for (int num : B) {
            if (num % 2 != 0) {
                C.push_back(num);
            }
        }
    }
    
    void binaryTreeSort(std::vector<int>& arr) {
        std::make_heap(arr.begin(), arr.end());
        std::sort_heap(arr.begin(), arr.end(), std::greater<int>());
    }
    
    void radixSort(std::vector<int>& arr) {
        int maxElement = *std::max_element(arr.begin(), arr.end());
        for (int div = 1; maxElement / div > 0; div *= 10) {
            std::vector<int> buckets(10, 0);
            std::vector<int> output(arr.size());
    
            for (int num : arr) {
                int index = (num / div) % 10;
                buckets[index]++;
            }
    
            for (int i = 1; i < buckets.size(); i++) {
                buckets[i] += buckets[i - 1];
            }
    
            for (int i = arr.size() - 1; i >= 0; i--) {
                int index = (arr[i] / div) % 10;
                output[buckets[index] - 1] = arr[i];
                buckets[index]--;
            }
    
            arr = output;
        }
    }
    
    int main() {
        std::vector<int> A;
        std::vector<int> B;
        std::vector<int> C;
    
        fillArray(A, 100, -10000, 10000);
        fillArray(B, 100, -10000, 10000);
        C.reserve(A.size() + B.size());
    
        transferElements(A, B, C);
    
        binaryTreeSort(C);
    
        std::cout << "Sorted Array C (using Binary Tree sort method): " << std::endl;
        printArray(C);
    
        radixSort(C);
    
        std::cout << "Sorted Array C (using Radix sort method): " << std::endl;
        printArray(C);
    
        return 0;
    }
    
  7. User

    Выполнить сортировку для массивов размером 100, 1000, 10000. Массивы заполняются случайными числами из диапазона от -10000 до 10000. Ввести массивы А и В. В массив С перенести четные элементы массива А и нечетные элементы массива В. Массив С отсортировать по убыванию, используя сортировку методом бинарного дерева и подразрядной. Напиши программу на c++

  8. Assistant
    #include <iostream>
    #include <vector>
    #include <algorithm>
    #include <random>
    
    void fillArray(std::vector<int>& arr, int size, int min, int max) {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(min, max);
    
        for (int i = 0; i < size; i++) {
            arr.push_back(dis(gen));
        }
    }
    
    void printArray(const std::vector<int>& arr) {
        for (int num : arr) {
            std::cout << num << " ";
        }
        std::cout << std::endl;
    }
    
    void transferAndSortArrays(const std::vector<int>& A, const std::vector<int>& B, std::vector<int>& C) {
        for (int num : A) {
            if (num % 2 == 0) {
                C.push_back(num);
            }
        }
    
        for (int num : B) {
            if (num % 2 != 0) {
                C.push_back(num);
            }
        }
    
        std::sort(C.begin(), C.end(), std::greater<int>());
    }
    
    void binaryTreeSort(std::vector<int>& arr) {
        std::make_heap(arr.begin(), arr.end());
        std::sort_heap(arr.begin(), arr.end(), std::greater<int>());
    }
    
    void radixSort(std::vector<int>& arr) {
        int maxElement = *std::max_element(arr.begin(), arr.end());
        for (int exp = 1; maxElement/exp > 0; exp *= 10) {
            std::vector<int> output(arr.size());
            std::vector<int> count(10, 0);
    
            for (int num : arr) {
                int digit = (num / exp) % 10;
                count[digit]++;
            }
    
            for (int i = 1; i < count.size(); i++) {
                count[i] += count[i - 1];
            }
    
            for (int i = arr.size() - 1; i >= 0; i--) {
                int digit = (arr[i] / exp) % 10;
                output[count[digit] - 1] = arr[i];
                count[digit]--;
            }
    
            arr = output;
        }
    }
    
    int main() {
        std::vector<int> A;
        std::vector<int> B;
        std::vector<int> C;
    
        fillArray(A, 100, -10000, 10000);
        fillArray(B, 100, -10000, 10000);
    
        transferAndSortArrays(A, B, C);
        std::cout << "Array C (before sorting): " << std::endl;
        printArray(C);
    
        binaryTreeSort(C);
        std::cout << "Array C (after binary tree sort): " << std::endl;
        printArray(C);
    
        radixSort(C);
        std::cout << "Array C (after radix sort): " << std::endl;
        printArray(C);
    
        return 0;
    }
    
  9. User

    напиши код на c++, который выполняет сортировку методом дерева для массива

  10. Assistant
    #include <iostream>
    #include <vector>
    #include <algorithm>
    
    // Структура для узла бинарного дерева
    struct TreeNode {
        int value;
        TreeNode* left;
        TreeNode* right;
    
        TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
    };
    
    // Функция для вставки нового узла в бинарное дерево
    void insertNode(TreeNode*& root, int value) {
        if (root == nullptr) {
            root = new TreeNode(value);
        }
        else if (value < root->value) {
            insertNode(root->left, value);
        }
        else {
            insertNode(root->right, value);
        }
    }
    
    // Функция для построения бинарного дерева на основе массива
    TreeNode* buildBinaryTree(const std::vector<int>& arr) {
        TreeNode* root = nullptr;
        for (int num : arr) {
            insertNode(root, num);
        }
        return root;
    }
    
    // Функция для обхода бинарного дерева в порядке убывания
    void traverseInOrder(TreeNode* root, std::vector<int>& sortedArr) {
        if (root == nullptr) {
            return;
        }
        traverseInOrder(root->right, sortedArr);
        sortedArr.push_back(root->value);
        traverseInOrder(root->left, sortedArr);
    }
    
    // Функция для сортировки массива методом бинарного дерева
    std::vector<int> treeSort(const std::vector<int>& arr) {
        std::vector<int> sortedArr;
        TreeNode* root = buildBinaryTree(arr);
        traverseInOrder(root, sortedArr);
        return sortedArr;
    }
    
    int main() {
        std::vector<int> arr = {5, 2, 9, 1, 7, 3, 6};
        std::vector<int> sortedArr = treeSort(arr);
        std::cout << "Sorted Array: ";
        for (int num : sortedArr) {
            std::cout << num << " ";
        }
        std::cout << std::endl;
        return 0;
    }
    
  11. User

    напиши код на c++, который выполняет сортировку методом дерева для массива, размером n, с случайными числами от -10000 до 10000

  12. Assistant
    #include <iostream>
    #include <vector>
    #include <random>
    
    struct TreeNode {
        int value;
        TreeNode* left;
        TreeNode* right;
    
        TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
    };
    
    void insertNode(TreeNode*& root, int value) {
        if (root == nullptr) {
            root = new TreeNode(value);
        }
        else if (value < root->value) {
            insertNode(root->left, value);
        }
        else {
            insertNode(root->right, value);
        }
    }
    
    TreeNode* buildBinaryTree(const std::vector<int>& arr) {
        TreeNode* root = nullptr;
        for (int num : arr) {
            insertNode(root, num);
        }
        return root;
    }
    
    void traverseInOrder(TreeNode* root, std::vector<int>& sortedArr) {
        if (root == nullptr) {
            return;
        }
        traverseInOrder(root->right, sortedArr);
        sortedArr.push_back(root->value);
        traverseInOrder(root->left, sortedArr);
    }
    
    std::vector<int> treeSort(const std::vector<int>& arr) {
        std::vector<int> sortedArr;
        TreeNode* root = buildBinaryTree(arr);
        traverseInOrder(root, sortedArr);
        return sortedArr;
    }
    
    void fillArray(std::vector<int>& arr, int size, int min, int max) {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(min, max);
    
        for (int i =