算法分析| Big – Ω (Big- Omega) 表示法

在算法分析中，渐近符号用于评估算法在最佳情况和最坏情况下的性能。本文将讨论由希腊字母 (Ω) 表示的 Big – Omega Notation。

定义：设 g 和 f 是从自然数集到自身的函数。如果存在常数 c > 0 和自然数 n ₀使得 c*g(n) ≤ f(n) 对于所有 n ≥ n ₀ ，则函数f 称为 Ω(g)

数学表示：

Ω(g) = {f(n): there exist positive constants c and n₀ such that 0 ≤ c*g(n) ≤ f(n) for all n ≥ n₀} 
Note: Ω (g) is a set

图示：

图示

用简单的语言，大 - 欧米茄 (Ω) 表示法指定函数f(n) 的渐近（在极端处）下限。

请按照以下步骤计算 Big – Omega (Ω) 对于任何程序：

1. 将程序分成更小的部分。
2. 假设给定的输入使得程序花费的时间最少，则查找每个段执行的操作数（根据输入大小）。
3. 将所有操作加起来并简化它，假设它是 f(n)。
4. 删除所有常数并选择具有最小阶数的项或当 n 趋于无穷大时始终小于 f(n) 的任何其他函数，假设它是 g(n) 然后，f( n) 是 Ω(g(n))。

示例：考虑一个打印数组所有可能对的示例。这个想法是运行两个嵌套循环来生成给定数组的所有可能对。

伪代码如下：

int print(int a[], int n)
{
    for (int i = 0; i < n; i++) 
    {
        for (int j = 0; j < n; j++)
        {
            if(i != j)
                cout << a[i] << " " 
                     << a[j] << "\n";
        }
    }
}

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to print all possible pairs
int print(int a[], int n)
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i != j)
                cout << a[i] << " " << a[j] << "\n";
        }
    }
}
 
// Driver Code
int main()
{
 
    // Given array
    int a[] = { 1, 2, 3 };
 
    // Store the size of the array
    int n = sizeof(a) / sizeof(a[0]);
 
    // Function Call
    print(a, n);
 
    return 0;
}

Java

// Java program for the above approach
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Function to print all possible pairs
static void print(int a[], int n)
{
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if (i != j)
                System.out.println(a[i] + " " + a[j]);
        }
    }
}
 
// Driver code
public static void main(String[] args)
{
     
    // Given array
    int a[] = { 1, 2, 3 };
 
    // Store the size of the array
    int n = a.length;
 
    // Function Call
    print(a, n);
}
}
 
// This code is contributed by avijitmondal1998

Python3

# Python3 program for the above approach
 
# Function to print all possible pairs
def printt(a, n) :
     
    for i in range(n) :
        for j in range(n) :
            if (i != j) :
                print(a[i], "", a[j])
 
# Driver Code
 
# Given array
a = [ 1, 2, 3 ]
 
# Store the size of the array
n = len(a)
 
# Function Call
printt(a, n)
 
# This code is contributed by splevel62.

C#

// C# program for above approach
using System;
 
class GFG{
 
 
// Function to print all possible pairs
static void print(int[] a, int n)
{
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if (i != j)
                Console.WriteLine(a[i] + " " + a[j]);
        }
    }
}
 
 
// Driver Code
static void Main()
{
     // Given array
    int[] a = { 1, 2, 3 };
 
    // Store the size of the array
    int n = a.Length;
 
    // Function Call
    print(a, n);
}
}
 
// This code is contributed by sanjoy_62.

Javascript

 
// JavaScript program for the above approach
 
// Function to print all possible pairs
function print(a, n)
{
    for(let i = 0; i < n; i++)
    {
        for(let j = 0; j < n; j++)
        {
            if (i != j)
                document.write(a[i] + " " +
                               a[j] + "<br>");
        }
    }
}
 
// Driver Code
 
// Given array
let a = [ 1, 2, 3 ];
 
// Store the size of the array
let n = a.length;
 
// Function Call
print(a, n);
 
// This code is contributed by code_hunt
  

输出

1 2
1 3
2 1
2 3
3 1
3 2

在此示例中，很明显 print 语句执行了 n ²次，因此如果绘制运行时间与 n 的关系图，将获得抛物线图 f(n ² )。现在线性函数 g(n)、对数函数 g(log n)、常数函数 g(1) 在输入范围趋于无穷大时都小于抛物线函数，因此，该程序的最坏情况运行时间可以是 Ω (log n)、Ω(n)、Ω(1) 或当 n 趋于无穷大时小于 n ²的任何函数g(n)。请参见下面的图形表示：

何时使用 Big – Ω 表示法： Big – Ω 表示法是算法分析中使用最少的表示法，因为它可以对算法的性能做出正确但不精确的陈述。假设一个人需要 100 分钟完成一项任务，使用Ω 表示法，可以说这个人需要超过 10 分钟来完成这项任务，这个说法是正确的，但并不精确，因为它没有提到的上限花的时间。类似地，使用 Ω 表示法，我们可以说二进制搜索的最坏情况运行时间是 Ω(1)，这是正确的，因为我们知道二进制搜索至少需要恒定的时间来执行。