C++:按升序对数组的初始部分进行排序，按降序对其他部分进行排序

C++:Sort the initial part of an array in ascending and the other part in descending order

本文关键字：排序 其他部 降序 升序 数组 C++ 始部      更新时间：2023-10-16

我是C++的新手，我正在努力做到这一点：

我有一个N元素的数组。用户应该能够输入数组的所有元素和数字K。之后，我必须对数组进行排序，以使第一部分（元素1到K）以升序排序，而第二部分（元素K到N

排序功能由我自己实现。我可以使用cstdlib中的qsort，但它不那么有趣。

我已经编写了对数组进行排序的代码，但我不明白如何将数组分为两部分进行排序。

#include <iostream>
#include <string>
void print_array(int[], int);
void qsort(int[], int, int);
int main()
{
    int array_length;
    int *array, k;
    std::cout << "Write array length: ";
    std::cin >> array_length;
    array = new int[array_length];
    for (int i = 0; i < array_length; i++) {
        std::cout << "Write " << i + 1 << " element: ";
        std::cin >> array[i];
    }
    print_array(array, array_length);
    do {
        std::cout << "Write k: ";
        std::cin >> k;
    } while (k >= array_length);
    qsort(array, 0, k);
    print_array(array, array_length);
}

void print_array(int* array, int length) {
    for (int i = 0; i < length; i++) {
        std::cout << array[i] << "n";
    }
}
void qsort(int arr[], int fst, int last)
{
    int i, j, pivot, tmp;
    if (fst < last)
    {
        pivot = fst;
        i = fst;
        j = last;
        while (i < j)
        {
            while (arr[i] <= arr[pivot] && i < last)
                i++;
            while (arr[j] > arr[pivot])
                j--;
            if (i < j)
            {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
        tmp = arr[pivot];
        arr[pivot] = arr[j];
        arr[j] = tmp;
        qsort(arr, fst, j - 1);
        qsort(arr, j + 1, last);
    }
}

您正在使用对一半进行排序

qsort(array, 0, k);

同样，你需要对另一半进行排序：

qsort(array+k, 0, array_length-k);

现在，问题是这两个部分将按升序排列。因此，您需要一种方法来告诉qsort()按升序对一半进行排序，按降序对另一半进行排序。将另一个标志传递给qsort()以更改交换顺序。所以你可以用一个bool来表示它：

void qsort(int arr[], int fst, int last, bool pass)
{
           ....
           if (pass && i < j)
            {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
            if(!pass && i > j) {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
       ...
       qsort(arr, fst, j - 1, pass); 
       qsort(arr, j + 1, last, pass);

}

当你调用它时，你可以通过true和false来"切换"交换订单：

  qsort(array, 0, k, true);
  qsort(array+k, 0, array_length-k, false);

相应地更改qsort()的原型。

您只需要替换以下行，就可以按降序获取数据：

        //while (arr[i] <= arr[pivot] && i < last)
        while (arr[i] >= arr[pivot] && i < last)
            i++;
        //while (arr[j] > arr[pivot])
        while (arr[j] < arr[pivot])

据我所见，您的数组包含纯整数值，这些值本质上是基元的，可以使用c++排序方法进行排序。

#include <algorithm> // this is to access c++ std::sort method
...
std::sort(array + first, array + last) // input range of index of array to be sorted
...

这应该会解决的。

需要注意的另一点是，默认情况下，这是按升序排序的。所以您可以使用CompareTo方法和所有这些方法。但我最喜欢的技巧是将-1乘以数组中的所有值，然后对其进行排序，再乘以-1，最后数组按降序排序。

C++编写数组和其他数据序列算法的方法是通过迭代器：

template <typename Iter>
void qsort(Iter begin, Iter end)
{
    auto pivot = begin + (end - begin) / 2;
    std::nth_element(begin, pivot, end);
    qsort(begin, pivot);
    qsort(pivot + 1, end);
}

将其与reverse_iterator相结合，我们将获得您想要的行为：

auto lhBegin = array;
auto lhEnd = array + K;
qsort(lhBegin, lhEnd);
// [ 0, 1, ..., K-2, K-1 ] is now in sorted order
auto rhBegin = std::make_reverse_iterator(array + N);
auto rhEnd = std::make_reverse_iterator(array + K);
qsort(rhBegin, rhEnd);
// [ N-1, N-2, ..., K+1, K ] is now in sorted order
相关文章：