📜  选择排序VS气泡排序

📅  最后修改于: 2021-04-22 00:35:21             🧑  作者: Mango

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

时间复杂度- 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


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<


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 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