ازگر کی مثالوں کے ساتھ بگ او نوٹیشن اور الگورتھم تجزیہ

تعارف

عام طور پر کمپیوٹر پروگرام کا استعمال کرتے ہوئے مسئلہ کو حل کرنے کے متعدد طریقے ہوتے ہیں۔ مثال کے طور پر، ایک صف میں اشیاء کو ترتیب دینے کے کئی طریقے ہیں - آپ استعمال کر سکتے ہیں۔ انضمام کی طرح, بلبلا طرح, اندراج کی طرح، اور اسی طرح. ان تمام الگورتھم کے اپنے اپنے فوائد اور نقصانات ہیں اور ڈویلپر کا کام ان کا وزن کرنا ہے تاکہ وہ کسی بھی استعمال کے معاملے میں استعمال کرنے کے لیے بہترین الگورتھم کا انتخاب کر سکے۔ دوسرے لفظوں میں، اہم سوال یہ ہے کہ کسی مخصوص مسئلے کو حل کرنے کے لیے کون سا الگورتھم استعمال کیا جائے جب اس مسئلے کے متعدد حل موجود ہوں۔

الگورتھم تجزیہ مختلف الگورتھم کی پیچیدگی کے تجزیہ اور ہاتھ میں موجود مسئلے کو حل کرنے کے لیے انتہائی موثر الگورتھم تلاش کرنے سے مراد ہے۔ بگ-او نوٹیشن الگورتھم کی پیچیدگی کو بیان کرنے کے لیے استعمال ہونے والا شماریاتی پیمانہ ہے۔

اس گائیڈ میں، ہم سب سے پہلے الگورتھم تجزیہ کا ایک مختصر جائزہ لیں گے اور پھر بگ-او نوٹیشن پر گہری نظر ڈالیں گے۔ ہم دیکھیں گے کہ مختلف Python فنکشنز کی مدد سے الگورتھم کی پیچیدگی کو تلاش کرنے کے لیے Big-O نوٹیشن کو کس طرح استعمال کیا جا سکتا ہے۔

الگورتھم تجزیہ کیوں اہم ہے؟

یہ سمجھنے کے لیے کہ الگورتھم کا تجزیہ کیوں ضروری ہے، ہم ایک سادہ مثال کی مدد لیں گے۔ فرض کریں کہ ایک مینیجر اپنے دو ملازمین کو Python میں ایک الگورتھم ڈیزائن کرنے کا ٹاسک دیتا ہے جو صارف کے درج کردہ نمبر کے فیکٹریل کا حساب لگاتا ہے۔ پہلے ملازم کی طرف سے تیار کردہ الگورتھم اس طرح لگتا ہے:

def fact(n):
    product = 1
    for i in range(n):
        product = product * (i+1)
    return product

print(fact(5))

غور کریں کہ الگورتھم محض ایک عدد عدد کو بطور دلیل لیتا ہے۔ کے اندر fact() نامی ایک متغیر کو فنکشن کریں۔ product کے لئے شروع کیا جاتا ہے 1. ایک لوپ سے عمل کرتا ہے۔ 1 کرنے کے لئے n اور ہر تکرار کے دوران، میں قدر product لوپ کے ذریعہ دہرائی جانے والی تعداد سے ضرب کیا جاتا ہے اور نتیجہ میں محفوظ کیا جاتا ہے۔ product متغیر دوبارہ. لوپ کے مکمل ہونے کے بعد، product متغیر فیکٹریل پر مشتمل ہوگا۔

اسی طرح، دوسرے ملازم نے بھی ایک الگورتھم تیار کیا جو ایک عدد کے فیکٹوریل کا حساب لگاتا ہے۔ دوسرے ملازم نے عدد کے فیکٹوریل کا حساب لگانے کے لیے ایک تکراری فنکشن کا استعمال کیا۔ n:

def fact2(n):
    if n == 0:
        return 1
    else:
        return n * fact2(n-1)

print(fact2(5))

مینیجر کو فیصلہ کرنا ہے کہ کون سا الگورتھم استعمال کرنا ہے۔ ایسا کرنے کے لیے، انہوں نے فیصلہ کیا ہے کہ کون سا الگورتھم تیزی سے چلتا ہے۔ ایسا کرنے کا ایک طریقہ یہ ہے کہ کوڈ کو ایک ہی ان پٹ پر عمل میں لانے کے لیے درکار وقت تلاش کرنا۔

Jupyter نوٹ بک میں، آپ استعمال کر سکتے ہیں۔ %timeit لٹریل کے بعد فنکشن کال کے بعد فنکشن کو عمل میں لانے میں لگنے والا وقت معلوم کرنے کے لیے:

%timeit fact(50)

یہ ہمیں دے گا:

9 µs ± 405 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

آؤٹ پٹ کا کہنا ہے کہ الگورتھم لیتا ہے۔ 9 مائیکرو سیکنڈز (پلس/مائنس 45 نینو سیکنڈ) فی لوپ۔

اسی طرح، ہم حساب لگا سکتے ہیں کہ دوسرے نقطہ نظر کو انجام دینے میں کتنا وقت لگتا ہے:

%timeit fact2(50)

اس کا نتیجہ یہ ہوگا:

15.7 µs ± 427 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

دوسرا الگورتھم جس میں تکرار شامل ہے۔ 15 مائیکرو سیکنڈز (پلس/مائنس 427 نینو سیکنڈز)۔

عمل درآمد کا وقت ظاہر کرتا ہے کہ پہلا الگورتھم دوسرے الگورتھم کے مقابلے میں تیز ہے جس میں تکرار شامل ہے۔ بڑے آدانوں کے ساتھ کام کرتے وقت، کارکردگی کا فرق زیادہ اہم ہو سکتا ہے۔

تاہم، الگورتھم کی پیچیدگی کی پیمائش کرنے کے لیے عملدرآمد کا وقت اچھا میٹرک نہیں ہے کیونکہ یہ ہارڈ ویئر پر منحصر ہے۔ الگورتھم کے لیے زیادہ معروضی پیچیدگی کے تجزیہ میٹرک کی ضرورت ہے۔ یہ ہے جہاں بڑا اے نوٹیشن کھیلنے کے لئے آتا ہے.

بگ-او نوٹیشن کے ساتھ الگورتھم تجزیہ

Big-O نوٹیشن الگورتھم کے ان پٹ اور الگورتھم کو انجام دینے کے لیے درکار اقدامات کے درمیان تعلق کی نشاندہی کرتا ہے۔ اسے ایک بڑے "O" سے ظاہر کیا جاتا ہے جس کے بعد افتتاحی اور بند ہونے والا قوسین ہوتا ہے۔ قوسین کے اندر، ان پٹ اور الگورتھم کے ذریعے اٹھائے گئے اقدامات کے درمیان تعلق کو "n" کا استعمال کرتے ہوئے پیش کیا جاتا ہے۔

اہم ٹیک وے ہے – Big-O کو a میں کوئی دلچسپی نہیں ہے۔ خاص طور پر مثال جس میں آپ الگورتھم چلاتے ہیں، جیسے fact(50)، بلکہ، یہ کتنی اچھی طرح سے کرتا ہے۔ پیمانے بڑھتی ہوئی ان پٹ دی جاتی ہے۔ یہ ایک ٹھوس مثال کے لئے ٹھوس وقت کے مقابلے میں تشخیص کے لئے ایک بہت بہتر میٹرک ہے!

مثال کے طور پر، اگر ایک ہے لکیری رشتہ ان پٹ اور الگورتھم کی طرف سے اس کے عمل کو مکمل کرنے کے لیے اٹھائے گئے قدم کے درمیان، استعمال شدہ Big-O اشارے اے (ن). اسی طرح، Big-O اشارے کے لیے چوکور افعال is O(n²).

وجدان پیدا کرنے کے لیے:

• اے (ن): پر n=1، 1 قدم اٹھایا گیا ہے۔ پر n=10، 10 قدم اٹھائے گئے ہیں۔
• O(n²): پر n=1، 1 قدم اٹھایا گیا ہے۔ پر n=10، 100 قدم اٹھائے گئے ہیں۔

At n=1، یہ دونوں ایک ہی کارکردگی کا مظاہرہ کریں گے! یہ ایک اور وجہ ہے کہ ان پٹ اور اس ان پٹ کو پروسیس کرنے کے اقدامات کی تعداد کے درمیان تعلق کا مشاہدہ کچھ ٹھوس ان پٹ کے ساتھ فنکشن کا جائزہ لینے سے بہتر ہے۔

مندرجہ ذیل کچھ سب سے زیادہ عام Big-O افعال ہیں:

نام	بگ اے
مسلسل	O (c)
لکیری	اے (ن)
چوک	O(n²)
کیوبک	O(n³)
متوقع	O(2ⁿ)
لوگرتھمک	O (لاگ (ن))
لکیری لاگ ان کریں۔	O(nlog(n))

آپ ان افعال کا تصور کر سکتے ہیں اور ان کا موازنہ کر سکتے ہیں:

عام طور پر - لکیری سے بدتر کسی بھی چیز کو بری پیچیدگی (یعنی ناکارہ) سمجھا جاتا ہے اور اگر ممکن ہو تو اس سے بچنا چاہیے۔ لکیری پیچیدگی ٹھیک ہے اور عام طور پر ایک ضروری برائی ہے۔ لوگاریتھمک اچھا ہے۔ مستقل حیرت انگیز ہے!

بگ-O کا حساب کیسے لگایا جاتا ہے اس کا اندازہ حاصل کرنے کے لیے، آئیے مستقل، لکیری، اور چوکور پیچیدگی کی کچھ مثالوں پر ایک نظر ڈالیں۔

مستقل پیچیدگی - O(C)

الگورتھم کی پیچیدگی کو مستقل کہا جاتا ہے اگر الگورتھم کے عمل کو مکمل کرنے کے لیے درکار اقدامات مستقل رہیں، قطع نظر ان پٹ کی تعداد۔ مسلسل پیچیدگی کی طرف سے اشارہ کیا جاتا ہے O (c) کہاں c کوئی بھی مستقل نمبر ہو سکتا ہے۔

آئیے Python میں ایک سادہ الگورتھم لکھتے ہیں جو فہرست میں پہلی آئٹم کا مربع تلاش کرتا ہے اور پھر اسے اسکرین پر پرنٹ کرتا ہے:

def constant_algo(items):
    result = items[0] * items[0]
    print(result)

constant_algo([4, 5, 6, 8])

اوپر کے اسکرپٹ میں، ان پٹ سائز سے قطع نظر، یا ان پٹ لسٹ میں آئٹمز کی تعداد items، الگورتھم صرف 2 مراحل انجام دیتا ہے:

1. پہلے عنصر کا مربع تلاش کرنا
2. اسکرین پر نتیجہ پرنٹ کرنا۔

لہذا، پیچیدگی مسلسل رہتی ہے.

اگر آپ مختلف سائز کے ساتھ لائن پلاٹ کھینچتے ہیں۔ items X-axis پر ان پٹ اور Y-axis پر قدموں کی تعداد، آپ کو ایک سیدھی لکیر ملے گی۔ آئیے اس کو دیکھنے میں ہماری مدد کے لیے ایک مختصر اسکرپٹ بنائیں۔ ان پٹ کی تعداد سے کوئی فرق نہیں پڑتا، عمل میں آنے والے اقدامات کی تعداد ایک جیسی رہتی ہے:

steps = []
def constant(n):
    return 1
    
for i in range(1, 100):
    steps.append(constant(i))
plt.plot(steps)

لکیری پیچیدگی - اے (ن)

الگورتھم کی پیچیدگی کو لکیری کہا جاتا ہے اگر الگورتھم کے عمل کو مکمل کرنے کے لیے درکار اقدامات ان پٹ کی تعداد کے ساتھ لکیری طور پر بڑھتے یا کم ہوتے ہیں۔ لکیری پیچیدگی کی طرف سے اشارہ کیا جاتا ہے اے (ن).

اس مثال میں، آئیے ایک سادہ پروگرام لکھتے ہیں جو فہرست میں موجود تمام اشیاء کو کنسول میں دکھاتا ہے:

def linear_algo(items):
    for item in items:
        print(item)

linear_algo([4, 5, 6, 8])

کی پیچیدگی linear_algo() فنکشن اوپر کی مثال میں لکیری ہے کیونکہ for-loop کی تکرار کی تعداد ہوگی۔ ان پٹ کے سائز کے برابر items صف. مثال کے طور پر، اگر میں 4 آئٹمز ہیں۔ items فہرست، فار لوپ کو 4 بار عمل میں لایا جائے گا۔

آئیے جلدی سے لکیری پیچیدگی الگورتھم کے لیے ایک پلاٹ بنائیں جس میں x-axis پر ان پٹ کی تعداد اور y-axis پر قدموں کی تعداد ہے:

steps = []
def linear(n):
    return n
    
for i in range(1, 100):
    steps.append(linear(i))
    
plt.plot(steps)
plt.xlabel('Inputs')
plt.ylabel('Steps')

اس کا نتیجہ یہ ہوگا:

نوٹ کرنے کے لئے ایک اہم بات یہ ہے کہ بڑے ان پٹ کے ساتھ، مستقل قدر کو کھو دیتے ہیں۔ یہی وجہ ہے کہ ہم عام طور پر بگ-O اشارے سے مستقل کو ہٹا دیتے ہیں، اور O(2n) جیسے اظہار کو عام طور پر O(n) میں مختصر کر دیا جاتا ہے۔ O(2n) اور O(n) دونوں لکیری ہیں - لکیری تعلق وہی ہے جو اہمیت رکھتا ہے، ٹھوس قدر نہیں۔ مثال کے طور پر، آئیے میں ترمیم کریں۔ linear_algo():

def linear_algo(items):
    for item in items:
        print(item)

    for item in items:
        print(item)

linear_algo([4, 5, 6, 8])

دو فار لوپس ہیں جو ان پٹ پر اعادہ کرتے ہیں۔ items فہرست لہذا الگورتھم کی پیچیدگی بن جاتی ہے۔ O (2n)تاہم، ان پٹ لسٹ میں لامحدود آئٹمز کی صورت میں، انفینٹی کا دو بار پھر بھی انفینٹی کے برابر ہے۔ ہم مستقل کو نظر انداز کر سکتے ہیں۔ 2 (چونکہ یہ بالآخر غیر اہم ہے) اور الگورتھم کی پیچیدگی باقی ہے۔ اے (ن).

آئیے X-axis پر ان پٹ اور Y-axis پر قدموں کی تعداد کو پلاٹ کرکے اس نئے الگورتھم کا تصور کرتے ہیں:

steps = []
def linear(n):
    return 2*n
    
for i in range(1, 100):
    steps.append(linear(i))
    
plt.plot(steps)
plt.xlabel('Inputs')
plt.ylabel('Steps')

اوپر کے اسکرپٹ میں، آپ اسے واضح طور پر دیکھ سکتے ہیں۔ y=2nتاہم، آؤٹ پٹ لکیری ہے اور اس طرح نظر آتی ہے:

چوکور پیچیدگی - O(n²)

الگورتھم کی پیچیدگی کو اس وقت چوکور کہا جاتا ہے جب الگورتھم کو عمل میں لانے کے لیے درکار اقدامات ان پٹ میں آئٹمز کی تعداد کا چوکور فنکشن ہوتے ہیں۔ چوکور پیچیدگی کے طور پر بیان کیا جاتا ہے O(n²):

def quadratic_algo(items):
    for item in items:
        for item2 in items:
            print(item, ' ' ,item2)

quadratic_algo([4, 5, 6, 8])

ہمارے پاس ایک بیرونی لوپ ہے جو ان پٹ لسٹ میں موجود تمام آئٹمز کے ذریعے اعادہ کرتا ہے اور پھر ایک نیسٹڈ اندرونی لوپ، جو دوبارہ ان پٹ لسٹ میں موجود تمام آئٹمز کے ذریعے دہراتا ہے۔ کئے گئے اقدامات کی کل تعداد n*n ہے، جہاں n ان پٹ اری میں آئٹمز کی تعداد ہے۔

درج ذیل گراف چوکور پیچیدگی کے ساتھ الگورتھم کے مراحل کے خلاف ان پٹ کی تعداد کو پلاٹ کرتا ہے:

لوگاریتھمک پیچیدگی - O (لاگ آن)

کچھ الگورتھم لوگارتھمک پیچیدگی حاصل کرتے ہیں، جیسے ثنائی تلاش. ثنائی تلاش ایک صف میں ایک عنصر کی تلاش کرتا ہے، چیک کرکے مشرق ایک صف کی، اور آدھے حصے کو کاٹنا جس میں عنصر نہیں ہے۔ یہ بقیہ نصف کے لیے دوبارہ کرتا ہے، اور عنصر کے ملنے تک وہی اقدامات جاری رکھتا ہے۔ ہر قدم میں، یہ آدھے حصے صف میں عناصر کی تعداد۔

اس کے لیے صف کو ترتیب دینے کی ضرورت ہوتی ہے، اور ہمارے لیے ڈیٹا کے بارے میں ایک قیاس کرنا ہوتا ہے (جیسے کہ اسے ترتیب دیا گیا ہے)۔

جب آپ آنے والے ڈیٹا کے بارے میں قیاس کر سکتے ہیں، تو آپ ایسے اقدامات کر سکتے ہیں جو الگورتھم کی پیچیدگی کو کم کر دیں۔ لوگاریتھمک پیچیدگی مطلوب ہے، کیونکہ یہ اعلیٰ درجے کی ان پٹ کے ساتھ بھی اچھی کارکردگی حاصل کرتی ہے۔

پیچیدہ افعال کی پیچیدگی کو تلاش کرنا؟

پچھلی مثالوں میں، ہمارے پاس ان پٹ پر کافی آسان افعال تھے۔ اگرچہ، ہم ان فنکشنز کے Big-O کا حساب کیسے لگاتے ہیں جو ان پٹ پر دوسرے فنکشنز کو (متعدد) کال کرتے ہیں؟

آئیے ایک نظر ڈالیں:

def complex_algo(items):

    for i in range(5):
        print("Python is awesome")

    for item in items:
        print(item)

    for item in items:
        print(item)

    print("Big O")
    print("Big O")
    print("Big O")

complex_algo([4, 5, 6, 8])

اوپر دیے گئے اسکرپٹ میں کئی کام کیے جا رہے ہیں، سب سے پہلے کنسول پر ایک تار 5 بار پرنٹ کیا جاتا ہے۔ print بیان اگلا، ہم ان پٹ لسٹ کو اسکرین پر دو بار پرنٹ کرتے ہیں، اور آخر میں، کنسول پر ایک اور سٹرنگ تین بار پرنٹ کی جاتی ہے۔ اس طرح کے الگورتھم کی پیچیدگی کو تلاش کرنے کے لیے، ہمیں الگورتھم کوڈ کو حصوں میں توڑنا ہوگا اور انفرادی ٹکڑوں کی پیچیدگی کو تلاش کرنے کی کوشش کرنی ہوگی۔ ہر ٹکڑے کی پیچیدگی کو نشان زد کریں۔

پہلے حصے میں ہمارے پاس ہے:

for i in range(5):
	print("Python is awesome")

اس حصے کی پیچیدگی ہے۔ O (5) چونکہ ان پٹ سے قطع نظر کوڈ کے اس ٹکڑے میں پانچ مستقل اقدامات کیے جا رہے ہیں۔

اگلا، ہمارے پاس ہے:

for item in items:
	print(item)

ہم جانتے ہیں کہ کوڈ کے مذکورہ ٹکڑے کی پیچیدگی کیا ہے۔ اے (ن). اسی طرح، کوڈ کے درج ذیل ٹکڑے کی پیچیدگی بھی ہے۔ اے (ن):

for item in items:
	print(item)

آخر میں، کوڈ کے مندرجہ ذیل ٹکڑے میں، ایک تار تین بار پرنٹ کیا جاتا ہے، اس وجہ سے پیچیدگی ہے O (3):

print("Big O")
print("Big O")
print("Big O")

مجموعی پیچیدگی کو تلاش کرنے کے لئے، ہمیں صرف ان انفرادی پیچیدگیوں کو شامل کرنا ہوگا:

O(5) + O(n) + O(n) + O(3)

مندرجہ بالا کو آسان بنانے سے ہمیں ملتا ہے:

O(8) + O(2n) = O(8+2n)

ہم نے پہلے کہا تھا کہ جب ان پٹ (جس کی اس معاملے میں لمبائی n ہے) بہت بڑی ہو جاتی ہے تو مستقل غیر معمولی ہو جاتے ہیں یعنی انفینٹی کا دو بار یا نصف اب بھی انفینٹی ہی رہتا ہے۔ لہذا، ہم مستقل کو نظر انداز کر سکتے ہیں. الگورتھم کی حتمی پیچیدگی ہوگی۔ اے (ن)!

بدترین بمقابلہ بہترین کیس کی پیچیدگی

عام طور پر، جب کوئی آپ سے الگورتھم کی پیچیدگی کے بارے میں پوچھتا ہے - وہ بدترین کیس کی پیچیدگی (Big-O) میں دلچسپی رکھتے ہیں۔ بعض اوقات، وہ بہترین کیس کی پیچیدگی میں بھی دلچسپی لے سکتے ہیں (بگ اومیگا)۔

ان کے درمیان تعلق کو سمجھنے کے لیے، آئیے کوڈ کے ایک اور ٹکڑے پر ایک نظر ڈالتے ہیں:

def search_algo(num, items):
    for item in items:
        if item == num:
            return True
        else:
            pass
nums = [2, 4, 6, 8, 10]

print(search_algo(2, nums))

اوپر کے اسکرپٹ میں، ہمارے پاس ایک فنکشن ہے جو ایک نمبر اور نمبروں کی فہرست کو بطور ان پٹ لیتا ہے۔ اگر پاس کردہ نمبر نمبروں کی فہرست میں پایا جاتا ہے تو یہ درست لوٹتا ہے، بصورت دیگر، یہ واپس آجاتا ہے۔ None. اگر آپ فہرست میں 2 تلاش کریں گے، تو یہ پہلے مقابلے میں ملے گا۔ یہ الگورتھم کی بہترین کیس پیچیدگی ہے جس میں تلاش کی گئی چیز پہلے تلاش کی گئی انڈیکس میں پائی جاتی ہے۔ بہترین کیس کی پیچیدگیاس صورت میں، ہے O (1). دوسری طرف، اگر آپ 10 کو تلاش کرتے ہیں، تو یہ آخری سرچ کردہ انڈیکس پر پائے گا۔ الگورتھم کو فہرست میں موجود تمام اشیاء کو تلاش کرنا پڑے گا، اس لیے بدترین کیس کی پیچیدگی ہو جاتا ہے اے (ن).

بہترین اور بدترین کیس کی پیچیدگی کے علاوہ، آپ حساب بھی کر سکتے ہیں۔ اوسط پیچیدگی ایک الگورتھم کا (بگ تھیٹا)، جو آپ کو بتاتا ہے کہ "ایک بے ترتیب ان پٹ دیے جانے پر، الگورتھم کی متوقع وقت کی پیچیدگی کیا ہے"؟

خلائی پیچیدگی

وقت کی پیچیدگی کے علاوہ، جہاں آپ الگورتھم کو مکمل کرنے کے لیے درکار مراحل کی تعداد گنتے ہیں، آپ یہ بھی تلاش کر سکتے ہیں خلائی پیچیدگی جس سے مراد وہ جگہ ہے جو آپ کو کسی پروگرام کے عمل کے دوران میموری میں مختص کرنے کی ضرورت ہے۔

درج ذیل مثال پر ایک نظر ڈالیں:

def return_squares(n):
    square_list = []
    for num in n:
        square_list.append(num * num)

    return square_list

nums = [2, 4, 6, 8, 10]
print(return_squares(nums))

۔ return_squares() فنکشن انٹیجرز کی فہرست کو قبول کرتا ہے اور متعلقہ چوکوں کے ساتھ ایک فہرست واپس کرتا ہے۔ الگورتھم کو آئٹمز کی اتنی ہی تعداد کے لیے میموری مختص کرنی ہوتی ہے جتنی ان پٹ لسٹ میں ہوتی ہے۔ لہذا، الگورتھم کی خلائی پیچیدگی بن جاتی ہے۔ اے (ن).

نتیجہ

Big-O اشارے ایک معیاری میٹرک ہے جو الگورتھم کی پیچیدگی کو ماپنے کے لیے استعمال ہوتا ہے۔ اس گائیڈ میں، ہم نے مطالعہ کیا کہ Big-O نوٹیشن کیا ہے اور اسے مختلف الگورتھم کی پیچیدگی کی پیمائش کے لیے کیسے استعمال کیا جا سکتا ہے۔ ہم نے Python کی مختلف مثالوں کی مدد سے مختلف قسم کے Big-O فنکشنز کا بھی مطالعہ کیا۔ آخر میں، ہم نے خلائی پیچیدگی کے ساتھ ساتھ بدترین اور بہترین کیس کی پیچیدگی کا مختصر جائزہ لیا۔