选择排序VS气泡排序

在本文中，我们将介绍选择排序与气泡排序之间的比较。基于时间和空间复杂度的选择排序和气泡排序算法所需的资源如下。

时间复杂度- $O(n^2)$相同的复杂度- $O(1)$

让我们深入研究这些算法的工作。
选择排序：
选择排序算法通常是教给我们的第一个排序算法。在此，在内部循环的每次迭代中，最小的元素将替换为每个循环中的起始元素。在每个循环结束之后，我们将起始位置增加1并运行直到数组中的倒数第二个元素。因此，通过在外部循环的末尾进行操作，我们将获得一个排序数组。
下图说明了选择排序算法的迭代过程。

在这里，我们可以简化选择排序算法，方法是说这里的排序是根据最小到最大元素进行的。首先对最小的元素进行排序，然后对第二个最小的元素进行排序，依此类推。
选择排序的实现：
下面是上述算法的实现。

C++

#include 
using namespace std;
void Selection_Sort(int arr[], int n) 
{
    for(int i = 0; i < n - 1; ++i) 
    {
        int min_index = i; 
        for(int j = i + 1; j < n; ++j) 
        {
            if(arr[j] < arr[min_index]) 
                min_index = j;
        }
        swap(arr[i], arr[min_index]); 
    }
}
int main()
{
    int n = 5;
    int arr[5] = {2, 0, 1, 4, 3};
    Selection_Sort(arr, n);
    cout<<"The Sorted Array by using Selection Sort is : ";
    for(int i = 0; i < n; ++i)
        cout<

---

Java

class GFG{
 
  static void Selection_Sort(int arr[], int n) 
  {
    for(int i = 0; i < n - 1; ++i) 
    {
      int min_index = i; 
      for(int j = i + 1; j < n; ++j) 
      {
        if(arr[j] < arr[min_index]) 
          min_index = j;
      }
      int temp = arr[i];
      arr[i] = arr[min_index];
      arr[min_index] = temp;
    }
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int n = 5;
    int arr[] = {2, 0, 1, 4, 3};
    Selection_Sort(arr, n);
    System.out.print("The Sorted Array by using Selection Sort is : ");
    for(int i = 0; i < n; ++i)
      System.out.print(arr[i] + " ");
  }
}
 
// This code is contributed by aashish1995

C#

using System;
 
public class GFG{
 
  static void Selection_Sort(int []arr, int n) 
  {
    for(int i = 0; i < n - 1; ++i) 
    {
      int min_index = i; 
      for(int j = i + 1; j < n; ++j) 
      {
        if(arr[j] < arr[min_index]) 
          min_index = j;
      }
      int temp = arr[i];
      arr[i] = arr[min_index];
      arr[min_index] = temp;
    }
  }
 
  // Driver code
  public static void Main(String[] args)
  {
    int n = 5;
    int []arr = {2, 0, 1, 4, 3};
    Selection_Sort(arr, n);
    Console.Write("The Sorted Array by using Selection Sort is : ");
    for(int i = 0; i < n; ++i)
      Console.Write(arr[i] + " ");
  }
}
 
// This code is contributed by aashish1995

Javascript

 
// JavaScript program for above approach
 
    function Selection_Sort(arr, n)
  {
    for(let i = 0; i < n - 1; ++i)
    {
      let min_index = i;
      for(let j = i + 1; j < n; ++j)
      {
        if(arr[j] < arr[min_index])
          min_index = j;
      }
      let temp = arr[i];
      arr[i] = arr[min_index];
      arr[min_index] = temp;
    }
  }
 
// Driver Code
 
    let n = 5;
    let arr = [2, 0, 1, 4, 3];
    Selection_Sort(arr, n);
    document.write("The Sorted Array by using Selection Sort is : ");
    for(let i = 0; i < n; ++i)
      document.write(arr[i] + " ");
 

---

输出

The Sorted Array by using Selection Sort is : 0 1 2 3 4 

气泡排序：
气泡排序算法在我们初次研究时可能会有些混乱。但这是对它的简单解释。在此交换以两种方式进行。在外循环的每次迭代中，都会找到最大的元素，并与循环中的最后一个元素交换。在内部循环中，我们进行两个连续元素的成对交换。在每个内部循环中，我们都从第一个元素转到上一个循环中少一个的元素。下图显示了冒泡排序算法中内部循环的第一次迭代。

在这里，我们可以简化选择排序算法，方法是说这里的排序是根据最大到最小元素进行的。最大的元素首先保留在数组的最后位置。然后是倒数第二个第二大元素，依此类推。
Bubble Sort的实现：
下面是上述算法的实现。

C++

#include 
using namespace std;
void Bubble_Sort(int arr[], int n) 
{
    for(int i = 1; i < n; ++i)     
    {   
                for(int j = 0; j <= (n - i - 1); ++j)  
        {   
            if(arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]); 
        }
    }
}
 
int main()
{
    int n = 5;
    int arr[5] = {2, 0, 1, 4, 3};
    Bubble_Sort(arr, n);
    cout<<"The Sorted Array by using Bubble Sort is : ";
    for(int i = 0; i < n; ++i)
        cout<

输出

The Sorted Array by using Bubble Sort is : 0 1 2 3 4 

向气泡排序添加智能：

1. 我们必须考虑以下事实：即使我们的数据最初是排序形式的，我们当前的算法也会执行所有迭代。
2. 如上面的代码所示，当arr [i]> arr [i + 1]时，我们交换两个元素(例如i和i + 1)。因此，即使我们的数据已经排序(或仅在几次迭代后排序)，我们的算法仍会运行，
3. 但是，我们可以调整代码，以便我们的算法能够识别给定数据的排序时间，并且不需要进一步的迭代。
4. 我们可以通过简单地添加一个“标志”变量来实现。在任何内部条件(arr [j]> arr [j + 1])为真时，将“ flag”变量初始化为false并在内部循环之外将其设置为true。
5. 退出内循环后，检查标志。如果标志== true，即更改了标志并执行了交换操作。但是，如果flag == false，则表示在整个迭代过程中均未进行任何交换，因此我们的数据现在已排序，并且不需要进一步的迭代。

C++

// CPP program for the above approach
#include 
using namespace std;
 
// Function for bubble sort
void Bubble_Sort(int arr[], int n)
{
    bool flag;
   
    // Iterate from 1 to n - 1
    for (int i = 1; i < n; ++i) {
 
        flag = false;
       
        // Iterate from 0 to n - i - 1
        for (int j = 0; j <= (n - i - 1); ++j) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                flag = true;
            }
        }
        if (flag == false)
            break;
    }
}
 
// Driver Code
int main()
{
    int n = 5;
    int arr[5] = { 2, 0, 1, 4, 3 };
    Bubble_Sort(arr, n);
    cout << "The Sorted Array by using Bubble Sort is : ";
    for (int i = 0; i < n; ++i)
        cout << arr[i] << " ";
    return 0;
}

输出

The Sorted Array by using Bubble Sort is : 0 1 2 3 4 

注意：这项微小的调整不会改变冒泡排序算法在最坏情况下的时间复杂度，但是可以改善其在特定情况下的运行时间。

参考 ：
讲座阅读
实施冒泡排序c

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。