🎉 پیاده‌سازی معماری ECS در پایتون

مقدمه 🚀

معماری ECS به شما امکان می‌دهد تا اجزای مختلف بازی را به صورت ماژولار و مجزا از یکدیگر پیاده‌سازی کنید. در این معماری، موجودیت‌ها فقط شناسه‌هایی برای شناسایی اشیاء هستند، کامپوننت‌ها داده‌هایی هستند که به این موجودیت‌ها متصل می‌شوند، و سیستم‌ها وظیفه پردازش و به‌روزرسانی این داده‌ها را بر عهده دارند.

ایجاد ساختار اصلی ECS 🌟

ابتدا باید ساختار پایه‌ای برای معماری ECS را در پایتون پیاده‌سازی کنیم. برای شروع، سه کلاس اصلی برای Entity، Component، و System تعریف می‌کنیم.

class Entity:
    def __init__(self):
        self.id = id(self)

class Component:
    pass

class System:
    def __init__(self):
        self.entities = []

    def add_entity(self, entity):
        self.entities.append(entity)

    def update(self):
        raise NotImplementedError("You need to implement the update method!")

ایجاد موجودیت‌ها و کامپوننت‌ها 🧩

موجودیت‌ها فقط شناسه‌هایی برای شناسایی اشیاء در بازی هستند و به خودی خود هیچ داده یا عملکرد خاصی ندارند. برای ایجاد موجودیت‌های خاص، می‌توانیم کامپوننت‌های مختلفی ایجاد کنیم.

class PositionComponent(Component):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

class VelocityComponent(Component):
    def __init__(self, dx=0, dy=0):
        self.dx = dx
        self.dy = dy

ایجاد سیستم‌ها برای پردازش داده‌ها 🛠️

سیستم‌ها وظیفه پردازش داده‌های متصل به موجودیت‌ها را بر عهده دارند. برای مثال، یک سیستم فیزیک می‌تواند داده‌های موقعیت و سرعت موجودیت‌ها را به‌روزرسانی کند.

class PhysicsSystem(System):
    def update(self):
        for entity in self.entities:
            position = entity.get_component(PositionComponent)
            velocity = entity.get_component(VelocityComponent)

            if position and velocity:
                position.x += velocity.dx
                position.y += velocity.dy

اضافه کردن قابلیت مدیریت کامپوننت‌ها به موجودیت‌ها 🔧

برای اینکه موجودیت‌ها بتوانند کامپوننت‌ها را مدیریت کنند، باید متدهایی برای اضافه کردن و دریافت کامپوننت‌ها به کلاس Entity اضافه کنیم.

class Entity:
    def __init__(self):
        self.id = id(self)
        self.components = {}

    def add_component(self, component):
        self.components[component.__class__] = component

    def get_component(self, component_class):
        return self.components.get(component_class)

تست کردن معماری ECS 🎮

حالا که ساختار اصلی معماری ECS را پیاده‌سازی کردیم، می‌توانیم آن را تست کنیم. ابتدا چند موجودیت ایجاد کرده، کامپوننت‌های مربوطه را به آن‌ها اضافه می‌کنیم و سپس با استفاده از سیستم‌ها این موجودیت‌ها را به‌روزرسانی می‌کنیم.

# ایجاد سیستم فیزیک
physics_system = PhysicsSystem()

# ایجاد موجودیت‌ها
entity1 = Entity()
entity1.add_component(PositionComponent(0, 0))
entity1.add_component(VelocityComponent(1, 1))

entity2 = Entity()
entity2.add_component(PositionComponent(10, 10))
entity2.add_component(VelocityComponent(-1, -1))

# اضافه کردن موجودیت‌ها به سیستم فیزیک
physics_system.add_entity(entity1)
physics_system.add_entity(entity2)

# به‌روزرسانی موجودیت‌ها
for _ in range(5):
    physics_system.update()

    print(f"Entity1 Position: ({entity1.get_component(PositionComponent).x}, {entity1.get_component(PositionComponent).y})")
    print(f"Entity2 Position: ({entity2.get_component(PositionComponent).x}, {entity2.get_component(PositionComponent).y})")

توضیحات

1. Entity: موجودیت‌ها به عنوان حامل‌های کامپوننت‌ها عمل می‌کنند و شناسه یکتایی دارند.
2. Component: کامپوننت‌ها داده‌هایی هستند که به موجودیت‌ها متصل می‌شوند. به عنوان مثال، PositionComponent و VelocityComponent دو نمونه از این کامپوننت‌ها هستند.
3. System: سیستم‌ها وظیفه پردازش کامپوننت‌های متصل به موجودیت‌ها را بر عهده دارند. در مثال ما، PhysicsSystem یک سیستم فیزیک است که موقعیت موجودیت‌ها را بر اساس سرعت آن‌ها به‌روزرسانی می‌کند.

پارت ۱: مقدمه‌ای بر ساختمان داده‌ها 📚

سلام دوستان! 🌟 در اولین پارت از سری آموزش‌های "مفاهیم پایه ساختمان داده‌ها" می‌خواهیم به تعریف و اهمیت ساختمان داده‌ها بپردازیم و با انواع مختلف آن‌ها آشنا شویم. 🚀

تعریف ساختمان داده‌ها 🏗️
ساختمان داده‌ها به روش‌هایی اشاره دارد که برای سازماندهی و ذخیره‌سازی داده‌ها در برنامه‌های کامپیوتری استفاده می‌شود. این روش‌ها به ما کمک می‌کنند تا بتوانیم داده‌ها را به صورت مؤثر و کارا مدیریت کنیم. 💾

اهمیت ساختمان داده‌ها 💡
ساختمان داده‌ها نقش بسیار مهمی در بهینه‌سازی عملکرد برنامه‌ها دارند. با انتخاب صحیح ساختمان داده، می‌توانیم سرعت و کارایی برنامه‌های خود را بهبود بخشیم و در نتیجه تجربه کاربری بهتری ارائه دهیم. 🔍

انواع ساختمان داده‌ها 📂
ساختمان داده‌ها به طور کلی به دو دسته اصلی تقسیم می‌شوند:

1. ساختمان داده‌های خطی (Linear Data Structures):
- آرایه‌ها (Arrays): مجموعه‌ای از عناصر با اندازه ثابت که به صورت متوالی در حافظه ذخیره می‌شوند. 📏
- لیست‌های پیوندی (Linked Lists): مجموعه‌ای از نودها که هر نود شامل داده و یک اشاره‌گر به نود بعدی است. 🔗

2. ساختمان داده‌های غیرخطی (Non-linear Data Structures):
- درخت‌ها (Trees): ساختارهای داده‌ای که به صورت سلسله‌مراتبی سازماندهی شده‌اند. 🌳
- گراف‌ها (Graphs): مجموعه‌ای از نودها و یال‌ها که ارتباطات بین نودها را نشان می‌دهند. 🕸️

کاربردهای مختلف ساختمان داده‌ها ⚙️

ساختمان داده‌ها در بسیاری از الگوریتم‌ها و برنامه‌های کامپیوتری کاربرد دارند. برای مثال، آرایه‌ها برای ذخیره‌سازی داده‌های مرتب شده و لیست‌های پیوندی برای اضافه و حذف سریع داده‌ها مناسب هستند. درخت‌ها و گراف‌ها نیز برای مسائل پیچیده‌تری مانند مسیر یابی و ذخیره‌سازی داده‌های سلسله‌مراتبی استفاده می‌شوند. 🧩

به این ترتیب، ساختمان داده‌ها پایه و اساس بسیاری از الگوریتم‌های برنامه‌نویسی و سیستم‌های نرم‌افزاری هستند. در پارت‌های بعدی به بررسی پیچیدگی زمانی و مکانی، و همچنین آرایه‌ها و لیست‌های پیوندی خواهیم پرداخت. 🚀

برای شروع آماده باشید و به یاد داشته باشید، پایه‌گذاری درست به موفقیت‌های بزرگ‌تر منجر خواهد شد! 📈

(🔺️🔺️اینجا کلیک کن🔻🔻)


#ساختمان_داده‌ها #پایتون #برنامه‌نویسی #آموزش #مفاهیم_پایه #الگوریتم #برنامه‌نویس

پارت ۲: پیچیدگی زمانی و مکانی (Big O) ⏳💾

سلام دوستان! 🌟 در این پارت از سری آموزش‌های "مفاهیم پایه ساختمان داده‌ها"، می‌خواهیم به یکی از مفاهیم کلیدی در برنامه‌نویسی و الگوریتم‌ها بپردازیم: پیچیدگی زمانی و مکانی! 🚀

مفهوم پیچیدگی زمانی و مکانی 📈
پیچیدگی زمانی و مکانی برای اندازه‌گیری کارایی الگوریتم‌ها استفاده می‌شود و به ما کمک می‌کند تا بفهمیم یک الگوریتم چقدر سریع و با چه مقدار حافظه اجرا می‌شود.

- پیچیدگی زمانی (Time Complexity): نشان می‌دهد که زمان اجرای الگوریتم چقدر به ورودی‌ها وابسته است. 🕒
- پیچیدگی مکانی (Space Complexity): نشان می‌دهد که مقدار حافظه مورد نیاز الگوریتم به چه اندازه وابسته است. 💾

مفهوم Big O 🔍
Big O (بزرگ O) یک نماد است که برای بیان پیچیدگی زمانی و مکانی استفاده می‌شود. این نماد به ما کمک می‌کند تا رشد عملکرد یک الگوریتم را با افزایش اندازه ورودی تحلیل کنیم.

برای مثال:
- O(1): زمان یا حافظه ثابت، مستقل از اندازه ورودی. ⌛
- O(n): زمان یا حافظه خطی، به اندازه ورودی وابسته است. 📈
- O(n^2): زمان یا حافظه مربعی، به مجذور اندازه ورودی وابسته است. 🧮

تحلیل چند مثال ساده 🧩
1. جستجو در آرایه: اگر یک الگوریتم نیاز به جستجوی یک عنصر در آرایه‌ای از اندازه \( n \) داشته باشد، پیچیدگی زمانی آن O(n) است. به این معنی که در بدترین حالت، باید تمام عناصر را بررسی کنیم. 🔍

2. مرتب‌سازی با الگوریتم Bubble Sort: این الگوریتم برای مرتب‌سازی لیستی از عناصر نیاز به O(n^2) زمان دارد، زیرا برای هر عنصر باید با دیگر عناصر مقایسه شود. 📊

اهمیت Big O در انتخاب ساختمان داده‌ها و الگوریتم‌ها 🧠
شناخت پیچیدگی زمانی و مکانی به ما کمک می‌کند تا بهترین ساختمان داده و الگوریتم را برای مسائل مختلف انتخاب کنیم. انتخاب مناسب می‌تواند منجر به بهبود قابل توجه در سرعت و کارایی برنامه‌ها شود. 🌟

برای مثال، اگر نیاز به جستجوی سریع در یک مجموعه از داده‌ها دارید، استفاده از درخت‌های جستجوی دودویی که دارای پیچیدگی زمانی O(log n) هستند، می‌تواند مناسب‌تر از آرایه‌ها با پیچیدگی زمانی O(n) باشد. 🔢

با یادگیری و درک مفهوم Big O، می‌توانید الگوریتم‌ها و ساختمان داده‌های مناسب را برای برنامه‌های خود انتخاب کنید و به بهینه‌سازی کدهای خود بپردازید. 🛠️

در پارت بعدی به بررسی آرایه‌ها و لیست‌های پیوندی خواهیم پرداخت و نحوه عملکرد این ساختمان داده‌ها را مورد بررسی قرار خواهیم داد. تا آن زمان، تمرین و مرور این مفاهیم را فراموش نکنید! 🚀

(🔺️🔺️اینجا کلیک کن🔻🔻)



#پیچیدگی_زمانی #پیچیدگی_مکانی #BigO #برنامه‌نویسی #ساختمان_داده‌ها #آموزش #پایتون #الگوریتم

پارت ۳: آرایه‌ها و لیست‌های پیوندی (مقدمه‌ای) 📊🔗

سلام دوستان! 🌟 در پارت سوم از سری آموزش‌های "مفاهیم پایه ساختمان داده‌ها"، به بررسی دو ساختمان داده‌ی مهم و پرکاربرد یعنی آرایه‌ها و لیست‌های پیوندی خواهیم پرداخت. 🚀

آرایه‌ها (Arrays) 📏
آرایه‌ها یکی از ساده‌ترین و پرکاربردترین ساختمان‌های داده‌ای هستند که برای ذخیره مجموعه‌ای از عناصر با نوع داده‌ی مشابه استفاده می‌شوند.

- تعریف: آرایه یک مجموعه از عناصر است که در حافظه به صورت متوالی ذخیره شده‌اند و هر عنصر با یک اندیس (Index) دسترسی دارد. 📍
- ویژگی‌ها:
- اندازه ثابت: پس از ایجاد آرایه، اندازه آن تغییر نمی‌کند. 🛠️
- دسترسی تصادفی سریع: با استفاده از اندیس می‌توان به هر عنصر به سرعت دسترسی پیدا کرد. 🚀

مثال:

# ایجاد یک آرایه از اعداد صحیح
arr = [1, 2, 3, 4, 5]
print(arr[2])  # دسترسی به عنصر سوم (3)

لیست‌های پیوندی (Linked Lists) 🔗
لیست‌های پیوندی ساختاری انعطاف‌پذیرتر نسبت به آرایه‌ها هستند و برای ذخیره داده‌ها به صورت پویا و تغییرپذیر مناسب‌اند.

- تعریف: لیست پیوندی مجموعه‌ای از نودها است که هر نود شامل داده و یک اشاره‌گر به نود بعدی (و در برخی موارد، نود قبلی) است. 🌐
- ویژگی‌ها:
- اندازه پویا: می‌توان به راحتی نودها را اضافه یا حذف کرد. 🛠️
- دسترسی خطی: برای دسترسی به یک عنصر باید از ابتدا تا نود مورد نظر پیمایش کرد. 🕵️

مثال:

# تعریف یک نود ساده در لیست پیوندی
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# ایجاد نودها و پیوند آنها
node1 = Node(1)
node2 = Node(2)
node1.next = node2
print(node1.next.data)  # دسترسی به داده نود دوم (2)

تفاوت‌های کلیدی بین آرایه‌ها و لیست‌های پیوندی ⚖️
- اندازه: آرایه‌ها اندازه ثابت دارند، در حالی که لیست‌های پیوندی اندازه پویا هستند. 📏🔧
- دسترسی: دسترسی به عناصر در آرایه‌ها به صورت تصادفی و سریع است، در حالی که در لیست‌های پیوندی باید از ابتدا تا عنصر مورد نظر پیمایش کنید. ⌛
- افزودن/حذف: در آرایه‌ها، افزودن یا حذف عناصر نیاز به جابجایی عناصر دارد، در حالی که در لیست‌های پیوندی این عملیات به راحتی با تغییر اشاره‌گرها انجام می‌شود. 🔄

در پارت بعدی، به بررسی عملیات پایه مانند جستجو، درج و حذف در آرایه‌ها و لیست‌های پیوندی خواهیم پرداخت و پیچیدگی زمانی این عملیات‌ها را بررسی خواهیم کرد. تا آن زمان، تمرین کنید و با این ساختمان داده‌ها آشنا شوید! 🚀

(🔺️🔺️اینجا کلیک کن🔻🔻)

#آرایه‌ها #لیست‌های_پیوندی #ساختمان_داده‌ها #برنامه‌نویسی #پایتون #آموزش #داده

پارت ۴: عملیات پایه بر روی آرایه‌ها و لیست‌ها 🔍✏️

سلام دوستان! 🌟 در پارت چهارم از سری آموزش‌های "مفاهیم پایه ساختمان داده‌ها"، به بررسی عملیات پایه‌ای مانند جستجو، درج، و حذف در آرایه‌ها و لیست‌های پیوندی خواهیم پرداخت. 🚀

عملیات پایه در آرایه‌ها 📏

1. جستجو 🔎
- توضیح: برای پیدا کردن یک عنصر خاص در آرایه، باید به صورت خطی و از ابتدا تا انتها جستجو کنید.
- پیچیدگی زمانی: O(n)، زیرا ممکن است نیاز به بررسی تمام عناصر باشد.

مثال:

   def linear_search(arr, target):
       for index, value in enumerate(arr):
           if value == target:
               return index
       return -1

   arr = [1, 2, 3, 4, 5]
   print(linear_search(arr, 3))  # خروجی: 2
   

2. درج 🆕
- توضیح: برای افزودن یک عنصر به آرایه، معمولاً نیاز به جابجایی عناصر دیگر برای باز کردن فضای جدید است.
- پیچیدگی زمانی: O(n)، به دلیل نیاز به جابجایی عناصر.

مثال:

   def insert_element(arr, index, element):
       arr.insert(index, element)
       return arr

   arr = [1, 2, 3, 4, 5]
   print(insert_element(arr, 2, 10))  # خروجی: [1, 2, 10, 3, 4, 5]
   

3. حذف ❌
- توضیح: برای حذف یک عنصر از آرایه، نیاز به جابجایی عناصر بعدی برای پر کردن فضای خالی است.
- پیچیدگی زمانی: O(n)، به دلیل نیاز به جابجایی عناصر.

مثال:

   def remove_element(arr, element):
       if element in arr:
           arr.remove(element)
       return arr

   arr = [1, 2, 3, 4, 5]
   print(remove_element(arr, 3))  # خروجی: [1, 2, 4, 5]
   

عملیات پایه در لیست‌های پیوندی 🔗

1. جستجو 🔍
- توضیح: برای پیدا کردن یک عنصر در لیست پیوندی، باید از نود ابتدایی شروع کرده و به ترتیب نودها را پیمایش کنید.
- پیچیدگی زمانی: O(n)، زیرا باید تمام نودها را بررسی کرد.

مثال:

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

   def search_linked_list(head, target):
       current = head
       while current:
           if current.data == target:
               return True
           current = current.next
       return False

   head = Node(1)
   head.next = Node(2)
   head.next.next = Node(3)
   print(search_linked_list(head, 2))  # خروجی: True
   

2. درج 🆕
- توضیح: برای افزودن یک نود به لیست پیوندی، تنها کافی است اشاره‌گرهای نودها را تغییر دهید.
- پیچیدگی زمانی: O(1) برای افزودن در ابتدای لیست، O(n) برای افزودن در موقعیت خاص.

مثال:

   def insert_at_head(head, new_data):
       new_node = Node(new_data)
       new_node.next = head
       head = new_node
       return head

   head = Node(1)
   head = insert_at_head(head, 0)
   print(head.data)  # خروجی: 0
   

3. حذف ❌
- توضیح: برای حذف یک نود از لیست پیوندی، باید نود قبلی را پیدا کرده و اشاره‌گر آن را به نود بعدی تغییر دهید.
- پیچیدگی زمانی: O(1) برای حذف از ابتدای لیست، O(n) برای حذف از موقعیت خاص.

مثال:

   def delete_node(head, key):
       temp = head
       if temp is not None:
           if temp.data == key:
               head = temp.next
               temp = None
               return head
       while temp is not None:
           if temp.data == key:
               break
           prev = temp
           temp = temp.next
       if temp == None:
           return head
       prev.next = temp.next
       temp = None
       return head

   head = Node(1)
   head.next = Node(2)
   head.next.next = Node(3)
   head = delete_node(head, 2)
   

جمع‌بندی 🧩
در این پارت، عملیات پایه‌ای مانند جستجو، درج، و حذف را در آرایه‌ها و لیست‌های پیوندی بررسی کردیم و پیچیدگی زمانی هر یک را مورد توجه قرار دادیم. با درک این عملیات، می‌توانید تصمیمات بهتری در طراحی الگوریتم‌ها و انتخاب ساختمان داده‌ها بگیرید. 🚀

در پارت بعدی، به مرور و تمرین مفاهیم خواهیم پرداخت و چند مثال برای تثبیت مفاهیم خواهیم زد. تا آن زمان، تمرینات را انجام دهید و سوالات خود را آماده کنید! 🌟

(🔺️🔺️اینجا کلیک کن🔻🔻)

#آرایه‌ها #لیست‌های_پیوندی #عملیات_پایه #برنامه‌نویسی #ساختمان_داده‌ها #پایتون #آموزش

پارت ۵: مرور و تمرین 📚📝

سلام دوستان! 🌟 در پارت پنجم از سری آموزش‌های "مفاهیم پایه ساختمان داده‌ها"، قصد داریم به مرور مفاهیم و نکات کلیدی بپردازیم و با حل چند مثال و تمرین، این مفاهیم را به خوبی تثبیت کنیم. 🚀

مرور مفاهیم کلیدی 🔍

1. ساختمان داده‌ها 🏗️
- تعریف: روش‌هایی برای سازماندهی و ذخیره‌سازی داده‌ها به صورت مؤثر.
- انواع:
- خطی: آرایه‌ها و لیست‌های پیوندی.
- غیرخطی: درخت‌ها و گراف‌ها.

2. پیچیدگی زمانی و مکانی (Big O) 📈
- O(1): زمان ثابت.
- O(n): زمان خطی.
- O(n^2): زمان مربعی.
- اهمیت: کمک به انتخاب مناسب‌ترین ساختمان داده و الگوریتم.

3. آرایه‌ها 📏
- ویژگی‌ها: اندازه ثابت، دسترسی تصادفی سریع.
- عملیات: جستجو، درج، حذف.

4. لیست‌های پیوندی 🔗
- ویژگی‌ها: اندازه پویا، دسترسی خطی.
- عملیات: جستجو، درج، حذف.

تمرین‌ها 🏆

1. تمرین جستجو در آرایه 🔎
- مسئله: الگوریتمی بنویسید که تعداد تکرار یک عنصر خاص را در یک آرایه پیدا کند.
- کد پیشنهادی:

   def count_occurrences(arr, target):
       count = 0
       for element in arr:
           if element == target:
               count += 1
       return count

   arr = [1, 2, 3, 2, 4, 2, 5]
   print(count_occurrences(arr, 2))  # خروجی: 3
   

2. تمرین درج در لیست پیوندی 🆕
- مسئله: نودی جدید را با مقدار مشخص در انتهای لیست پیوندی اضافه کنید.
- کد پیشنهادی:

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

   def append_node(head, new_data):
       new_node = Node(new_data)
       if head is None:
           return new_node
       last = head
       while last.next:
           last = last.next
       last.next = new_node
       return head

   head = Node(1)
   head = append_node(head, 2)
   head = append_node(head, 3)
   

3. تمرین حذف در آرایه ❌
- مسئله: تابعی بنویسید که تمام مقادیر تکراری را از یک آرایه حذف کند و آرایه جدید را برگرداند.
- کد پیشنهادی:

   def remove_duplicates(arr):
       return list(set(arr))

   arr = [1, 2, 2, 3, 4, 4, 5]
   print(remove_duplicates(arr))  # خروجی: [1, 2, 3, 4, 5]
   

4. تمرین جستجو در لیست پیوندی 🔍
- مسئله: تابعی بنویسید که نود با داده مشخص را پیدا کند و آن را حذف کند.
- کد پیشنهادی:

   def delete_node_by_value(head, value):
       temp = head
       if temp is not None and temp.data == value:
           return temp.next
       prev = None
       while temp is not None and temp.data != value:
           prev = temp
           temp = temp.next
       if temp is None:
           return head
       prev.next = temp.next
       temp = None
       return head

   head = Node(1)
   head.next = Node(2)
   head.next.next = Node(3)
   head = delete_node_by_value(head, 2)
   

جمع‌بندی 🧩
در این پارت، مفاهیم پایه‌ای ساختمان داده‌ها را مرور کردیم و با حل چند تمرین، این مفاهیم را به خوبی تثبیت کردیم. تمرین و تکرار این مسائل به شما کمک می‌کند تا درک بهتری از نحوه عملکرد ساختمان داده‌ها و الگوریتم‌ها پیدا کنید. 🌟

در پارت بعدی، به ساخت یک پروژه عملی ساده خواهیم پرداخت که به شما کمک می‌کند مفاهیم را به صورت عملی پیاده‌سازی کنید. تا آن زمان، تمرینات را ادامه دهید و سوالات خود را آماده کنید! 🚀

(🔺️🔺️اینجا کلیک کن🔻🔻)


#مرور #تمرین #آرایه‌ها #لیست‌های_پیوندی #ساختمان_داده‌ها #پایتون #آموزش #برنامه‌نویسی

پارت ۶: پروژه عملی ساده 🛠️📈

سلام دوستان! 🌟 در پارت ششم از سری آموزش‌های "مفاهیم پایه ساختمان داده‌ها"، به یک پروژه عملی ساده خواهیم پرداخت که به شما کمک می‌کند تا مفاهیم آموزش‌دیده شده را به کار ببرید. 🚀

پروژه: ساخت یک سیستم مدیریت لیست خرید 🛒📋

هدف این پروژه ساخت یک برنامه ساده است که از آرایه‌ها و لیست‌های پیوندی برای مدیریت لیست خرید استفاده می‌کند. این پروژه شامل عملیات‌های پایه‌ای مانند افزودن، حذف و نمایش اقلام خرید است.

گام ۱: تعریف کلاس‌ها و ساختار داده‌ها 🏗️

1. تعریف نودها برای لیست پیوندی 🔗

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

2. تعریف لیست پیوندی برای مدیریت اقلام 🛒

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

       def add_item(self, item):
           new_node = Node(item)
           new_node.next = self.head
           self.head = new_node

       def remove_item(self, item):
           current = self.head
           prev = None
           while current:
               if current.item == item:
                   if prev:
                       prev.next = current.next
                   else:
                       self.head = current.next
                   return
               prev = current
               current = current.next

       def display_items(self):
           items = []
           current = self.head
           while current:
               items.append(current.item)
               current = current.next
           return items
   

گام ۲: استفاده از کلاس‌ها برای مدیریت لیست خرید 🛠️

1. افزودن اقلام به لیست خرید ✏️

   shopping_list = ShoppingList()
   shopping_list.add_item("Milk")
   shopping_list.add_item("Bread")
   shopping_list.add_item("Eggs")
   print("Current items:", shopping_list.display_items())  # خروجی: ['Eggs', 'Bread', 'Milk']
   

2. حذف اقلام از لیست خرید ❌

   shopping_list.remove_item("Bread")
   print("Updated items:", shopping_list.display_items())  # خروجی: ['Eggs', 'Milk']
   

گام ۳: بررسی و اجرای پروژه ✅

- بررسی عملکرد: اطمینان حاصل کنید که عملیات‌های افزودن، حذف و نمایش به درستی کار می‌کنند.
- تست کد: با افزودن و حذف اقلام مختلف، برنامه را تست کنید و بررسی کنید که آیا اقلام به درستی مدیریت می‌شوند.

نتیجه‌گیری 🌟

با تکمیل این پروژه ساده، توانسته‌اید مفاهیم پایه‌ای ساختمان داده‌ها را در عمل به کار ببرید. این پروژه به شما کمک می‌کند تا درک بهتری از نحوه استفاده از آرایه‌ها و لیست‌های پیوندی در حل مسائل واقعی پیدا کنید. 🚀

(🔺️🔺️اینجا کلیک کن🔻🔻)


#پروژه_عملی #ساختمان_داده‌ها #آرایه‌ها #لیست‌های_پیوندی #برنامه‌نویسی #پایتون #آموزش

پارت ۱: معرفی آرایه‌ها 📚📊

سلام دوستان! 🌟 به سری دوم آموزش‌های "ساختمان داده‌ها" خوش آمدید! در این سری، به بررسی دقیق‌تر آرایه‌ها و لیست‌های پیوندی خواهیم پرداخت. پارت اول این سری به آرایه‌ها اختصاص دارد. آماده‌اید؟ شروع کنیم! 🚀

آرایه چیست؟ 🤔

آرایه (Array) یک ساختار داده‌ای است که مجموعه‌ای از عناصر هم‌نوع (مانند اعداد صحیح، اعشار یا کاراکترها) را در یک فضای حافظه پیوسته ذخیره می‌کند. هر عنصر در آرایه با استفاده از یک اندیس (index) قابل دسترسی است.

مثال:
فرض کنید آرایه‌ای به نام arr داریم که ۵ عدد صحیح را ذخیره می‌کند:

arr = [10, 20, 30, 40, 50]

در اینجا، arr[0] مقدار 10 و arr[4] مقدار 50 را برمی‌گرداند.

انواع آرایه‌ها 🧩

1. آرایه‌های یک‌بعدی:
- ساده‌ترین نوع آرایه، که عناصر را به صورت خطی ذخیره می‌کند.
- مثال: arr = [1, 2, 3, 4, 5]

2. آرایه‌های دوبعدی:
- آرایه‌هایی که عناصر را در قالب سطرها و ستون‌ها ذخیره می‌کنند.
- برای نمایش ماتریس‌ها و جداول استفاده می‌شوند.
- مثال:

     matrix = [
         [1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]
     ]
     

3. آرایه‌های چندبعدی:
- آرایه‌هایی با بیش از دو بعد، که برای نمایش داده‌های پیچیده‌تر به کار می‌روند.
- در مواردی مثل پردازش تصاویر سه‌بعدی یا داده‌های چندبعدی استفاده می‌شوند.

مزایا و معایب آرایه‌ها ⚖️

1. مزایا 🌟
- دسترسی سریع: با استفاده از اندیس می‌توان به سرعت به هر عنصر دسترسی پیدا کرد. پیچیدگی زمانی دسترسی به عناصر آرایه O(1) است.
- ساده و کاربردی: پیاده‌سازی و استفاده از آرایه‌ها در بسیاری از زبان‌های برنامه‌نویسی ساده است.
- استفاده بهینه از حافظه: حافظه به صورت پیوسته تخصیص داده می‌شود که باعث بهبود کارایی می‌شود.

2. معایب ⚠️
- اندازه ثابت: پس از تعریف آرایه، نمی‌توان اندازه آن را تغییر داد. این موضوع ممکن است باعث هدررفت حافظه یا کمبود فضا شود.
- هزینه بالای درج و حذف: برای درج یا حذف یک عنصر، ممکن است نیاز به جابجایی بسیاری از عناصر باشد که پیچیدگی زمانی O(n) دارد.

کاربردهای آرایه‌ها در برنامه‌نویسی 💻

آرایه‌ها به دلیل سادگی و کارایی بالا، در بسیاری از الگوریتم‌ها و برنامه‌های مختلف کاربرد دارند:

- پردازش لیست‌ها: مانند لیست نمرات دانشجویان یا قیمت محصولات.
- مدیریت ماتریس‌ها: در الگوریتم‌های ریاضی و گرافیک کامپیوتری.
- پیاده‌سازی ساختارهای داده‌ای پیشرفته: مانند پشته‌ها و صف‌ها.

در این پارت، با مفهوم آرایه‌ها و انواع مختلف آن‌ها آشنا شدیم و مزایا و معایب این ساختار داده‌ای را بررسی کردیم. آرایه‌ها یکی از ساده‌ترین و پرکاربردترین ساختارهای داده‌ای هستند که در بسیاری از مسائل برنامه‌نویسی مورد استفاده قرار می‌گیرند.

در پارت بعدی، به بررسی عملیات پایه‌ای مانند درج، حذف، جستجو و به‌روزرسانی عناصر در آرایه‌ها می‌پردازیم.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#آرایه‌ها #ساختمان_داده‌ها #برنامه‌نویسی #پایتون #آموزش

پارت ۲: عملیات پایه روی آرایه‌ها 🔄🛠️

سلام دوستان! 🌟 در پارت دوم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به بررسی عملیات پایه‌ای که می‌توان روی آرایه‌ها انجام داد، می‌پردازیم. این عملیات شامل درج، حذف، جستجو و به‌روزرسانی عناصر در آرایه‌ها است. همچنین با پیچیدگی زمانی هر عملیات نیز آشنا خواهیم شد. آماده‌اید؟ شروع کنیم! 🚀

۱. درج (Insertion) در آرایه ✏️

درج یک عنصر جدید در آرایه می‌تواند در سه حالت مختلف انجام شود:
1. درج در ابتدای آرایه: همه عناصر باید یک خانه به جلو منتقل شوند.
2. درج در میانه آرایه: عناصر پس از محل درج باید یک خانه به جلو منتقل شوند.
3. درج در انتهای آرایه: تنها زمانی امکان‌پذیر است که فضایی در انتهای آرایه موجود باشد.

پیچیدگی زمانی: درج در ابتدای آرایه یا میانه آن O(n) است، در حالی که درج در انتها O(1) است.

مثال کد:

def insert(arr, index, value):
    if index >= len(arr):
        arr.append(value)
    else:
        arr.insert(index, value)

arr = [10, 20, 30, 40]
insert(arr, 2, 25)  # آرایه بعد از درج: [10, 20, 25, 30, 40]
print(arr)

۲. حذف (Deletion) از آرایه ❌

حذف یک عنصر نیز به سه حالت مشابه درج انجام می‌شود:
1. حذف از ابتدای آرایه: همه عناصر باید یک خانه به عقب منتقل شوند.
2. حذف از میانه آرایه: عناصر بعد از محل حذف باید یک خانه به عقب منتقل شوند.
3. حذف از انتهای آرایه: حذف سریع‌تر و بدون نیاز به جابجایی دیگر عناصر است.

پیچیدگی زمانی: حذف از ابتدای آرایه یا میانه آن O(n) است، در حالی که حذف از انتها O(1) است.

مثال کد:

def delete(arr, index):
    if index < len(arr):
        arr.pop(index)

arr = [10, 20, 30, 40]
delete(arr, 1)  # آرایه بعد از حذف: [10, 30, 40]
print(arr)

۳. جستجو (Search) در آرایه 🔍

جستجو به معنای یافتن یک عنصر خاص در آرایه است. دو روش رایج برای جستجو عبارتند از:
1. جستجوی خطی (Linear Search): از ابتدا تا انتها آرایه را برای یافتن عنصر مورد نظر جستجو می‌کنیم.
2. جستجوی دودویی (Binary Search): برای آرایه‌های مرتب، جستجو به روش تقسیم و تسخیر انجام می‌شود.

پیچیدگی زمانی:
- جستجوی خطی O(n) است.
- جستجوی دودویی O(log n) است.

مثال کد (جستجوی خطی):

def linear_search(arr, value):
    for i in range(len(arr)):
        if arr[i] == value:
            return i
    return -1

arr = [10, 20, 30, 40]
index = linear_search(arr, 30)  # خروجی: 2
print("Index of 30:", index)

۴. به‌روزرسانی (Update) عنصر در آرایه 🔄

به‌روزرسانی به معنای تغییر مقدار یک عنصر خاص در آرایه است. این عملیات بسیار سریع است زیرا فقط به اندیس عنصر مورد نظر نیاز داریم.

پیچیدگی زمانی: به‌روزرسانی O(1) است.

مثال کد:

def update(arr, index, value):
    if index < len(arr):
        arr[index] = value

arr = [10, 20, 30, 40]
update(arr, 2, 35)  # آرایه بعد از به‌روزرسانی: [10, 20, 35, 40]
print(arr)

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#آموزش #برنامه‌نویسی #ساختمان_داده‌ها

ادامه پارت ۲: جستجوی دودویی (Binary Search) در آرایه 🔍📈

جستجوی دودویی یکی از کارآمدترین روش‌ها برای یافتن یک عنصر در یک آرایه مرتب‌شده است. این روش از رویکرد "تقسیم و تسخیر" (Divide and Conquer) استفاده می‌کند و پیچیدگی زمانی آن به صورت لگاریتمی است.

چگونه جستجوی دودویی کار می‌کند؟ 🤔

1. ابتدا، عنصر میانی (وسط) آرایه را پیدا کنید.
2. اگر عنصر مورد نظر کمتر از عنصر میانی است، جستجو را در نیمه چپ آرایه ادامه دهید.
3. اگر عنصر مورد نظر بیشتر از عنصر میانی است، جستجو را در نیمه راست آرایه ادامه دهید.
4. اگر عنصر میانی برابر با عنصر مورد نظر است، جستجو به پایان می‌رسد و اندیس آن بازگردانده می‌شود.
5. این فرآیند را تا زمانی که عنصر مورد نظر پیدا شود یا آرایه به بخش‌های کوچکتر تقسیم شود ادامه دهید.

پیچیدگی زمانی 🔄

پیچیدگی زمانی جستجوی دودویی O(log n) است، که بسیار سریع‌تر از جستجوی خطی با پیچیدگی O(n) است، به شرطی که آرایه مرتب باشد.

مثال کد:
در اینجا یک پیاده‌سازی از جستجوی دودویی در پایتون آمده است:

def binary_search(arr, value):
    low = 0
    high = len(arr) - 1
    
    while low <= high:
        mid = (low + high) // 2
        
        if arr[mid] == value:
            return mid
        elif arr[mid] < value:
            low = mid + 1
        else:
            high = mid - 1
    
    return -1  # در صورتی که عنصر پیدا نشود

arr = [10, 20, 30, 40, 50, 60]
index = binary_search(arr, 40)  # خروجی: 3
print("Index of 40:", index)

در این مثال، ابتدا آرایه مرتب شده arr داریم. سپس از تابع binary_search برای یافتن عنصر 40 استفاده می‌کنیم. این تابع مقدار 3 را که اندیس عنصر 40 است، بازمی‌گرداند.

نکات مهم در مورد جستجوی دودویی ⚠️

- آرایه مرتب: جستجوی دودویی تنها در آرایه‌های مرتب‌شده کار می‌کند. اگر آرایه شما مرتب نیست، ابتدا باید آن را مرتب کنید (مثلاً با استفاده از الگوریتم‌های مرتب‌سازی).
- پیچیدگی زمانی: این روش به خصوص برای آرایه‌های بزرگ بسیار کارآمد است و می‌تواند زمان جستجو را به شدت کاهش دهد.

جمع‌بندی 🎯

جستجوی دودویی یکی از ابزارهای قدرتمند برای یافتن سریع عناصر در آرایه‌های مرتب‌شده است. با استفاده از این روش، می‌توانید به سرعت بخش‌های بزرگی از آرایه را نادیده بگیرید و زمان جستجو را بهینه کنید.

با این توضیحات، پارت ۲ تکمیل شد. در پارت بعدی به بررسی لیست‌های پیوندی تک‌پیوندی خواهیم پرداخت.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#آرایه‌ها #جستجوی_دودویی #ساختمان_داده‌ها #برنامه‌نویسی #پایتون #آموزش

پارت ۳: لیست‌های پیوندی تک‌پیوندی 🔗📘

سلام دوستان! 🌟 در پارت سوم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به بررسی یکی از ساختارهای داده‌ای مهم به نام لیست‌های پیوندی تک‌پیوندی (Singly Linked Lists) می‌پردازیم. لیست‌های پیوندی یک ساختار داده‌ای قدرتمند و منعطف هستند که در بسیاری از کاربردهای برنامه‌نویسی استفاده می‌شوند. بیایید شروع کنیم! 🚀

لیست پیوندی تک‌پیوندی چیست؟ 🤔

یک لیست پیوندی تک‌پیوندی مجموعه‌ای از نودها (Node) است که هر نود شامل دو بخش است:
1. داده (Data): مقداری که می‌خواهیم در لیست ذخیره کنیم.
2. اشاره‌گر (Pointer): اشاره‌گری که به نود بعدی در لیست اشاره می‌کند.

نودها به صورت زنجیره‌ای به هم متصل هستند و اولین نود با نام سر لیست (Head) شناخته می‌شود. آخرین نود نیز به جای اشاره به نود دیگر، به مقدار None اشاره می‌کند که نشان‌دهنده پایان لیست است.

تفاوت لیست پیوندی با آرایه‌ها ⚖️

- اندازه پویا: برخلاف آرایه‌ها، اندازه لیست پیوندی به راحتی می‌تواند در زمان اجرا تغییر کند.
- درج و حذف سریع‌تر: عملیات درج و حذف در لیست پیوندی سریع‌تر از آرایه‌هاست زیرا نیازی به جابجایی دیگر عناصر نیست.
- دسترسی مستقیم: در آرایه‌ها می‌توان به هر عنصر به طور مستقیم دسترسی پیدا کرد، اما در لیست پیوندی برای دسترسی به یک عنصر باید از ابتدای لیست شروع کنیم.

پیاده‌سازی لیست پیوندی تک‌پیوندی در پایتون 🛠️

در اینجا یک پیاده‌سازی ساده از لیست پیوندی تک‌پیوندی در پایتون آمده است.

class Node:
    def __init__(self, data):
        self.data = data  # ذخیره داده
        self.next = None  # اشاره‌گر به نود بعدی

class LinkedList:
    def __init__(self):
        self.head = None  # سر لیست (شروع لیست)

    def insert_at_end(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

# مثال استفاده
ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
ll.display()  # خروجی: 10 -> 20 -> 30 -> None

در این پیاده‌سازی:
- کلاس Node یک نود ساده را تعریف می‌کند که شامل داده و اشاره‌گر به نود بعدی است.
- کلاس LinkedList ساختار لیست پیوندی را تعریف می‌کند و شامل متدهایی برای اضافه کردن نود در انتهای لیست (insert_at_end) و نمایش لیست (display) است.

مزایا و معایب لیست‌های پیوندی تک‌پیوندی ⚠️

1. مزایا 🌟
- افزایش و کاهش اندازه پویا: لیست پیوندی می‌تواند به راحتی گسترش یا کوچک شود.
- درج و حذف سریع‌تر: عملیات درج و حذف بدون نیاز به جابجایی سایر عناصر انجام می‌شود.
- استفاده بهینه از حافظه: برای ذخیره داده‌ها به همان اندازه حافظه استفاده می‌شود که مورد نیاز است.

2. معایب ⚠️
- دسترسی خطی: برای دسترسی به یک عنصر خاص باید از ابتدای لیست شروع کنید، که می‌تواند زمان‌بر باشد.
- استفاده بیشتر از حافظه: هر نود به یک اشاره‌گر اضافی نیاز دارد که حافظه بیشتری مصرف می‌کند.

نتیجه‌گیری 🎯

در این پارت با مفهوم لیست‌های پیوندی تک‌پیوندی، ساختار آن‌ها، و نحوه پیاده‌سازی آن‌ها در پایتون آشنا شدیم. لیست‌های پیوندی ابزاری قدرتمند و انعطاف‌پذیر هستند که در بسیاری از مسائل برنامه‌نویسی مورد استفاده قرار می‌گیرند.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#لیست_پیوندی #برنامه‌نویسی #ساختمان_داده‌ها #پایتون #آموزش

پارت ۴: عملیات پایه روی لیست‌های پیوندی تک‌پیوندی 🔄🔗

سلام دوستان! 🌟 در پارت چهارم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به بررسی عملیات پایه‌ای که می‌توان روی لیست‌های پیوندی تک‌پیوندی انجام داد، می‌پردازیم. این عملیات شامل درج، حذف، جستجو و به‌روزرسانی عناصر در لیست‌های پیوندی است. همچنین پیچیدگی زمانی هر عملیات را بررسی خواهیم کرد. بیایید شروع کنیم! 🚀

۱. درج (Insertion) در لیست پیوندی ✏️

درج یک نود جدید در لیست پیوندی به چند حالت انجام می‌شود:
1. درج در ابتدای لیست: نود جدید به عنوان سر لیست قرار می‌گیرد و اشاره‌گر آن به نود قبلی سر لیست اشاره می‌کند.
2. درج در انتهای لیست: نود جدید به آخرین نود لیست اضافه می‌شود و اشاره‌گر نود قبلی به نود جدید اشاره می‌کند.
3. درج در وسط لیست: نود جدید در محل مشخصی از لیست قرار می‌گیرد و اشاره‌گر نود قبلی به نود جدید و اشاره‌گر نود جدید به نود بعدی اشاره می‌کند.

پیچیدگی زمانی:
- درج در ابتدای لیست O(1) است.
- درج در انتهای لیست O(n) است (زیرا باید تا انتهای لیست پیمایش کنیم).
- درج در وسط لیست O(n) است (زیرا باید محل دقیق درج را پیدا کنیم).

مثال کد:

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

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

    def insert_at_end(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node

    def insert_after(self, prev_node, data):
        if prev_node is None:
            print("Previous node must be in the list.")
            return
        new_node = Node(data)
        new_node.next = prev_node.next
        prev_node.next = new_node

ll = LinkedList()
ll.insert_at_beginning(10)
ll.insert_at_end(20)
ll.insert_after(ll.head, 15)  # درج 15 بعد از نود 10
ll.display()  # خروجی: 10 -> 15 -> 20 -> None

۲. حذف (Deletion) از لیست پیوندی ❌

حذف یک نود نیز به چند حالت انجام می‌شود:
1. حذف از ابتدای لیست: نود سر لیست حذف می‌شود و اشاره‌گر سر به نود بعدی منتقل می‌شود.
2. حذف از انتهای لیست: نود آخر لیست حذف می‌شود و اشاره‌گر نود قبلی به None تغییر می‌کند.
3. حذف از وسط لیست: نودی که باید حذف شود، از لیست برداشته می‌شود و اشاره‌گر نود قبلی به نود بعدی آن متصل می‌شود.

پیچیدگی زمانی:
- حذف از ابتدای لیست O(1) است.
- حذف از انتهای لیست O(n) است.
- حذف از وسط لیست O(n) است.

مثال کد:

class LinkedList:
    def delete_node(self, key):
        current = self.head

        if current and current.data == key:
            self.head = current.next
            current = None
            return

        prev = None
        while current and current.data != key:
            prev = current
            current = current.next

        if current is None:
            return

        prev.next = current.next
        current = None

ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
ll.delete_node(20)  # حذف نود با مقدار 20
ll.display()  # خروجی: 10 -> 30 -> None

۳. جستجو (Search) در لیست پیوندی 🔍

جستجو به معنای یافتن یک نود خاص در لیست پیوندی است. برای این کار باید از ابتدا تا انتهای لیست پیمایش کنیم تا نود مورد نظر را پیدا کنیم.

پیچیدگی زمانی: جستجو در لیست پیوندی O(n) است.

مثال کد:

class LinkedList:
    def search(self, key):
        current = self.head
        while current:
            if current.data == key:
                return True
            current = current.next
        return False

ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
found = ll.search(20)  # خروجی: True
print("Found 20:", found)

۴. به‌روزرسانی (Update) نود در لیست پیوندی 🔄

به‌روزرسانی به معنای تغییر مقدار یک نود خاص در لیست پیوندی است. برای این کار باید نود مورد نظر را پیدا کرده و داده آن را تغییر دهیم.

پیچیدگی زمانی: به‌روزرسانی O(n) است.

مثال کد:

class LinkedList:
    def update(self, old_data, new_data):
        current = self.head
        while current:
            if current.data == old_data:
                current.data = new_data
                return True
            current = current.next
        return False

ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
updated = ll.update(20, 25)  # تغییر مقدار نود 20 به 25
ll.display()  # خروجی: 10 -> 25 -> 30 -> None

در این پارت، با عملیات‌های پایه‌ای روی لیست‌های پیوندی تک‌پیوندی شامل درج، حذف، جستجو و به‌روزرسانی آشنا شدیم و هر کدام را با مثال‌های کدنویسی بررسی کردیم. این عملیات‌ها برای مدیریت داده‌ها در برنامه‌های پیچیده بسیار کاربردی هستند.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#لیست_پیوندی #برنامه‌نویسی #ساختمان_داده‌ها #پایتون #آموزش
پ

پارت ۵: لیست‌های پیوندی دوپیوندی و حلقوی 🔗🔄

سلام دوستان! 🌟 در پارت پنجم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به بررسی دو نوع دیگر از لیست‌های پیوندی، یعنی لیست‌های پیوندی دوپیوندی (Doubly Linked Lists) و لیست‌های پیوندی حلقوی (Circular Linked Lists) می‌پردازیم. این ساختارها در مواقع خاصی می‌توانند بسیار مفید باشند. بیایید شروع کنیم! 🚀

۱. لیست پیوندی دوپیوندی (Doubly Linked List) چیست؟ ↔️

در لیست پیوندی دوپیوندی، هر نود شامل سه بخش است:
1. داده (Data): مقداری که می‌خواهیم ذخیره کنیم.
2. اشاره‌گر به نود قبلی (Prev Pointer): اشاره‌گری که به نود قبلی اشاره می‌کند.
3. اشاره‌گر به نود بعدی (Next Pointer): اشاره‌گری که به نود بعدی اشاره می‌کند.

این ساختار اجازه می‌دهد تا بتوانیم لیست را در هر دو جهت (جلو و عقب) پیمایش کنیم.

مزایا:
- پیمایش در هر دو جهت (پیش‌روی و پس‌روی).
- حذف و درج نودها ساده‌تر است زیرا اشاره‌گر نود قبلی در دسترس است.

معایب:
- استفاده بیشتر از حافظه به دلیل وجود دو اشاره‌گر در هر نود.
- مدیریت پیچیده‌تر اشاره‌گرها در مقایسه با لیست‌های تک‌پیوندی.

پیاده‌سازی ساده لیست پیوندی دوپیوندی در پایتون:

class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None  # اشاره‌گر به نود قبلی
        self.next = None  # اشاره‌گر به نود بعدی

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

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
            new_node.prev = current

    def display_forward(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

    def display_backward(self):
        current = self.head
        while current.next:
            current = current.next
        while current:
            print(current.data, end=" -> ")
            current = current.prev
        print("None")

# مثال استفاده
dll = DoublyLinkedList()
dll.append(10)
dll.append(20)
dll.append(30)
dll.display_forward()  # خروجی: 10 -> 20 -> 30 -> None
dll.display_backward() # خروجی: 30 -> 20 -> 10 -> None

۲. لیست پیوندی حلقوی (Circular Linked List) چیست؟ 🔁

در لیست پیوندی حلقوی، آخرین نود لیست به جای اشاره به None، به نود اول (سر لیست) اشاره می‌کند، بنابراین لیست یک حلقه تشکیل می‌دهد. این ساختار می‌تواند برای مواقعی که نیاز به چرخش در داده‌ها داریم، مفید باشد.

مزایا:
- امکان پیمایش بی‌پایان در لیست.
- مناسب برای برنامه‌هایی که به چرخش دائمی نیاز دارند.

معایب:
- نیاز به مدیریت دقیق حلقه‌ها برای جلوگیری از حلقه‌های بی‌پایان.
- پیچیدگی بیشتر در برخی از عملیات‌ها مثل حذف نودها.

پیاده‌سازی ساده لیست پیوندی حلقوی در پایتون:

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

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

    def append(self, data):
        new_node = Node(data)
        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

    def display(self):
        if not self.head:
            return
        current = self.head
        while True:
            print(current.data, end=" -> ")
            current = current.next
            if current == self.head:
                break
        print(f"Back to {self.head.data}")

# مثال استفاده
cll = CircularLinkedList()
cll.append(10)
cll.append(20)
cll.append(30)
cll.display()  # خروجی: 10 -> 20 -> 30 -> Back to 10

۳. کاربردهای خاص لیست‌های پیوندی دوپیوندی و حلقوی 📊

- لیست‌های دوپیوندی معمولاً در سیستم‌هایی که نیاز به پیمایش دوطرفه دارند (مانند مرورگرهای وب با قابلیت بازگشت و پیشروی بین صفحات) استفاده می‌شوند.
- لیست‌های حلقوی در برنامه‌هایی مانند سیستم‌های صف‌گردشی یا بازی‌های رایانه‌ای برای مدیریت نوبت‌ها کاربرد دارند.


در این پارت، با لیست‌های پیوندی دوپیوندی و حلقوی آشنا شدیم. هر یک از این ساختارها مزایا و معایب خود را دارند و در موقعیت‌های مختلف می‌توانند مفید باشند.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#لیست_پیوندی #برنامه‌نویسی #ساختمان_داده‌ها #پایتون #آموزش

پارت ۶: پروژه عملی ساده 🛠️🎯

سلام دوستان! 🌟 در پارت ششم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به پیاده‌سازی یک پروژه عملی ساده خواهیم پرداخت. این پروژه به ما کمک می‌کند تا مفاهیم یادگرفته شده از لیست‌های پیوندی را به کار ببریم و به تسلط بیشتری در این ساختار داده‌ای برسیم. بیایید شروع کنیم! 🚀

پروژه: ساخت یک دفترچه تلفن ساده با استفاده از لیست پیوندی 📞📚

در این پروژه، یک دفترچه تلفن ساده خواهیم ساخت که به کمک لیست‌های پیوندی تک‌پیوندی اطلاعات تماس را ذخیره و مدیریت خواهد کرد. ویژگی‌های این دفترچه تلفن شامل افزودن تماس جدید، حذف تماس، جستجو برای تماس و نمایش تمام تماس‌ها خواهد بود.

مرحله ۱: تعریف کلاس‌های لازم 🏗️

ابتدا کلاس‌های مورد نیاز را تعریف می‌کنیم. شامل کلاس نود (Node) و کلاس لیست پیوندی (LinkedList).

class ContactNode:
    def __init__(self, name, phone_number):
        self.name = name
        self.phone_number = phone_number
        self.next = None

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

    def add_contact(self, name, phone_number):
        new_contact = ContactNode(name, phone_number)
        if self.head is None:
            self.head = new_contact
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_contact

    def delete_contact(self, name):
        current = self.head
        prev = None
        while current:
            if current.name == name:
                if prev:
                    prev.next = current.next
                else:
                    self.head = current.next
                return True
            prev = current
            current = current.next
        return False

    def search_contact(self, name):
        current = self.head
        while current:
            if current.name == name:
                return current.phone_number
            current = current.next
        return None

    def display_contacts(self):
        current = self.head
        while current:
            print(f"Name: {current.name}, Phone Number: {current.phone_number}")
            current = current.next

مرحله ۲: استفاده از دفترچه تلفن 📝

اکنون با استفاده از کلاس PhoneBook، چندین تماس به دفترچه تلفن اضافه کرده، آن‌ها را جستجو و حذف خواهیم کرد و تمام تماس‌ها را نمایش خواهیم داد.

# ایجاد دفترچه تلفن و افزودن تماس‌ها
phone_book = PhoneBook()
phone_book.add_contact("Alice", "123-456-7890")
phone_book.add_contact("Bob", "987-654-3210")
phone_book.add_contact("Charlie", "555-123-4567")

# نمایش تمام تماس‌ها
print("Contacts:")
phone_book.display_contacts()

# جستجوی یک تماس
print("\nSearching for Bob's number:")
number = phone_book.search_contact("Bob")
print(f"Bob's Number: {number}")

# حذف یک تماس
print("\nDeleting Charlie's contact:")
deleted = phone_book.delete_contact("Charlie")
if deleted:
    print("Charlie has been deleted.")
else:
    print("Charlie was not found.")

# نمایش تماس‌ها پس از حذف
print("\nContacts after deletion:")
phone_book.display_contacts()

در این پارت، یک دفترچه تلفن ساده با استفاده از لیست پیوندی تک‌پیوندی پیاده‌سازی کردیم. این پروژه به ما کمک کرد تا مفاهیم درج، حذف، جستجو و نمایش در لیست‌های پیوندی را عملی کنیم. این ساختار داده‌ای، ابزار مفیدی برای مدیریت داده‌ها در برنامه‌های مختلف است.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#پروژه #دفترچه_تلفن #لیست_پیوندی #برنامه‌نویسی #ساختمان_داده‌ها #پایتون #آموزش

پارت ۱: معرفی پشته (Stack) 🧱🔄

سلام دوستان! 🌟 در این سری از آموزش‌ها، به بررسی و یادگیری دو ساختمان داده‌ی بسیار مهم و کاربردی یعنی پشته (Stack) و صف (Queue) می‌پردازیم. امروز با پشته شروع می‌کنیم و ابتدا به تعریف آن و مفهوم LIFO می‌پردازیم. بیایید شروع کنیم! 🚀

پشته (Stack) چیست؟ 🤔

پشته (Stack) یک ساختار داده‌ای است که بر اساس اصل LIFO (Last In, First Out) کار می‌کند. به این معنا که آخرین عنصری که وارد پشته می‌شود، اولین عنصری است که از آن خارج می‌شود.

برای درک بهتر، تصور کنید که یک جعبه دارید و کتاب‌ها را در آن می‌چینید. هر بار که کتابی را روی جعبه می‌گذارید، باید همان کتاب را ابتدا بردارید تا بتوانید به کتاب‌های زیرین دسترسی پیدا کنید. این دقیقاً همان چیزی است که در پشته اتفاق می‌افتد.

ویژگی‌های کلیدی پشته 📌

- LIFO (Last In, First Out): آخرین عنصری که وارد پشته می‌شود، اولین عنصری است که از آن خارج می‌شود.
- فقط دسترسی به عنصر بالایی: در پشته، تنها می‌توان به آخرین عنصر وارد شده دسترسی داشت (مانند برداشتن کتاب از روی جعبه).

کاربردهای پشته در برنامه‌نویسی 💻

پشته‌ها در برنامه‌نویسی کاربردهای فراوانی دارند. در ادامه به برخی از این کاربردها اشاره می‌کنیم:

1. برگشت‌پذیری در مرورگر وب: مرورگرهای وب از پشته برای مدیریت صفحات بازدیدشده استفاده می‌کنند. هنگامی که دکمه "بازگشت" را فشار می‌دهید، صفحه قبلی از پشته خارج می‌شود و نمایش داده می‌شود.

2. ارزیابی و تبدیل عبارات جبری: پشته‌ها برای ارزیابی عبارات جبری (مثل تبدیل عبارات infix به postfix) و تجزیه و تحلیل آن‌ها به کار می‌روند.

3. مدیریت فراخوانی‌های توابع (Function Call Stack): در هنگام اجرای برنامه، اطلاعات مربوط به فراخوانی توابع در یک پشته ذخیره می‌شود. این ساختار به سیستم کمک می‌کند که بتواند به‌درستی به تابع قبلی بازگردد.

پیاده‌سازی یک پشته ساده 🛠️

حالا که با مفهوم پشته آشنا شدیم، بیایید یک پشته ساده را با استفاده از لیست در پایتون پیاده‌سازی کنیم.

class Stack:
    def __init__(self):
        self.stack = []

    def push(self, item):
        self.stack.append(item)

    def pop(self):
        if not self.is_empty():
            return self.stack.pop()
        else:
            return "Stack is empty"

    def peek(self):
        if not self.is_empty():
            return self.stack[-1]
        else:
            return "Stack is empty"

    def is_empty(self):
        return len(self.stack) == 0

    def size(self):
        return len(self.stack)

مثال کاربردی 📚

بیایید ببینیم چطور می‌توانیم از این کلاس پشته استفاده کنیم:

# ایجاد یک پشته
my_stack = Stack()

# اضافه کردن عناصر به پشته
my_stack.push(10)
my_stack.push(20)
my_stack.push(30)

# مشاهده عنصر بالای پشته
print("Top element:", my_stack.peek())  # خروجی: 30

# حذف عنصر بالای پشته
print("Popped element:", my_stack.pop())  # خروجی: 30

# بررسی پشته پس از حذف
print("Top element after pop:", my_stack.peek())  # خروجی: 20

# بررسی اندازه پشته
print("Stack size:", my_stack.size())  # خروجی: 2

در این پارت، با مفهوم پشته و کاربردهای آن آشنا شدیم و همچنین یاد گرفتیم که چگونه یک پشته ساده را با استفاده از لیست پیاده‌سازی کنیم. این ساختمان داده برای مدیریت داده‌هایی که نیاز به دسترسی LIFO دارند، بسیار مفید و قدرتمند است.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#پشته #ساختمان_داده #برنامه‌نویسی #پایتون #آموزش

پارت ۲: عملیات روی پشته 🧱🔧

سلام دوستان! 🌟 در این پارت از آموزش، قصد داریم با عملیات‌های پایه‌ای که روی پشته انجام می‌شوند، آشنا شویم. یادگیری این عملیات‌ها برای استفاده موثر از پشته در برنامه‌نویسی ضروری است. بیایید شروع کنیم! 🚀

عملیات‌های پایه‌ای روی پشته 📌

1. **افزودن عنصر (push)** 🔼

عملیات push عنصری را به بالای پشته اضافه می‌کند. این عنصر بعداً به عنوان اولین عنصر در زمان pop حذف خواهد شد.

   def push(self, item):
       self.stack.append(item)
   

پیچیدگی زمانی:ی:**
عملیات push با استفاده از لیست در پایتون دارای پیچیدگی زمانی O(1) است، زیرا افزودن یک عنصر به انتهای لیست زمان ثابتی می‌برد.

2. **حذف عنصر (pop)** 🔽

عملیات pop عنصری را از بالای پشته حذف کرده و آن را بازمی‌گرداند. اگر پشته خالی باشد، پیامی مبنی بر خالی بودن پشته بازگردانده می‌شود.

   def pop(self):
       if not self.is_empty():
           return self.stack.pop()
       else:
           return "Stack is empty"
   

**پیچیدگی زمانی:**
عملیات pop نیز با پیچیدگی زمانی O(1) انجام می‌شود، زیرا حذف عنصر از انتهای لیست زمان ثابتی مشاهده عنصر بالای پشته (peek)شته (peek)** 👀

عملیات peek بدون حذف، عنصری که در بالای پشته قرار دارد را بازمی‌گرداند. این عملیات به شما امکان می‌دهد که ببینید چه عنصری در بالای پشته قرار دارد.

   def peek(self):
       if not self.is_empty():
           return self.stack[-1]
       else:
           return "Stack is empty"
   

**پیچیدگی زمانی:**
عملیات peek نیز با پیچیدگی زمانی O(1) انجام می‌شود، زیرا مشاهده عنصر آخر در لیست نیاز به پیبررسی خالی بودن پشته (isEmpty)پشته (isEmpty)** ❓

عملیات isEmpty بررسی می‌کند که آیا پشته خالی است یا خیر. اگر پشته خالی باشد، True و در غیر این صورت False بازمی‌گرداند.

   def is_empty(self):
       return len(self.stack) == 0
   

**پیچیدگی زمانی:**
این عملیات نیز با پیچیدگی زمانی O(1) انجام می‌شود.

**پیاده‌سازی کامل کلاس پشته** 🛠️

حالا که با عملیات‌های پایه‌ای آشنا شدیم، بیایید کلاس پشته‌ی خود را کامل کنیم:

class Stack:
    def __init__(self):
        self.stack = []

    def push(self, item):
        self.stack.append(item)

    def pop(self):
        if not self.is_empty():
            return self.stack.pop()
        else:
            return "Stack is empty"

    def peek(self):
        if not self.is_empty():
            return self.stack[-1]
        else:
            return "Stack is empty"

    def is_empty(self):
        return len(self.stack) == 0

    def size(self):
        return len(self.stack)

**تمرین: بررسی تعادل پرانتزها با استفاده از پشته** 🔄

یکی از کاربردهای پشته، بررسی تعادل پرانتزها در یک رشته است. برای مثال، رشته‌ی "(a + b) * (c + d)" متعادل است، اما "(a + b))" نامتعادل است. بیایید یک تابع برای بررسی این موضوع بنویسیم.

def is_balanced(expression):
    stack = Stack()
    for char in expression:
        if char == '(':
            stack.push(char)
        elif char == ')':
            if stack.is_empty():
                return False
            stack.pop()
    return stack.is_empty()

در این پارت، با عملیات‌های پایه‌ای که روی پشته انجام می‌شوند، آشنا شدیم و یاد گرفتیم که چطور می‌توانیم این عملیات‌ها را در پایتون پیاده‌سازی کنیم. همچنین، یک مثال عملی از کاربرد پشته برای بررسی تعادل پرانتزها دیدیم. این مهارت‌ها به شما کمک می‌کند تا از پشته‌ها در برنامه‌های واقعی خود به صورت موثر استفاده کنید.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#پشته #برنامه‌نویسی #آموزش #پایتون #ساختمان_داده

پارت ۳: معرفی صف (Queue) 🛤️🚶‍♂️

سلام دوستان! 🌟 در این پارت از سری آموزشی، قصد داریم با صف (Queue) و کاربردهای آن در برنامه‌نویسی آشنا شویم. صف یکی از مفاهیم اساسی در ساختمان داده‌ها است که کاربردهای بسیاری در حل مسائل مختلف دارد. بیایید شروع کنیم! 🚀

صف (Queue) چیست؟ 🤔

صف (Queue) یک ساختار داده‌ای است که بر اساس اصل FIFO (First In, First Out) کار می‌کند. به این معنا که اولین عنصری که وارد صف می‌شود، اولین عنصری است که از آن خارج می‌شود.

برای درک بهتر، تصور کنید که در صف بانک ایستاده‌اید. اولین نفری که وارد صف شده است، اولین نفری است که خدمت دریافت می‌کند و از صف خارج می‌شود. به همین ترتیب، نفرات بعدی نیز به ترتیب وارد و خارج می‌شوند.

ویژگی‌های کلیدی صف 📌

- FIFO (First In, First Out): اولین عنصری که وارد صف می‌شود، اولین عنصری است که از آن خارج می‌شود.
- دو انتها: صف دو انتها دارد: یک انتها برای اضافه کردن عناصر (پشت صف) و یک انتها برای حذف عناصر (جلوی صف).

کاربردهای صف در برنامه‌نویسی 💻

صف‌ها در برنامه‌نویسی و سیستم‌های کامپیوتری کاربردهای فراوانی دارند. در ادامه به برخی از این کاربردها اشاره می‌کنیم:

1. مدیریت صف چاپگر: در سیستم‌های چاپ، صف‌ها برای مدیریت درخواست‌های چاپ استفاده می‌شوند. اولین درخواست چاپ که وارد صف شده، اولین درخواستی است که پردازش می‌شود.

2. پردازش صف مشتریان: در سیستم‌های بانکی و خدماتی، صف‌ها برای مدیریت درخواست‌ها و ارائه خدمات به مشتریان استفاده می‌شوند. اولین مشتری که وارد صف می‌شود، اولین نفری است که خدمت دریافت می‌کند.

3. سیستم‌های عملیاتی: در سیستم‌های عملیاتی و شبیه‌سازی‌ها، صف‌ها برای مدیریت فرآیندهای در حال انتظار استفاده می‌شوند. اولین فرآیندی که وارد صف می‌شود، اولین فرآیندی است که پردازش می‌شود.

پیاده‌سازی یک صف ساده 🛠️

حالا که با مفهوم صف آشنا شدیم، بیایید یک صف ساده را با استفاده از لیست در پایتون پیاده‌سازی کنیم.

class Queue:
    def __init__(self):
        self.queue = []

    def enqueue(self, item):
        self.queue.append(item)

    def dequeue(self):
        if not self.is_empty():
            return self.queue.pop(0)
        else:
            return "Queue is empty"

    def front(self):
        if not self.is_empty():
            return self.queue[0]
        else:
            return "Queue is empty"

    def is_empty(self):
        return len(self.queue) == 0

    def size(self):
        return len(self.queue)

مثال کاربردی 📚

بیایید ببینیم چطور می‌توانیم از این کلاس صف استفاده کنیم:

# ایجاد یک صف
my_queue = Queue()

# اضافه کردن عناصر به صف
my_queue.enqueue(10)
my_queue.enqueue(20)
my_queue.enqueue(30)

# مشاهده عنصر جلوی صف
print("Front element:", my_queue.front())  # خروجی: 10

# حذف عنصر جلوی صف
print("Dequeued element:", my_queue.dequeue())  # خروجی: 10

# بررسی صف پس از حذف
print("Front element after dequeue:", my_queue.front())  # خروجی: 20

# بررسی اندازه صف
print("Queue size:", my_queue.size())  # خروجی: 2

در این پارت، با مفهوم صف و کاربردهای آن آشنا شدیم و یاد گرفتیم که چگونه یک صف ساده را با استفاده از لیست پیاده‌سازی کنیم. صف‌ها برای مدیریت داده‌هایی که نیاز به دسترسی FIFO دارند، بسیار مفید و پرکاربرد هستند.

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#صف #برنامه‌نویسی #آموزش #پایتون #ساختمان_داده