C++程序 将数组元素按升序排序

在这里，我们将看到如何使用C ++程序将数组元素按升序排序。以下是示例：

输入： 3 4 5 8 1 10

输出： 1 3 4 5 8 10

输入： 11 34 6 20 40 3

输出： 3 6 11 20 34 40

有两种方法可以在C ++中按升序对数组进行排序：

1. 使用冒泡排序的暴力方法。
2. 使用快速排序的优化方法。

让我们开始讨论这些解决方案。

1. 使用冒泡排序的暴力方法

在这里，使用冒泡排序法使用暴力方法。以下是使用冒泡排序法使用暴力方法将数组按升序排序的C ++程序：

// C ++程序对数组进行排序
//使用暴力方法以升序排列
//使用冒泡排序
#include <bits/stdc++.h>
using namespace std;

void sort(int num[], int len);
void swapNums(int nums[],
              int first, int second);

//驱动程序
int main()
{
    //初始化arrya
    int nums[] = {1, 12, 6, 8, 10};
    int size_nums = (sizeof(nums) /
                     sizeof(nums[0]));

    cout << "排序前数组为： \n";
    for (int i = 0; i < size_nums; i++)
        cout << nums[i] << " ";
    cout << "\n\n";

    sort(nums, size_nums);

    cout << "排序后的数组为： \n";

    for (int i = 0; i < size_nums; i++)
        cout << nums[i] << " ";
    cout << "\n";
    return 0;
}

//排序函数
void sort(int num[], int len)
{
    bool isSwapped;

    /**
     * 在这里，我们运行n-1步骤，
     * 在每个步骤中，最大项将
     * 到达最后一个相应的索引，并交换元素，如果
     * 元素小于先前的元素。
     **/
    for (int i = 0; i < len; i++)
    {
        isSwapped = false;
        for (int j = 1; j < len - i; j++)
        {
            if (num[j] < num[j - 1])
            {
                swapNums(num, j, (j - 1));
                isSwapped = true;
            }
        }
        if (!isSwapped)
        {
            break;
        }
    }
}

//在数组中交换两个数字
void swapNums(int nums[],
              int first, int second)
{
    int curr = nums[first];
    nums[first] = nums[second];
    nums[second] = curr;
}  

输出

排序前数组为：
1 12 6 8 10

排序后的数组为：
1 6 8 10 12 

• 时间复杂度： O（n ^ 2）
• 空间复杂度： O（1）

2. 优化方法使用QuickSort

在这里，使用快速排序算法提供了一种优化的解决方案。以下是使用优化方法使用quicksort将数组按升序排序的C ++程序：

// C++程序，使用优化的快速排序方法将数组按升序排序
#include <bits/stdc++.h>
using namespace std;
 
void quickSort(int nums[],
               int low, int high);
 
// 主函数
int main()
{
    int nums[] = {1, 6, 3, 10, 50};
    int size_nums = (sizeof(nums) /
                     sizeof(nums[0]));
    
    cout << "排序前的数组为: \n";
    for (int i = 0; i < size_nums; i++)
        cout << nums[i] << " ";
    cout << "\n\n";
 
    quickSort(nums, 0, size_nums - 1);
 
    cout << "排序后的数组为: \n";
 
    for (int i = 0; i < size_nums; i++)
        cout << nums[i] << " ";
    cout << "\n";
    return 0;
}
 
/**
 * 将指定的数组按升序排序
 *
 * @param nums 要排序的数组。
 * @param low   说明工作区域的部分。
 * @param high  说明工作区域的部分。
 */
void quickSort(int nums[],
               int low, int high)
{
    // 基本情况
    if (low >= high)
        return;
 
    // 这些仅用于交换元素。
    int start = low, end = high;
    int mid = start + ((end - start) / 2);
    int pivot = nums[mid];
 
    while (start <= end) {
        while (nums[start] < nums[end])
            start++;
        while (nums[end] > pivot)
            end--;
        if (start <= end)
        {
            // 交换开始和结束元素。
            int x = nums[start];
            nums[start] = nums[end];
            nums[end] = x;
            start++;
            end--;
        }
    }
    quickSort(nums, low, end);
    quickSort(nums, start, high);
}  

输出

排序前的数组为: 
1 6 3 10 50 

排序后的数组为: 
1 3 6 10 50 

时间复杂度：

• 最优情况 – O(n log n)
• 最坏情况- O(n 2 )

空间复杂度： O(1)