ازگر میں منسلک فہرستیں۔

تعارف

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

منسلک فہرستوں کے فائدے اور نقصانات

لنک شدہ فہرستیں دوسرے ڈیٹا ڈھانچے کے مقابلے میں کئی فوائد پیش کرتی ہیں۔ سب سے پہلے، وہ عناصر کے موثر اندراج اور حذف کرنے کی اجازت دیتے ہیں، کیونکہ انہیں صرف پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنے کی ضرورت ہوتی ہے۔ یہ LinkedLists کو ان منظرناموں کے لیے مثالی بناتا ہے جہاں بار بار ترمیم کی توقع کی جاتی ہے۔ مزید برآں، LinkedLists متحرک طور پر بڑھ سکتی ہیں یا سائز میں سکڑ سکتی ہیں، صفوں کے برعکس، جن کا سائز مقرر ہے۔

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

ازگر میں منسلک فہرستوں کو نافذ کرنا

Python لنکڈ فہرستوں کو نافذ کرنے کا ایک لچکدار اور بدیہی طریقہ فراہم کرتا ہے۔ لنکڈ لسٹ کی تین اہم اقسام ہیں: سنگلی لنکڈ لسٹ، ڈبل لنکڈ لسٹ، اور سرکلر لنکڈ لسٹ۔ آئیے ان میں سے ہر ایک کو تفصیل سے دیکھیں۔

سنگل لنکڈ لسٹ

سنگلی لنکڈ لسٹ نوڈس پر مشتمل ہوتی ہے جہاں ہر نوڈ میں ایک قدر اور ترتیب میں اگلے نوڈ کا حوالہ ہوتا ہے۔ یہاں یہ ہے کہ آپ Python میں سنگلی لنکڈ لسٹ کیسے بنا سکتے ہیں:

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class Linked List:
    def __init__(self):
        self.head = None

سنگل لنکڈ لسٹ بنانا

سنگلی لنکڈ لسٹ بنانے کے لیے، ہمیں نوڈ کلاس کی وضاحت کرنی ہوگی جو فہرست میں ہر نوڈ کی نمائندگی کرے۔ ہر نوڈ میں ایک قدر اور اگلے نوڈ کا حوالہ ہوتا ہے۔ لنکڈ لسٹ کلاس نوڈس کے لیے کنٹینر کے طور پر کام کرتی ہے، جس میں سر کی خصوصیت فہرست میں پہلے نوڈ کی طرف اشارہ کرتی ہے۔

سنگل لنکڈ لسٹ میں نوڈس داخل کرنا

سنگلی لنکڈ لسٹ میں نوڈس داخل کرنے میں پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنا شامل ہے۔ فہرست کے آغاز میں نوڈ داخل کرنے کی ایک مثال یہ ہے:

def insert_at_beginning(self, value):
    new_node = Node(value)
    new_node.next = self.head
    self.head = new_node

سنگل لنکڈ لسٹ سے نوڈس کو حذف کرنا

سنگلی لنکڈ لسٹ سے نوڈس کو حذف کرنے کے لیے پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنے کی ضرورت ہوتی ہے۔ یہاں ایک مخصوص قدر کے ساتھ نوڈ کو حذف کرنے کی ایک مثال ہے۔

def delete_node(self, value):
    current = self.head
    if current.value == value:
        self.head = current.next
    else:
        while current.next:
            if current.next.value == value:
                current.next = current.next.next
                break
            current = current.next

سنگل لنکڈ لسٹ میں تلاش کرنا

سنگلی لنکڈ لسٹ میں کسی مخصوص قدر کی تلاش میں اس فہرست کو عبور کرنا شامل ہے جب تک کہ قیمت نہ مل جائے یا فہرست کے اختتام تک پہنچ جائے۔ قدر کی تلاش کی ایک مثال یہ ہے:

def search(self, value):
    current = self.head
    while current:
        if current.value == value:
            return True
        current = current.next
    return False

سنگل لنکڈ لسٹ کو تبدیل کرنا

سنگلی لنکڈ لسٹ کو ریورس کرنے کے لیے پچھلے نوڈ کی طرف اشارہ کرنے کے لیے ہر نوڈ کے حوالہ جات کو اپ ڈیٹ کرنے کی ضرورت ہوتی ہے۔ سنگلی لنکڈ لسٹ کو تبدیل کرنے کی ایک مثال یہ ہے:

def reverse(self):
    previous = None
    current = self.head
    while current:
        next_node = current.next
        current.next = previous
        previous = current
        current = next_node
    self.head = previous

دوہری لنک شدہ فہرست

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

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
        self.previous = None

class DoublyLinked List:
    def __init__(self):
        self.head = None

ڈبل لنکڈ لسٹ بنانا

ڈبل لنکڈ لسٹ بنانے کے لیے، ہم ایک نوڈ کلاس کی وضاحت کرتے ہیں جس میں ایک قدر، اگلے نوڈ کا حوالہ، اور پچھلے نوڈ کا حوالہ ہوتا ہے۔ DoublyLinked List کلاس نوڈس کے لیے کنٹینر کے طور پر کام کرتی ہے، جس میں سر کی خصوصیت فہرست میں پہلے نوڈ کی طرف اشارہ کرتی ہے۔

دوہری لنک شدہ فہرست میں نوڈس داخل کرنا

ڈبل لنکڈ لسٹ میں نوڈس داخل کرنے میں پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنا شامل ہے۔ فہرست کے آغاز میں نوڈ داخل کرنے کی ایک مثال یہ ہے:

def insert_at_beginning(self, value):
    new_node = Node(value)
    if self.head:
        self.head.previous = new_node
    new_node.next = self.head
    self.head = new_node

دوہری لنک شدہ فہرست سے نوڈس کو حذف کرنا

دوہری لنک شدہ فہرست سے نوڈس کو حذف کرنے کے لیے پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنے کی ضرورت ہوتی ہے۔ یہاں ایک مخصوص قدر کے ساتھ نوڈ کو حذف کرنے کی ایک مثال ہے۔

def delete_node(self, value):
    current = self.head
    if current.value == value:
        self.head = current.next
        if self.head:
            self.head.previous = None
    else:
        while current.next:
            if current.next.value == value:
                current.next = current.next.next
                if current.next:
                    current.next.previous = current
                break
            current = current.next

دوہری لنک شدہ فہرست میں تلاش کرنا

Doubly Linked List میں کسی مخصوص قدر کی تلاش میں اس فہرست کو کسی بھی سمت میں منتقل کرنا شامل ہے جب تک کہ قیمت نہ مل جائے یا فہرست کے اختتام تک پہنچ جائے۔ قدر کی تلاش کی ایک مثال یہ ہے:

def search(self, value):
    current = self.head
    while current:
        if current.value == value:
            return True
        current = current.next
    return False

دوہری لنک شدہ فہرست کو تبدیل کرنا

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

def reverse(self):
    current = self.head
    while current:
        next_node = current.next
        current.next = current.previous
        current.previous = next_node
        if not next_node:
            self.head = current
        current = next_node

سرکلر لنکڈ لسٹ

ایک سرکلر لنکڈ لسٹ سنگلی لنکڈ لسٹ کا ایک تغیر ہے جہاں آخری نوڈ پہلے نوڈ کی طرف اشارہ کرتا ہے، جس سے ایک سرکلر ڈھانچہ بنتا ہے۔ یہ فہرست میں کسی بھی نوڈ سے موثر ٹراورسل کی اجازت دیتا ہے۔ یہاں یہ ہے کہ آپ Python میں سرکلر لنکڈ لسٹ کیسے بنا سکتے ہیں:

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class CircularLinked List:
    def __init__(self):
        self.head = None

سرکلر لنکڈ لسٹ بنانا

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

سرکلر لنکڈ لسٹ میں نوڈس داخل کرنا

سرکلر لنکڈ لسٹ میں نوڈس داخل کرنے میں پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنا شامل ہے۔ فہرست کے آغاز میں نوڈ داخل کرنے کی ایک مثال یہ ہے:

def insert_at_beginning(self, value):
    new_node = Node(value)
    if not self.head:
        self.head = new_node
        new_node.next = self.head
    else:
        current = self.head
        while current.next != self.head:
            current = current.next
        current.next = new_node
        new_node.next = self.head
        self.head = new_node

سرکلر لنکڈ لسٹ سے نوڈس کو حذف کرنا

سرکلر لنکڈ لسٹ سے نوڈس کو حذف کرنے کے لیے پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنے کی ضرورت ہوتی ہے۔ یہاں ایک مخصوص قدر کے ساتھ نوڈ کو حذف کرنے کی ایک مثال ہے۔

def delete_node(self, value):
    if not self.head:
        return
    current = self.head
    if current.value == value:
        while current.next != self.head:
            current = current.next
        if current == self.head:
            self.head = None
        else:
            current.next = self.head.next
            self.head = self.head.next
    else:
        previous = None
        while current.next != self.head:
            previous = current
            current = current.next
            if current.value == value:
                previous.next = current.next
                break

سرکلر لنکڈ لسٹ میں تلاش کرنا

سرکلر لنکڈ لسٹ میں کسی مخصوص قدر کی تلاش میں اس فہرست کو عبور کرنا شامل ہے جب تک کہ قیمت نہ مل جائے یا پوری فہرست کو عبور نہ کیا جائے۔ قدر کی تلاش کی ایک مثال یہ ہے:

def search(self, value):
    if not self.head:
        return False
    current = self.head
    while True:
        if current.value == value:
            return True
        current = current.next
        if current == self.head:
            break
    return False

سرکلر سے منسلک فہرست کو تبدیل کرنا

سرکلر لنکڈ لسٹ کو ریورس کرنے کے لیے سرکلر سٹرکچر کو ریورس کرنے کے لیے ہر نوڈ کے حوالوں کو اپ ڈیٹ کرنے کی ضرورت ہوتی ہے۔ سرکلر لنکڈ لسٹ کو تبدیل کرنے کی ایک مثال یہ ہے:

def reverse(self):
    if not self.head:
        return
    previous = None
    current = self.head
    next_node = current.next
    while True:
        current.next = previous
        previous = current
        current = next_node
        next_node = next_node.next
        if current == self.head:
            break
    self.head = previous

لنکڈ لسٹوں پر کامن آپریشنز

منسلک فہرستیں مختلف عام کارروائیوں کی حمایت کرتی ہیں جو عناصر پر کی جا سکتی ہیں۔ آئیے ان میں سے کچھ آپریشنز کو دریافت کریں:

لنک شدہ فہرست میں عناصر تک رسائی

لنکڈ لسٹ میں عناصر تک رسائی کے لیے، ہم ہیڈ نوڈ سے شروع ہونے والی فہرست کو عبور کر کے اگلے نوڈ پر جا سکتے ہیں جب تک کہ ہم مطلوبہ پوزیشن پر نہ پہنچ جائیں۔ یہاں ایک مخصوص انڈیکس پر ایک عنصر تک رسائی کی ایک مثال ہے:

def get_element(self, index):
    current = self.head
    count = 0
    while current:
        if count == index:
            return current.value
        count += 1
        current = current.next
    raise IndexError("Index out of range")

ایک لنک شدہ فہرست میں عناصر میں ترمیم کرنا

لنک شدہ فہرست میں عناصر کو تبدیل کرنے میں مطلوبہ عنصر کو تلاش کرنے اور اس کی قیمت کو اپ ڈیٹ کرنے کے لیے فہرست کو عبور کرنا شامل ہے۔ یہاں ایک مخصوص انڈیکس میں ایک عنصر میں ترمیم کرنے کی ایک مثال ہے:

def modify_element(self, index, new_value):
    current = self.head
    count = 0
    while current:
        if count == index:
            current.value = new_value
            return
        count += 1
        current = current.next
    raise IndexError("Index out of range")

لنک شدہ فہرست کی لمبائی تلاش کرنا

لنک شدہ فہرست کی لمبائی معلوم کرنے کے لیے، ہم فہرست کو عبور کر سکتے ہیں اور نوڈس کی تعداد گن سکتے ہیں۔ لنکڈ لسٹ کی لمبائی تلاش کرنے کی ایک مثال یہ ہے:

def get_length(self):
    current = self.head
    count = 0
    while current:
        count += 1
        current = current.next
    return count

چیک کر رہا ہے کہ آیا لنک شدہ فہرست خالی ہے۔

یہ چیک کرنے کے لیے کہ آیا لنکڈ لسٹ خالی ہے، ہم صرف چیک کر سکتے ہیں کہ آیا ہیڈ نوڈ کوئی نہیں ہے۔ یہ چیک کرنے کی ایک مثال ہے کہ آیا لنکڈ لسٹ خالی ہے:

def is_empty(self):
    return self.head is None

منسلک فہرستوں کو جوڑنا

دو لنک شدہ فہرستوں کو جوڑنے کے لیے، ہم آخری نوڈ کو تلاش کرنے کے لیے پہلی فہرست کو عبور کر سکتے ہیں اور اس کے اگلے حوالہ کو دوسری فہرست کے سر پر اپ ڈیٹ کر سکتے ہیں۔ یہاں دو لنک شدہ فہرستوں کو جوڑنے کی ایک مثال ہے:

def concatenate(self, other_list):
    if not self.head:
        self.head = other_list.head
    else:
        current = self.head
        while current.next:
            current = current.next
        current.next = other_list.head

لنکڈ لسٹ بمقابلہ صف

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

یادداشت کی کارکردگی

لنکڈ لسٹیں صفوں سے زیادہ میموری کے لحاظ سے موثر ہوتی ہیں کیونکہ ان کے لیے مربوط میموری مختص کرنے کی ضرورت نہیں ہوتی ہے۔ لنکڈ لسٹ میں ہر نوڈ کو صرف قیمت اور اگلے نوڈ کا حوالہ ذخیرہ کرنے کی ضرورت ہوتی ہے، جبکہ صفوں کو تمام عناصر کے لیے میموری مختص کرنے کی ضرورت ہوتی ہے، چاہے وہ استعمال نہ ہوں۔

اندراج اور حذف کرنے کی کارکردگی

لنک شدہ فہرستیں اندراج اور حذف کرنے کی کارروائیوں میں بہترین ہیں، خاص طور پر جب عناصر کو فہرست کے درمیان سے اکثر شامل یا ہٹا دیا جاتا ہے۔ لنکڈ لسٹ میں کسی عنصر کو داخل کرنے یا حذف کرنے کے لیے صرف پڑوسی نوڈس کے حوالہ جات کو اپ ڈیٹ کرنے کی ضرورت ہوتی ہے، جبکہ صفوں کو تبدیلی کو ایڈجسٹ کرنے کے لیے عناصر کو منتقل کرنے کی ضرورت پڑ سکتی ہے۔

بے ترتیب رسائی کی کارکردگی

Arrays ان کے اشاریوں کی بنیاد پر عناصر تک موثر بے ترتیب رسائی فراہم کرتے ہیں، کیونکہ وہ براہ راست میموری ایڈریسنگ کی اجازت دیتے ہیں۔ اس کے برعکس، لنکڈ لسٹوں کو ایک مخصوص انڈیکس پر کسی عنصر تک رسائی کے لیے شروع سے فہرست کو عبور کرنے کی ضرورت ہوتی ہے، جس کے نتیجے میں بے ترتیب رسائی کی کارروائیوں کی کارکردگی سست ہوتی ہے۔

صحیح ڈیٹا سٹرکچر کا انتخاب

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

لنکڈ لسٹ ایپلی کیشنز

اب جب کہ ہمیں منسلک فہرستوں اور ان کے کام کرنے کے بارے میں اچھی طرح سمجھ ہے، آئیے کچھ عملی ایپلی کیشنز کا جائزہ لیں جہاں منسلک فہرستوں کو مؤثر طریقے سے استعمال کیا جا سکتا ہے۔

آپ بھی ہماری رجسٹریشن کر سکتے ہیں۔ مفت کورسز آج!

اسٹیکس اور قطاروں کو نافذ کرنا

منسلک فہرستوں کی سب سے عام ایپلی کیشنز میں سے ایک اسٹیک اور قطار کو نافذ کرنا ہے۔ اسٹیک اور قطار دونوں خلاصہ ڈیٹا کی قسمیں ہیں جو منسلک فہرستوں کا استعمال کرتے ہوئے آسانی سے لاگو کی جا سکتی ہیں۔

اسٹیک ایک ڈیٹا ڈھانچہ ہے جو Last-In-First-Out (LIFO) اصول کی پیروی کرتا ہے۔ عناصر کو اسی سرے سے شامل اور ہٹا دیا جاتا ہے، جسے اسٹیک کے اوپری حصے کے نام سے جانا جاتا ہے۔ منسلک فہرستیں اسٹیک کو لاگو کرنے کا ایک موثر طریقہ فراہم کرتی ہیں کیونکہ ہم آسانی سے فہرست کے سر سے عناصر کو شامل یا ہٹا سکتے ہیں۔

Python میں منسلک فہرست کا استعمال کرتے ہوئے اسٹیک کو نافذ کرنے کی ایک مثال یہ ہے۔

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Stack:
    def __init__(self):
        self.head = None

    def push(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def pop(self):
        if self.head is None:
            return None
        popped = self.head.data
        self.head = self.head.next
        return popped

ایک قطار، دوسری طرف، فرسٹ-ان-فرسٹ-آؤٹ (FIFO) اصول کی پیروی کرتی ہے۔ عناصر ایک سرے پر شامل کیے جاتے ہیں، جسے پیچھے کہا جاتا ہے، اور دوسرے سرے سے ہٹا دیا جاتا ہے، جسے سامنے کے نام سے جانا جاتا ہے۔ قطاروں کو مؤثر طریقے سے لاگو کرنے کے لیے منسلک فہرستوں کو بھی استعمال کیا جا سکتا ہے۔

Python میں منسلک فہرست کا استعمال کرتے ہوئے قطار کو لاگو کرنے کی ایک مثال یہ ہے:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Queue:
    def __init__(self):
        self.front = None
        self.rear = None

    def enqueue(self, data):
        new_node = Node(data)
        if self.rear is None:
            self.front = new_node
            self.rear = new_node
        else:
            self.rear.next = new_node
            self.rear = new_node

    def dequeue(self):
        if self.front is None:
            return None
        dequeued = self.front.data
        self.front = self.front.next
        if self.front is None:
            self.rear = None
        return dequeued

بڑے ڈیٹاسیٹس کو ہینڈل کرنا

بڑے ڈیٹاسیٹس سے نمٹنے کے دوران منسلک فہرستیں بھی کارآمد ہوتی ہیں۔ صفوں کے برعکس، منسلک فہرستوں کو متصل میموری مختص کرنے کی ضرورت نہیں ہے۔ اس کا مطلب یہ ہے کہ جڑی ہوئی فہرستیں مختلف سائز کے ڈیٹاسیٹس کو مؤثر طریقے سے تبدیل کرنے یا دوبارہ جگہ دینے کی ضرورت کے بغیر ہینڈل کر سکتی ہیں۔

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

گراف ٹراورسل الگورتھم

گراف ٹراورسل الگورتھم، جیسے بریڈتھ فرسٹ سرچ (BFS) اور ڈیپتھ فرسٹ سرچ (DFS) کو بھی منسلک فہرستوں کا استعمال کرتے ہوئے لاگو کیا جا سکتا ہے۔ گراف ٹراورسل میں، ہم ایک مخصوص ترتیب میں گراف میں ہر ایک چوٹی یا نوڈ کا دورہ کرتے ہیں۔

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

کثیر الجہتی نمائندگی

مربوط فہرستوں کو کثیر الاضلاع کی مؤثر طریقے سے نمائندگی کرنے کے لیے استعمال کیا جا سکتا ہے۔ ریاضی میں، polynomials متغیرات اور کوفیشینٹس پر مشتمل اظہار ہیں۔ کثیر الجہتی میں ہر اصطلاح کو منسلک فہرست میں نوڈ کے طور پر دکھایا جا سکتا ہے، جہاں گتانک اور ایکسپوننٹ کو ڈیٹا کے طور پر محفوظ کیا جاتا ہے۔

منسلک فہرستوں کا استعمال کرتے ہوئے، ہم آسانی سے کثیر ناموں پر آپریشن کر سکتے ہیں، جیسے کہ اضافہ، گھٹاؤ، اور ضرب۔ نوڈس کو ان کارروائیوں کو انجام دینے کے لیے جوڑ توڑ کیا جا سکتا ہے، جس کے نتیجے میں کثیر الثانیات کی جامع اور موثر نمائندگی ہوتی ہے۔

موسیقی اور ویڈیو پلے لسٹس

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

پلے لسٹس کے لیے منسلک فہرستوں کا استعمال گانوں یا ویڈیوز کے درمیان آسانی سے نیویگیشن کی اجازت دیتا ہے۔ ہم پوائنٹرز کو اپ ڈیٹ کر کے، صارف کو ہموار تجربہ فراہم کر کے آسانی سے پلے لسٹ سے گانے شامل یا ہٹا سکتے ہیں۔

نتیجہ

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

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

لہذا، اگلی بار جب آپ کو کسی ایسے مسئلے کا سامنا کرنا پڑتا ہے جس کے لیے موثر اندراج، حذف، یا ٹراورسل کی ضرورت ہوتی ہے، تو اپنے حل کو آسان بنانے اور اپنے کوڈ کو بہتر بنانے کے لیے منسلک فہرستوں کو استعمال کرنے پر غور کریں۔

آپ یہاں ازگر کی فہرستوں سے متعلق مزید مضامین بھی پڑھ سکتے ہیں:

اکثر پوچھے گئے سوالات

متعلقہ

• SEO سے چلنے والا مواد اور PR کی تقسیم۔ آج ہی بڑھا دیں۔
• پلیٹو ڈیٹا ڈاٹ نیٹ ورک ورٹیکل جنریٹو اے آئی۔ اپنے آپ کو بااختیار بنائیں۔ یہاں تک رسائی حاصل کریں۔
• پلیٹوآئ اسٹریم۔ ویب 3 انٹیلی جنس۔ علم میں اضافہ۔ یہاں تک رسائی حاصل کریں۔
• پلیٹو ای ایس جی۔ کاربن، کلین ٹیک، توانائی ، ماحولیات، شمسی، ویسٹ مینجمنٹ یہاں تک رسائی حاصل کریں۔
• پلیٹو ہیلتھ۔ بائیوٹیک اینڈ کلینیکل ٹرائلز انٹیلی جنس۔ یہاں تک رسائی حاصل کریں۔
• ماخذ: https://www.analyticsvidhya.com/blog/2024/02/linked-lists-in-python/