الگوریتم چیست؟ راهنمای کامل الگوریتم در برنامه‌نویسی

الگوریتم چیست؟ تعریف ساده با یک مثال روزمره

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

هر الگوریتم از یک نقطه شروع میشه، تعدادی مرحله مشخص داره و در نهایت باید به یک نتیجه برسه. ترتیب این مراحل هم مهمه؛ چون اگر بعضی از مراحل جابه‌جا یا حذف بشن، ممکنه نتیجه اشتباه باشه یا اصلاً به نتیجه نرسیم.

برای درک بهتر، دم کردن چای رو در نظر بگیرید. برای انجام این کار معمولاً مراحل زیر رو طی می‌کنیم:

1. داخل کتری آب می‌ریزیم.
2. کتری رو روی حرارت قرار میدیم.
3. صبر می‌کنیم تا آب جوش بیاد.
4. چای رو داخل قوری می‌ریزیم.
5. آب جوش رو به قوری اضافه می‌کنیم.
6. چند دقیقه منتظر می‌مونیم تا چای دم بکشه.
7. چای رو داخل فنجون می‌ریزیم.

این مراحل در کنار هم، یک الگوریتم ساده برای دم کردن چای هستند.

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

یک مثال ساده‌تر

فرض کنید میخوایم مشخص کنیم یک دانشجو قبول شده یا نه. قانون ما اینه که اگر نمره دانشجو ۱۰ یا بیشتر باشه، قبول شده و در غیر این صورت مردود.

الگوریتم این مسئله می‌تونه به شکل زیر باشه:

1. نمره دانشجو رو دریافت کن.
2. بررسی کن که نمره بزرگ‌تر یا مساوی ۱۰ است یا نه.
3. اگر نمره ۱۰ یا بیشتر بود، پیام «قبول شده» رو نمایش بده.
4. در غیر این صورت، پیام «مردود شده» رو نمایش بده.

در این مثال:

• ورودی: نمره دانشجو
• پردازش: مقایسه نمره با عدد ۱۰
• خروجی: قبول یا مردود شدن دانشجو

تقریباً هر الگوریتمی در برنامه‌نویسی همین ساختار کلی رو داره:

ورودی → پردازش → خروجی

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

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

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

در برنامه‌نویسی، الگوریتم مشخص می‌کنه که کامپیوتر برای حل یک مسئله باید چه مراحلی رو، با چه ترتیبی و تحت چه شرایطی انجام بده.

کامپیوتر خودش نمی‌تونه منظور ما رو حدس بزنه. ما باید مسئله رو به مجموعه‌ای از دستورهای واضح و قابل اجرا تبدیل کنیم. الگوریتم دقیقاً همین مسیر رو مشخص می‌کنه و قبل از شروع کدنویسی، منطق حل مسئله رو در اختیار برنامه‌نویس قرار میده.

برای مثال، فرض کنید میخوایم در یک فروشگاه اینترنتی مبلغ نهایی سفارش مشتری رو محاسبه کنیم. برنامه باید کارهای زیر رو انجام بده:

1. قیمت هر محصول رو دریافت کنه.
2. تعداد سفارش رو دریافت کنه.
3. قیمت محصول رو در تعداد ضرب کنه.
4. تخفیف احتمالی رو محاسبه کنه.
5. هزینه ارسال رو به مبلغ اضافه کنه.
6. مبلغ نهایی رو به مشتری نمایش بده.

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

الگوریتم، مسئله بزرگ رو به مراحل کوچک‌تر تقسیم می‌کنه

یکی از مهم‌ترین کاربردهای الگوریتم اینه که یک مسئله پیچیده رو به چند مرحله کوچک‌تر و قابل مدیریت تقسیم می‌کنه.

برای مثال، ساخت یک سیستم ثبت‌نام ممکنه در نگاه اول کار بزرگی به نظر برسه؛ اما میشه اون رو به مراحل کوچک‌تری تقسیم کرد:

1. دریافت نام و اطلاعات کاربر
2. بررسی خالی نبودن فیلدها
3. بررسی معتبر بودن شماره موبایل یا ایمیل
4. بررسی تکراری نبودن حساب کاربری
5. ذخیره اطلاعات در دیتابیس
6. ارسال پیام موفقیت یا خطا

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

الگوریتم باعث میشه قبل از کدنویسی فکر کنیم

برنامه‌نویس حرفه‌ای معمولاً قبل از نوشتن کد، مسیر حل مسئله رو مشخص می‌کنه. این کار باعث میشه:

• خطاهای منطقی زودتر شناسایی بشن.
• کدهای اضافی و تکراری کمتر نوشته بشن.
• نگهداری و توسعه برنامه ساده‌تر بشه.
• برنامه‌نویس بتونه چند راه‌حل مختلف رو با هم مقایسه کنه.
• سرعت و مصرف منابع برنامه بهتر مدیریت بشه.

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

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

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

تفاوت الگوریتم با کدنویسی چیه؟

الگوریتم و کدنویسی به هم مرتبط هستند، اما یک مفهوم نیستند.

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

به زبان ساده:

الگوریتم میگه چه کاری باید انجام بشه؛ کدنویسی مشخص می‌کنه این کار چطور به زبان کامپیوتر نوشته بشه.

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

الگوریتم این مسئله می‌تونه به شکل زیر باشه:

1. عدد اول رو دریافت کن.
2. عدد دوم رو دریافت کن.
3. دو عدد رو با هم مقایسه کن.
4. عدد بزرگ‌تر رو نمایش بده.
5. اگر دو عدد برابر بودند، پیام «دو عدد برابرند» رو نمایش بده.

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

برای مثال، کد همین الگوریتم در پایتون می‌تونه به این شکل باشه:

number1 = int(input("عدد اول رو وارد کنید: "))
number2 = int(input("عدد دوم رو وارد کنید: "))
if number1 > number2:
    print(number1)
elif number2 > number1:
    print(number2)
else:
    print("دو عدد برابرند")

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

اول الگوریتم یا اول کدنویسی؟

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

برای مثال، در یک سیستم فروشگاه اینترنتی باید مشخص بشه:

• موجودی محصول چطور بررسی بشه؟
• مبلغ تخفیف چطور محاسبه بشه؟
• سفارش چه زمانی ثبت نهایی بشه؟
• اگر پرداخت ناموفق بود چه اتفاقی بیفته؟
• اگر چند کاربر هم‌زمان یک محصول رو خریدند، موجودی چطور مدیریت بشه؟

این مسائل قبل از کدنویسی به طراحی منطق و الگوریتم نیاز دارن.

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

برنامه‌نویس حرفه‌ای باید هم ابزار کدنویسی رو بشناسه و هم مهارت حل مسئله و طراحی الگوریتم داشته باشه.

آیا یک الگوریتم فقط یک شکل کدنویسی داره؟

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

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

پس تفاوت اصلی رو میشه این‌طور خلاصه کرد:

در نتیجه، الگوریتم نقشه مسیر است و کدنویسی اجرای اون نقشه.

یک الگوریتم خوب چه ویژگی‌هایی داره؟

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

مهم‌ترین ویژگی‌های یک الگوریتم خوب عبارت‌اند از:

۱. نقطه شروع مشخصی داشته باشه

الگوریتم باید دقیقاً مشخص کنه اجرای مراحل از کجا شروع میشه.

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

۲. ورودی‌های الگوریتم مشخص باشند

ورودی، اطلاعاتیه که الگوریتم برای انجام کار به اون نیاز داره.

برای مثال، الگوریتم محاسبه مساحت مستطیل به دو ورودی نیاز داره:

• طول مستطیل
• عرض مستطیل

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

۳. خروجی مشخصی تولید کنه

هر الگوریتم باید در پایان، یک نتیجه یا خروجی مشخص داشته باشه.

در مثال مساحت مستطیل، خروجی الگوریتم عددیه که از ضرب طول در عرض به دست میاد. در یک الگوریتم جست‌وجو، خروجی می‌تونه پیدا شدن یا پیدا نشدن اطلاعات موردنظر باشه.

اگر الگوریتم هیچ نتیجه مشخصی تولید نکنه، معلوم نیست مسئله رو حل کرده یا نه.

۴. مراحل واضح و بدون ابهام باشند

هر مرحله از الگوریتم باید دقیق و قابل فهم نوشته بشه. دستورهایی مثل «عددها رو بررسی کن» یا «بهترین نتیجه رو پیدا کن» به‌اندازه کافی واضح نیستند.

به‌جای اون باید مشخص کنیم:

• کدوم عددها بررسی بشن؟
• با چه شرطی مقایسه بشن؟
• منظور از بهترین نتیجه چیه؟
• در چه شرایطی الگوریتم به مرحله بعد بره؟

کامپیوتر نمی‌تونه منظور پنهان ما رو حدس بزنه. بنابراین هر مرحله باید فقط یک برداشت مشخص داشته باشه.

۵. ترتیب مراحل درست باشه

مراحل الگوریتم باید با ترتیب منطقی اجرا بشن. تغییر ترتیب بعضی مراحل ممکنه نتیجه رو کاملاً عوض کنه.

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

۶. بعد از تعداد مشخصی مرحله به پایان برسه

یک الگوریتم نباید بدون دلیل برای همیشه ادامه پیدا کنه. باید شرایطی وجود داشته باشه که اجرای اون رو متوقف کنه.

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

۷. مراحل اون قابل اجرا باشند

دستورهای الگوریتم باید عملی و قابل انجام باشند.

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

هر مرحله باید با عملیات ساده و مشخصی مثل دریافت اطلاعات، محاسبه، مقایسه، تکرار یا نمایش نتیجه قابل اجرا باشه.

۸. نتیجه درست تولید کنه

مهم‌ترین ویژگی یک الگوریتم اینه که برای ورودی‌های معتبر، خروجی درست تولید کنه.

برای مثال، الگوریتم تشخیص زوج یا فرد بودن عدد باید برای عدد ۸ نتیجه «زوج» و برای عدد ۷ نتیجه «فرد» رو نمایش بده.

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

• عدد صفر
• اعداد منفی
• ورودی خالی
• داده نامعتبر
• مقادیر بسیار بزرگ

۹. تا حد امکان ساده و بهینه باشه

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

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

بنابراین یک الگوریتم خوب فقط باید درست کار نکنه؛ بلکه بهتره:

• مراحل اضافی نداشته باشه.
• محاسبات تکراری رو کم کنه.
• سرعت مناسبی داشته باشه.
• حافظه و منابع سیستم رو بی‌دلیل مصرف نکنه.

یک مثال از الگوریتم ناقص و الگوریتم درست

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

الگوریتم ناقص:

1. سه عدد رو دریافت کن.
2. بزرگ‌ترین عدد رو پیدا کن.
3. اون رو نمایش بده.

مرحله دوم مبهمه؛ چون مشخص نکردیم بزرگ‌ترین عدد دقیقاً چطور پیدا بشه.

نسخه واضح‌تر الگوریتم:

1. سه عدد رو دریافت کن.
2. عدد اول رو به‌عنوان بزرگ‌ترین عدد در نظر بگیر.
3. اگر عدد دوم از عدد بزرگ‌تر فعلی بیشتر بود، عدد دوم رو جایگزین اون کن.
4. اگر عدد سوم از عدد بزرگ‌تر فعلی بیشتر بود، عدد سوم رو جایگزین اون کن.
5. بزرگ‌ترین عدد رو نمایش بده.
6. الگوریتم رو به پایان برسون.

در نسخه دوم، ورودی، مراحل پردازش، خروجی و نقطه پایان کاملاً مشخص هستند.

در نتیجه، یک الگوریتم خوب باید واضح، دقیق، پایان‌پذیر، قابل اجرا و دارای خروجی درست باشه. هرچه مسئله پیچیده‌تر بشه، توجه به این ویژگی‌ها اهمیت بیشتری پیدا می‌کنه.

الگوریتم رو چگونه نمایش میدیم؟

الگوریتم فقط یک مفهوم ذهنی نیست. برای اینکه بتونیم مراحل حل مسئله رو بررسی کنیم، به دیگران توضیح بدیم یا بعداً اون رو به کد تبدیل کنیم، باید الگوریتم رو به یک شکل مشخص نمایش بدیم.

چهار روش رایج برای نمایش الگوریتم وجود داره:

1. توضیح با زبان ساده
2. شبه‌کد
3. فلوچارت
4. کد برنامه‌نویسی

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

۱. نمایش الگوریتم با زبان ساده

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

برای مثال، فرض کنید میخوایم مشخص کنیم یک عدد زوج است یا فرد. الگوریتم رو میشه این‌طور توضیح داد:

1. یک عدد از کاربر دریافت کن.
2. باقی‌مانده تقسیم عدد بر ۲ رو محاسبه کن.
3. اگر باقی‌مانده صفر بود، عدد رو زوج اعلام کن.
4. در غیر این صورت، عدد رو فرد اعلام کن.
5. الگوریتم رو به پایان برسون.

مزیت این روش اینه که حتی افرادی که هنوز برنامه‌نویسی بلد نیستند هم میتونن منطق مسئله رو درک کنند.

اما برای مسائل بزرگ و پیچیده، توضیح متنی ممکنه طولانی یا مبهم بشه. در چنین شرایطی استفاده از شبه‌کد یا فلوچارت مناسب‌تره.

۲. نمایش الگوریتم با شبه‌کد

شبه‌کد یا Pseudocode روشی برای نوشتن مراحل الگوریتمه که از زبان معمولی منظم‌تره، اما به قواعد یک زبان برنامه‌نویسی خاص وابسته نیست.

برای مثال، الگوریتم تشخیص زوج یا فرد بودن عدد رو میشه به شکل زیر نوشت:

شروع
عدد رو دریافت کن
اگر باقی‌مانده تقسیم عدد بر ۲ برابر صفر بود
    پیام «عدد زوج است» رو نمایش بده
در غیر این صورت
    پیام «عدد فرد است» رو نمایش بده
پایان

شبه‌کد شبیه کدنویسیه، اما لازم نیست نگران جزئیاتی مثل نقطه‌ویرگول، پرانتز، نوع متغیر یا قواعد نگارشی زبان‌های برنامه‌نویسی باشیم.

هدف اصلی شبه‌کد اینه که منطق حل مسئله رو واضح و مرحله‌به‌مرحله نمایش بده.

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

۳. نمایش الگوریتم با فلوچارت

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

در فلوچارت، هر شکل معنی مشخصی داره:

• شکل بیضی برای شروع و پایان
• مستطیل برای انجام محاسبات و پردازش
• لوزی برای بررسی شرط
• متوازی‌الاضلاع برای دریافت ورودی یا نمایش خروجی
• فلش برای مشخص‌کردن مسیر اجرای مراحل

برای مثال، فلوچارت تشخیص زوج یا فرد بودن عدد چنین مسیری داره:

شروع ← دریافت عدد ← بررسی باقی‌مانده تقسیم بر ۲ ← نمایش زوج یا فرد ← پایان

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

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

۴. نمایش الگوریتم با کد برنامه‌نویسی

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

برای مثال، الگوریتم تشخیص زوج یا فرد بودن عدد در پایتون می‌تونه به این شکل نوشته بشه:

number = int(input("یک عدد وارد کنید: "))
if number % 2 == 0:
    print("عدد زوج است")
else:
    print("عدد فرد است")

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

Console.Write("یک عدد وارد کنید: ");
int number = Convert.ToInt32(Console.ReadLine());
if (number % 2 == 0)
{
    Console.WriteLine("عدد زوج است");
}
else
{
    Console.WriteLine("عدد فرد است");
}

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

مقایسه روش‌های نمایش الگوریتم

در عمل، معمولاً ابتدا مسئله رو با زبان ساده تحلیل می‌کنیم، بعد در صورت نیاز شبه‌کد یا فلوچارت اون رو می‌نویسیم و در نهایت الگوریتم رو به کد تبدیل می‌کنیم.

این روند کمک می‌کنه قبل از درگیرشدن با جزئیات یک زبان برنامه‌نویسی، مطمئن بشیم که منطق حل مسئله درست طراحی شده.

چگونه الگوریتم بنویسیم؟

برای نوشتن الگوریتم، لازم نیست از همون ابتدا سراغ کدنویسی بریم. اول باید مسئله رو درست بفهمیم، ورودی و خروجی رو مشخص کنیم و بعد مسیر رسیدن به جواب رو به چند مرحله ساده تقسیم کنیم.

در ادامه، مراحل نوشتن یک الگوریتم رو قدم‌به‌قدم بررسی می‌کنیم.

۱. مسئله رو دقیق مشخص کنیم

اولین مرحله اینه که دقیقاً بدونیم قراره چه مسئله‌ای رو حل کنیم.

برای مثال، جمله زیر خیلی کلیه:

یک برنامه برای نمرات دانشجوها بنویس.

اما مشخص نیست برنامه باید چه کاری انجام بده:

• میانگین نمرات رو حساب کنه؟
• بالاترین نمره رو پیدا کنه؟
• دانشجویان قبول و مردود رو مشخص کنه؟
• نمرات رو مرتب کنه؟

تعریف دقیق‌تر مسئله می‌تونه این باشه:

برنامه‌ای طراحی کنیم که سه نمره رو دریافت کنه، میانگین اون‌ها رو محاسبه کنه و مشخص کنه دانشجو قبول شده یا مردود.

هرچه صورت مسئله واضح‌تر باشه، طراحی الگوریتم هم ساده‌تر میشه.

۲. ورودی‌های مسئله رو مشخص کنیم

بعد باید بررسی کنیم الگوریتم برای انجام کار به چه اطلاعاتی نیاز داره.

در مثال محاسبه میانگین، ورودی‌ها عبارت‌اند از:

• نمره اول
• نمره دوم
• نمره سوم

نوع ورودی هم مهمه. مثلاً باید مشخص کنیم نمره‌ها عدد هستند و در چه محدوده‌ای قرار می‌گیرند.

برای نمونه، اگر نمره‌ها از صفر تا ۲۰ باشند، ورود عدد ۲۵ یا یک متن مثل «عالی» معتبر نیست.

۳. خروجی مورد انتظار رو تعیین کنیم

باید بدونیم الگوریتم در پایان چه نتیجه‌ای رو تولید می‌کنه.

در مثال ما، خروجی‌ها شامل این موارد هستند:

• میانگین نمرات
• وضعیت قبولی یا مردودی دانشجو

اگر خروجی از ابتدا مشخص نباشه، ممکنه مراحل غیرضروری طراحی کنیم یا بخشی از مسئله رو فراموش کنیم.

۴. مسئله رو به مراحل کوچک‌تر تقسیم کنیم

حالا باید مسیر رسیدن از ورودی به خروجی رو به چند مرحله ساده و مشخص تقسیم کنیم.

الگوریتم محاسبه میانگین سه نمره می‌تونه این مراحل رو داشته باشه:

1. نمره اول رو دریافت کن.
2. نمره دوم رو دریافت کن.
3. نمره سوم رو دریافت کن.
4. سه نمره رو با هم جمع کن.
5. حاصل جمع رو بر ۳ تقسیم کن.
6. میانگین رو نمایش بده.
7. اگر میانگین ۱۰ یا بیشتر بود، پیام «قبول شده» رو نمایش بده.
8. در غیر این صورت، پیام «مردود شده» رو نمایش بده.
9. الگوریتم رو به پایان برسون.

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

۵. شرط‌ها و حالت‌های مختلف رو بررسی کنیم

بسیاری از مسائل فقط یک مسیر مستقیم ندارن و بسته به شرایط مختلف، مسیر اجرای الگوریتم تغییر می‌کنه.

در مثال نمرات، یک شرط داریم:

• اگر میانگین ۱۰ یا بیشتر باشه، دانشجو قبوله.
• اگر میانگین کمتر از ۱۰ باشه، دانشجو مردوده.

اما ممکنه حالت‌های بیشتری هم وجود داشته باشه:

• اگر نمره‌ای کمتر از صفر وارد شد، پیام خطا نمایش داده بشه.
• اگر نمره‌ای بیشتر از ۲۰ بود، ورودی نامعتبر اعلام بشه.
• اگر کاربر به‌جای عدد، متن وارد کرد، برنامه متوقف نشه.

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

۶. تکرارها رو شناسایی کنیم

بعضی مسائل شامل انجام چندباره یک کار هستند.

برای مثال، اگر بخوایم میانگین نمرات ۳۰ دانشجو رو محاسبه کنیم، منطقی نیست دستور دریافت نمره رو ۳۰ بار تکرار کنیم. در این شرایط از یک ساختار تکرار یا حلقه استفاده می‌کنیم.

الگوریتم ساده می‌تونه این‌طور باشه:

1. تعداد دانشجوها رو دریافت کن.
2. یک متغیر برای مجموع نمرات در نظر بگیر.
3. نمره هر دانشجو رو دریافت کن.
4. نمره رو به مجموع اضافه کن.
5. این کار رو برای تمام دانشجوها تکرار کن.
6. مجموع نمرات رو بر تعداد دانشجوها تقسیم کن.
7. میانگین رو نمایش بده.

در طراحی الگوریتم باید بررسی کنیم کدوم مراحل تکرار میشن و شرط پایان تکرار چیه.

۷. الگوریتم رو با چند ورودی آزمایش کنیم

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

برای مثال، سه نمره زیر رو در نظر بگیریم:

• نمره اول: ۱۲
• نمره دوم: ۱۴
• نمره سوم: ۱۰

مراحل محاسبه:

مجموع نمرات = ۱۲ + ۱۴ + ۱۰

مجموع نمرات = ۳۶

میانگین = ۳۶ ÷ ۳

میانگین = ۱۲

چون میانگین ۱۲ و بزرگ‌تر از ۱۰ است، خروجی باید «قبول شده» باشه.

حالا الگوریتم رو با حالت‌های دیگه هم بررسی می‌کنیم:

• میانگین دقیقاً ۱۰
• میانگین کمتر از ۱۰
• نمره صفر
• نمره منفی
• نمره بیشتر از ۲۰
• ورود متن به‌جای عدد

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

۸. مراحل اضافی رو حذف کنیم

بعد از طراحی اولیه، باید الگوریتم رو دوباره بررسی کنیم و ببینیم آیا مرحله تکراری یا غیرضروری وجود داره یا نه.

یک الگوریتم خوب بهتره:

• مراحل اضافه نداشته باشه.
• محاسبات تکراری رو دوباره انجام نده.
• مسیر ساده و قابل فهمی داشته باشه.
• بدون پیچیدگی غیرضروری به نتیجه برسه.

البته ساده‌بودن به معنی ناقص‌بودن نیست. الگوریتم باید هم ساده باشه و هم تمام حالت‌های مهم مسئله رو پوشش بده.

۹. الگوریتم رو به شبه‌کد یا فلوچارت تبدیل کنیم

وقتی مراحل حل مسئله مشخص شدند، می‌تونیم اون‌ها رو به شکل شبه‌کد یا فلوچارت نمایش بدیم.

شبه‌کد مثال محاسبه میانگین می‌تونه به این شکل باشه:

شروع
نمره اول رو دریافت کن
نمره دوم رو دریافت کن
نمره سوم رو دریافت کن
اگر هرکدوم از نمرات کمتر از صفر یا بیشتر از ۲۰ بود
    پیام «نمره نامعتبر است» رو نمایش بده
در غیر این صورت
    مجموع = نمره اول + نمره دوم + نمره سوم
    میانگین = مجموع تقسیم بر ۳
    میانگین رو نمایش بده
    اگر میانگین بزرگ‌تر یا مساوی ۱۰ بود
        پیام «دانشجو قبول شده است» رو نمایش بده
    در غیر این صورت
        پیام «دانشجو مردود شده است» رو نمایش بده
پایان

در این مرحله، منطق الگوریتم تقریباً کامل شده و آماده تبدیل‌شدن به کده.

۱۰. الگوریتم رو به کد تبدیل کنیم

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

برای مثال، همین الگوریتم در پایتون می‌تونه به شکل زیر نوشته بشه:

score1 = float(input("نمره اول رو وارد کنید: "))
score2 = float(input("نمره دوم رو وارد کنید: "))
score3 = float(input("نمره سوم رو وارد کنید: "))

if (
    score1 < 0 or score1 > 20
    or score2 < 0 or score2 > 20
    or score3 < 0 or score3 > 20
):
    print("نمره واردشده معتبر نیست.")
else:
    average = (score1 + score2 + score3) / 3
    print("میانگین:", average)
    if average >= 10:
        print("دانشجو قبول شده است.")
    else:
        print("دانشجو مردود شده است.")

همین الگوریتم رو میشه با سی‌شارپ، جاوا اسکریپت، جاوا یا هر زبان برنامه‌نویسی دیگه‌ای هم پیاده‌سازی کرد.

خلاصه مراحل نوشتن الگوریتم

برای طراحی یک الگوریتم می‌تونیم این مسیر رو دنبال کنیم:

تعریف دقیق مسئله ← مشخص‌کردن ورودی‌ها ← تعیین خروجی ← تقسیم مسئله به مراحل کوچک ← بررسی شرط‌ها و تکرارها ← آزمایش الگوریتم ← حذف مراحل اضافی ← نوشتن شبه‌کد یا فلوچارت ← تبدیل به کد

مهم‌ترین نکته اینه که قبل از نوشتن کد، بدونیم مسئله دقیقاً چیه و کامپیوتر باید برای رسیدن به نتیجه چه مراحلی رو انجام بده.

چند مثال ساده از الگوریتم در برنامه‌نویسی

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

مثال اول: تشخیص زوج یا فرد بودن عدد

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

برای حل این مسئله، باید باقی‌مانده تقسیم عدد بر ۲ رو بررسی کنیم.

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

الگوریتم

1. یک عدد رو دریافت کن.
2. باقی‌مانده تقسیم عدد بر ۲ رو محاسبه کن.
3. اگر باقی‌مانده برابر صفر بود، پیام «عدد زوج است» رو نمایش بده.
4. در غیر این صورت، پیام «عدد فرد است» رو نمایش بده.
5. الگوریتم رو به پایان برسون.

شبه‌کد

شروع
عدد رو دریافت کن
اگر عدد % ۲ برابر صفر بود
    پیام «عدد زوج است» رو نمایش بده
در غیر این صورت
    پیام «عدد فرد است» رو نمایش بده
پایان

پیاده‌سازی با پایتون

number = int(input("یک عدد وارد کنید: "))
if number % 2 == 0:
    print("عدد زوج است")
else:
    print("عدد فرد است")

این الگوریتم یک نمونه ساده از الگوریتم‌های شرطیه؛ چون نتیجه اجرا به درست یا غلط بودن یک شرط بستگی داره.

مثال دوم: پیدا کردن بزرگ‌ترین عدد بین سه عدد

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

الگوریتم

1. عدد اول رو دریافت کن.
2. عدد دوم رو دریافت کن.
3. عدد سوم رو دریافت کن.
4. عدد اول رو به‌عنوان بزرگ‌ترین عدد در نظر بگیر.
5. اگر عدد دوم از مقدار فعلی بزرگ‌تر بود، عدد دوم رو جایگزین کن.
6. اگر عدد سوم از مقدار فعلی بزرگ‌تر بود، عدد سوم رو جایگزین کن.
7. بزرگ‌ترین عدد رو نمایش بده.
8. الگوریتم رو به پایان برسون.

شبه‌کد

شروع
عدد اول رو دریافت کن
عدد دوم رو دریافت کن
عدد سوم رو دریافت کن
بزرگ‌ترین عدد = عدد اول
اگر عدد دوم از بزرگ‌ترین عدد بیشتر بود
    بزرگ‌ترین عدد = عدد دوم
اگر عدد سوم از بزرگ‌ترین عدد بیشتر بود
    بزرگ‌ترین عدد = عدد سوم
بزرگ‌ترین عدد رو نمایش بده
پایان

پیاده‌سازی با پایتون

number1 = int(input("عدد اول رو وارد کنید: "))
number2 = int(input("عدد دوم رو وارد کنید: "))
number3 = int(input("عدد سوم رو وارد کنید: "))

largest = number1
if number2 > largest:
    largest = number2
if number3 > largest:
    largest = number3

print("بزرگ‌ترین عدد:", largest)

در این الگوریتم، یک مقدار اولیه برای بزرگ‌ترین عدد در نظر می‌گیریم و بعد بقیه عددها رو با اون مقایسه می‌کنیم.

مثال سوم: محاسبه مجموع اعداد ۱ تا ۱۰۰

فرض کنید میخوایم مجموع تمام اعداد از ۱ تا ۱۰۰ رو محاسبه کنیم.

یعنی:

۱ + ۲ + ۳ + ... + ۱۰۰

برای انجام این کار می‌تونیم از یک حلقه استفاده کنیم.

الگوریتم

1. یک متغیر به نام مجموع با مقدار صفر ایجاد کن.
2. عددهای ۱ تا ۱۰۰ رو یکی‌یکی بررسی کن.
3. هر عدد رو به مجموع اضافه کن.
4. بعد از رسیدن به عدد ۱۰۰، مجموع رو نمایش بده.
5. الگوریتم رو به پایان برسون.

شبه‌کد

شروع
مجموع = صفر
برای عددهای ۱ تا ۱۰۰
    عدد رو به مجموع اضافه کن
مجموع رو نمایش بده
پایان

پیاده‌سازی با پایتون

total = 0
for number in range(1, 101):
    total += number
print("مجموع اعداد:", total)

این مثال یک الگوریتم تکراریه؛ چون یک مرحله مشخص، چند بار پشت سر هم اجرا میشه.

مثال چهارم: محاسبه میانگین نمرات

فرض کنید نمرات چند دانشجو داخل یک لیست قرار دارن و میخوایم میانگین اون‌ها رو حساب کنیم.

برای محاسبه میانگین باید:

1. تمام نمرات رو با هم جمع کنیم.
2. مجموع نمرات رو بر تعداد اون‌ها تقسیم کنیم.

الگوریتم

1. لیست نمرات رو دریافت کن.
2. یک متغیر برای مجموع نمرات ایجاد کن.
3. تمام نمرات رو یکی‌یکی به مجموع اضافه کن.
4. تعداد نمرات رو مشخص کن.
5. مجموع رو بر تعداد نمرات تقسیم کن.
6. میانگین رو نمایش بده.
7. الگوریتم رو به پایان برسون.

پیاده‌سازی با پایتون

scores = [12, 16, 18, 14, 10]
total = 0
for score in scores:
    total += score
average = total / len(scores)
print("میانگین نمرات:", average)

در یک برنامه واقعی باید حالت خالی بودن لیست رو هم بررسی کنیم؛ چون تقسیم عدد بر صفر باعث خطا میشه.

scores = []
if len(scores) == 0:
    print("هیچ نمره‌ای ثبت نشده است.")
else:
    total = 0
    for score in scores:
        total += score
    average = total / len(scores)
    print("میانگین نمرات:", average)

این مثال نشون میده یک الگوریتم خوب باید فقط حالت عادی رو در نظر نگیره و برای شرایط خاص هم رفتار مشخصی داشته باشه.

مثال پنجم: پیدا کردن یک نام در لیست

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

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

الگوریتم

1. لیست نام‌ها رو دریافت کن.
2. نام موردنظر رو دریافت کن.
3. از اولین نام داخل لیست شروع کن.
4. هر نام رو با نام موردنظر مقایسه کن.
5. اگر دو نام برابر بودند، پیام «نام پیدا شد» رو نمایش بده.
6. اگر به پایان لیست رسیدی و نام پیدا نشد، پیام «نام پیدا نشد» رو نمایش بده.
7. الگوریتم رو به پایان برسون.

پیاده‌سازی با پایتون

students = ["علی", "مریم", "رضا", "سارا"]
target_name = input("نام موردنظر رو وارد کنید: ")

found = False
for student in students:
    if student == target_name:
        found = True
        break

if found:
    print("نام پیدا شد.")
else:
    print("نام پیدا نشد.")

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

مثال ششم: مرتب‌کردن چند عدد

فرض کنید عددهای زیر رو داریم:

۷، ۳، ۹، ۲، ۵

میخوایم اون‌ها رو از کوچک به بزرگ مرتب کنیم:

۲، ۳، ۵، ۷، ۹

برای انجام این کار الگوریتم‌های مختلفی وجود دارن. یکی از ساده‌ترین اون‌ها Bubble Sort یا مرتب‌سازی حبابیه.

در این روش، عددهای کنار هم با هم مقایسه میشن و اگر ترتیب اون‌ها اشتباه باشه، جاشون عوض میشه.

روند ساده اجرا

لیست اولیه:

۷، ۳، ۹، ۲، ۵

مقایسه ۷ و ۳:

۳، ۷، ۹، ۲، ۵

مقایسه ۷ و ۹:

۳، ۷، ۹، ۲، ۵

مقایسه ۹ و ۲:

۳، ۷، ۲، ۹، ۵

مقایسه ۹ و ۵:

۳، ۷، ۲، ۵، ۹

بعد این روند دوباره تکرار میشه تا تمام عددها مرتب بشن.

پیاده‌سازی با پایتون

numbers = [7, 3, 9, 2, 5]
for i in range(len(numbers)):
    for j in range(0, len(numbers) - i - 1):
        if numbers[j] > numbers[j + 1]:
            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
print(numbers)

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

مثال هفتم: محاسبه فاکتوریل یک عدد

فاکتوریل عدد ۵ به این شکل محاسبه میشه:

۵ × ۴ × ۳ × ۲ × ۱ = ۱۲۰

فاکتوریل صفر هم برابر با ۱ در نظر گرفته میشه.

الگوریتم

1. یک عدد رو دریافت کن.
2. مقدار حاصل رو برابر ۱ قرار بده.
3. عددهای ۱ تا عدد واردشده رو در حاصل ضرب کن.
4. نتیجه رو نمایش بده.
5. الگوریتم رو به پایان برسون.

پیاده‌سازی با پایتون

number = int(input("یک عدد وارد کنید: "))
factorial = 1
for current_number in range(1, number + 1):
    factorial *= current_number
print("فاکتوریل:", factorial)

در نسخه کامل‌تر باید بررسی کنیم که عدد واردشده منفی نباشه؛ چون فاکتوریل برای اعداد منفی در این تعریف ساده قابل محاسبه نیست.

number = int(input("یک عدد وارد کنید: "))
if number < 0:
    print("فاکتوریل برای اعداد منفی تعریف نشده است.")
else:
    factorial = 1
    for current_number in range(1, number + 1):
        factorial *= current_number
    print("فاکتوریل:", factorial)

نتیجه‌ای که از این مثال‌ها می‌گیریم

ظاهر مسئله‌ها با هم فرق داره، اما ساختار کلی الگوریتم‌ها معمولاً شامل چند عنصر اصلیه:

• دریافت ورودی
• انجام محاسبه یا مقایسه
• استفاده از شرط
• تکرار بعضی مراحل
• تولید خروجی
• پایان مشخص

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

وقتی برنامه‌نویس بتونه یک مسئله رو به مراحل کوچک، واضح و قابل اجرا تقسیم کنه، تبدیل اون مراحل به کد هم خیلی ساده‌تر میشه.

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

الگوریتم‌ها چند نوع هستند؟

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

به همین دلیل، نمی‌تونیم بگیم در برنامه‌نویسی دقیقاً ۵، ۱۰ یا ۲۰ نوع الگوریتم وجود داره. الگوریتم‌ها رو میشه از زاویه‌های مختلف دسته‌بندی کرد.

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

1. بر اساس ساختار اجرای مراحل
2. بر اساس روش حل مسئله

دسته‌بندی الگوریتم‌ها بر اساس ساختار اجرا

در سطح مقدماتی، بیشتر الگوریتم‌ها از سه ساختار اصلی ساخته میشن:

• ساختار ترتیبی
• ساختار شرطی
• ساختار تکراری

تقریباً هر برنامه‌ای که نوشته میشه، ترکیبی از همین سه ساختار رو در خودش داره.

۱. الگوریتم ترتیبی

در الگوریتم ترتیبی، دستورها یکی‌یکی و به همون ترتیبی که نوشته شده‌اند اجرا میشن.

برای مثال، الگوریتم محاسبه مساحت مستطیل:

1. طول رو دریافت کن.
2. عرض رو دریافت کن.
3. طول رو در عرض ضرب کن.
4. مساحت رو نمایش بده.

در این الگوریتم هیچ شرط یا تکراری وجود نداره و مراحل از ابتدا تا انتها به‌ترتیب اجرا میشن.

نمونه کد پایتون:

length = float(input("طول رو وارد کنید: "))
width = float(input("عرض رو وارد کنید: "))
area = length * width
print("مساحت مستطیل:", area)

۲. الگوریتم شرطی

در الگوریتم شرطی، مسیر اجرای برنامه به برقرار بودن یا نبودن یک شرط بستگی داره.

برای مثال، الگوریتم تشخیص قبولی دانشجو:

1. نمره رو دریافت کن.
2. اگر نمره ۱۰ یا بیشتر بود، پیام «قبول شده» رو نمایش بده.
3. در غیر این صورت، پیام «مردود شده» رو نمایش بده.

نمونه کد پایتون:

score = float(input("نمره رو وارد کنید: "))
if score >= 10:
    print("قبول شده")
else:
    print("مردود شده")

در این الگوریتم، برنامه بر اساس مقدار نمره یکی از دو مسیر رو انتخاب می‌کنه.

۳. الگوریتم تکراری

در الگوریتم تکراری، یک یا چند مرحله چند بار اجرا میشن.

برای مثال، الگوریتم نمایش اعداد ۱ تا ۵:

1. عدد ۱ رو در نظر بگیر.
2. عدد رو نمایش بده.
3. یک واحد به عدد اضافه کن.
4. تا زمانی که عدد از ۵ بیشتر نشده، مراحل رو تکرار کن.

نمونه کد پایتون:

for number in range(1, 6):
    print(number)

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

دسته‌بندی الگوریتم‌ها بر اساس روش حل مسئله

الگوریتم‌ها رو میشه بر اساس روشی که برای حل مسئله استفاده می‌کنن هم دسته‌بندی کرد.

در ادامه مهم‌ترین انواع الگوریتم‌ها رو بررسی می‌کنیم.

۱. الگوریتم‌های جست‌وجو

این الگوریتم‌ها برای پیدا کردن یک داده در بین مجموعه‌ای از اطلاعات استفاده میشن.

مثال‌ها:

• پیدا کردن نام یک دانشجو در لیست
• پیدا کردن محصول در فروشگاه
• پیدا کردن شماره تماس در دفترچه تلفن
• جست‌وجوی یک کلمه داخل متن

دو الگوریتم معروف جست‌وجو عبارت‌اند از:

• جست‌وجوی خطی یا Linear Search
• جست‌وجوی دودویی یا Binary Search

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

البته جست‌وجوی دودویی فقط زمانی قابل استفاده است که داده‌ها از قبل مرتب شده باشن.

۲. الگوریتم‌های مرتب‌سازی

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

برای مثال:

• مرتب‌کردن قیمت محصولات از کم به زیاد
• مرتب‌کردن نمرات از بیشترین به کمترین
• مرتب‌کردن نام کاربران بر اساس حروف الفبا
• مرتب‌کردن سفارش‌ها بر اساس تاریخ

الگوریتم‌های معروف مرتب‌سازی عبارت‌اند از:

• Bubble Sort
• Selection Sort
• Insertion Sort
• Merge Sort
• Quick Sort

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

۳. الگوریتم‌های بازگشتی

در الگوریتم بازگشتی یا Recursive Algorithm، یک تابع برای حل مسئله دوباره خودش رو فراخوانی می‌کنه.

برای مثال، محاسبه فاکتوریل عدد ۵ رو میشه این‌طور در نظر گرفت:

فاکتوریل ۵ = ۵ × فاکتوریل ۴

فاکتوریل ۴ = ۴ × فاکتوریل ۳

فاکتوریل ۳ = ۳ × فاکتوریل ۲

نمونه کد پایتون:

def factorial(number):
    if number == 0:
        return 1
    return number * factorial(number - 1)

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

۴. الگوریتم‌های تقسیم و حل

در روش تقسیم و حل یا Divide and Conquer، مسئله بزرگ به چند مسئله کوچک‌تر تقسیم میشه.

بعد هر بخش جداگانه حل میشه و در نهایت جواب‌ها با هم ترکیب میشن.

مراحل کلی این روش عبارت‌اند از:

1. مسئله رو به بخش‌های کوچک‌تر تقسیم کن.
2. هر بخش رو جداگانه حل کن.
3. جواب بخش‌ها رو با هم ترکیب کن.

الگوریتم‌های معروفی مثل Merge Sort و Quick Sort از این روش استفاده می‌کنن.

جست‌وجوی دودویی هم نمونه‌ای از تقسیم مسئله است؛ چون در هر مرحله، نیمی از داده‌ها کنار گذاشته میشن.

۵. الگوریتم‌های حریصانه

در الگوریتم حریصانه یا Greedy Algorithm، در هر مرحله گزینه‌ای انتخاب میشه که در همون لحظه بهترین انتخاب به نظر میرسه.

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

برای مثال، فرض کنید بخوایم یک مبلغ رو با کمترین تعداد اسکناس پرداخت کنیم. ممکنه الگوریتم در هر مرحله بزرگ‌ترین اسکناس ممکن رو انتخاب کنه.

الگوریتم‌های حریصانه معمولاً ساده و سریع هستند، اما در همه مسائل بهترین جواب نهایی رو تولید نمی‌کنن.

به همین دلیل، قبل از استفاده از این روش باید مطمئن بشیم انتخاب بهترین گزینه در هر مرحله، واقعاً به جواب مطلوب نهایی منجر میشه.

۶. الگوریتم‌های برنامه‌نویسی پویا

در برنامه‌نویسی پویا یا Dynamic Programming، نتایج محاسبات قبلی ذخیره میشن تا دوباره محاسبه نشن.

برای مثال، در محاسبه دنباله فیبوناچی، بعضی مقدارها بارها تکرار میشن. اگر نتیجه هر محاسبه رو ذخیره کنیم، سرعت اجرای الگوریتم خیلی بیشتر میشه.

این روش معمولاً زمانی استفاده میشه که:

• مسئله به چند زیرمسئله تقسیم بشه.
• زیرمسئله‌ها چند بار تکرار بشن.
• بشه نتیجه محاسبات قبلی رو ذخیره و دوباره استفاده کرد.

برنامه‌نویسی پویا در مسائلی مثل مسیریابی، زمان‌بندی، بهینه‌سازی و پردازش داده‌ها کاربرد زیادی داره.

۷. الگوریتم‌های عقبگرد

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

برای مثال، هنگام خروج از یک هزارتو:

1. یک مسیر رو انتخاب می‌کنیم.
2. در مسیر حرکت می‌کنیم.
3. اگر به بن‌بست رسیدیم، برمی‌گردیم.
4. مسیر دیگه‌ای رو امتحان می‌کنیم.

این روش در مسائل زیر کاربرد داره:

• حل سودوکو
• پیدا کردن مسیر در هزارتو
• مسئله هشت وزیر
• تولید ترکیب‌های مختلف
• حل مسائل محدودیت‌دار

عقبگرد معمولاً تمام انتخاب‌های ممکن رو به‌شکل کنترل‌شده بررسی می‌کنه.

۸. الگوریتم‌های گراف

گراف ساختاریه که از تعدادی نقطه و ارتباط بین اون‌ها تشکیل شده.

برای مثال:

• شهرها و جاده‌های بین اون‌ها
• کاربران و ارتباطات اون‌ها در شبکه اجتماعی
• ایستگاه‌های مترو و مسیرهای ارتباطی
• صفحات سایت و لینک‌های بین اون‌ها

الگوریتم‌های گراف برای بررسی مسیرها و ارتباطات استفاده میشن.

نمونه‌های معروف:

• الگوریتم دایکسترا برای پیدا کردن کوتاه‌ترین مسیر
• الگوریتم BFS برای پیمایش سطح‌به‌سطح
• الگوریتم DFS برای پیمایش عمقی
• الگوریتم‌های پیدا کردن درخت پوشای کمینه

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

۹. الگوریتم‌های رشته و متن

این الگوریتم‌ها برای کار با متن‌ها و رشته‌های کاراکتری استفاده میشن.

برای مثال:

• پیدا کردن یک کلمه داخل متن
• بررسی برابر بودن دو متن
• جایگزین‌کردن کلمات
• بررسی قرینه بودن یک عبارت
• جست‌وجوی الگو داخل متن
• بررسی غلط‌های املایی

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

۱۰. الگوریتم‌های تصادفی

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

برای مثال:

• انتخاب تصادفی یک آیتم
• تولید رمز عبور
• ترکیب‌کردن کارت‌ها در بازی
• انتخاب نمونه از داده‌ها
• بعضی روش‌های بهینه‌سازی

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

۱۱. الگوریتم‌های هوش مصنوعی و یادگیری ماشین

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

برای مثال:

• تشخیص ایمیل اسپم
• پیش‌بینی قیمت خانه
• پیشنهاد فیلم و محصول
• تشخیص تصویر
• تحلیل رفتار مشتری
• پیش‌بینی ریزش کاربران

نمونه‌هایی از الگوریتم‌های یادگیری ماشین عبارت‌اند از:

• Linear Regression
• Logistic Regression
• Decision Tree
• K-Nearest Neighbors
• Support Vector Machine
• Neural Networks

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

آیا هر الگوریتم فقط در یک دسته قرار می‌گیره؟

نه. یک الگوریتم ممکنه هم‌زمان در چند دسته قرار بگیره.

برای مثال:

• Merge Sort هم یک الگوریتم مرتب‌سازیه و هم از روش تقسیم و حل استفاده می‌کنه.
• جست‌وجوی عمقی گراف می‌تونه با روش بازگشتی پیاده‌سازی بشه.
• بعضی الگوریتم‌های گراف از روش حریصانه استفاده می‌کنن.
• بعضی مسائل برنامه‌نویسی پویا با بازگشت هم قابل پیاده‌سازی هستند.

بنابراین این دسته‌بندی‌ها کاملاً جدا از هم نیستند و بیشتر کمک می‌کنن روش کار و کاربرد هر الگوریتم رو بهتر درک کنیم.

جدول خلاصه انواع الگوریتم‌ها

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

الگوریتم‌های معروف در برنامه‌نویسی

در دنیای برنامه‌نویسی، بعضی الگوریتم‌ها اهمیت بیشتری دارن؛ چون در پروژه‌های واقعی، مصاحبه‌های استخدامی، طراحی نرم‌افزار و حل مسائل مختلف بارها از اون‌ها استفاده میشه.

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

۱. جست‌وجوی خطی یا Linear Search

جست‌وجوی خطی یکی از ساده‌ترین الگوریتم‌های جست‌وجوئه.

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

برای مثال، فرض کنید این لیست رو داریم:

۱۲، ۷، ۲۵، ۹، ۱۸

و میخوایم عدد ۹ رو پیدا کنیم.

الگوریتم به‌ترتیب عددهای ۱۲، ۷، ۲۵ و بعد ۹ رو بررسی می‌کنه. وقتی به عدد ۹ رسید، جست‌وجو متوقف میشه.

نمونه کد پایتون:

numbers = [12, 7, 25, 9, 18]
target = 9
found_index = -1

for index in range(len(numbers)):
    if numbers[index] == target:
        found_index = index
        break

if found_index != -1:
    print("عدد در موقعیت", found_index, "پیدا شد.")
else:
    print("عدد پیدا نشد.")

جست‌وجوی خطی ساده است و به مرتب‌بودن داده‌ها نیاز نداره؛ اما وقتی حجم اطلاعات خیلی زیاد باشه، ممکنه سرعت مناسبی نداشته باشه.

۲. جست‌وجوی دودویی یا Binary Search

جست‌وجوی دودویی برای پیدا کردن یک مقدار در یک لیست مرتب استفاده میشه.

این الگوریتم به‌جای بررسی همه عناصر، در هر مرحله لیست رو به دو قسمت تقسیم می‌کنه.

برای مثال، فرض کنید لیست زیر مرتب شده:

۲، ۵، ۸، ۱۲، ۱۷، ۲۱، ۳۰

اگر بخوایم عدد ۱۷ رو پیدا کنیم:

1. عنصر وسط لیست بررسی میشه.
2. اگر مقدار موردنظر بزرگ‌تر باشه، نیمه چپ کنار گذاشته میشه.
3. اگر کوچک‌تر باشه، نیمه راست کنار گذاشته میشه.
4. این روند تا پیدا شدن عدد ادامه پیدا می‌کنه.

نمونه کد پایتون:

numbers = [2, 5, 8, 12, 17, 21, 30]
target = 17
left = 0
right = len(numbers) - 1
found_index = -1

while left <= right:
    middle = (left + right) // 2
    if numbers[middle] == target:
        found_index = middle
        break
    if numbers[middle] < target:
        left = middle + 1
    else:
        right = middle - 1

if found_index != -1:
    print("عدد در موقعیت", found_index, "پیدا شد.")
else:
    print("عدد پیدا نشد.")

جست‌وجوی دودویی در داده‌های بزرگ خیلی سریع‌تر از جست‌وجوی خطیه؛ اما فقط زمانی کار می‌کنه که اطلاعات از قبل مرتب شده باشن.

۳. مرتب‌سازی حبابی یا Bubble Sort

مرتب‌سازی حبابی یکی از ساده‌ترین الگوریتم‌های مرتب‌سازیه.

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

برای مثال:

۵، ۲، ۸، ۱

در مرحله اول، عدد ۵ و ۲ مقایسه میشن و جاشون عوض میشه:

۲، ۵، ۸، ۱

این مقایسه‌ها چند بار ادامه پیدا می‌کنن تا تمام عناصر مرتب بشن.

نمونه کد پایتون:

numbers = [5, 2, 8, 1]
for i in range(len(numbers)):
    swapped = False
    for j in range(len(numbers) - i - 1):
        if numbers[j] > numbers[j + 1]:
            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
            swapped = True
    if not swapped:
        break
print(numbers)

Bubble Sort برای آموزش الگوریتم خیلی مناسبه؛ اما برای مرتب‌کردن حجم زیادی از اطلاعات معمولاً انتخاب خوبی نیست.

۴. مرتب‌سازی انتخابی یا Selection Sort

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

برای مثال، در لیست زیر:

۶، ۳، ۹، ۲

ابتدا کوچک‌ترین عدد یعنی ۲ پیدا میشه و به ابتدای لیست منتقل میشه:

۲، ۳، ۹، ۶

بعد کوچک‌ترین عدد باقی‌مانده پیدا میشه و این روند ادامه پیدا می‌کنه.

نمونه کد پایتون:

numbers = [6, 3, 9, 2]
for i in range(len(numbers)):
    minimum_index = i
    for j in range(i + 1, len(numbers)):
        if numbers[j] < numbers[minimum_index]:
            minimum_index = j
    numbers[i], numbers[minimum_index] = (
        numbers[minimum_index],
        numbers[i]
    )
print(numbers)

این الگوریتم ساده است و تعداد جابه‌جایی‌های کمی انجام میده؛ اما سرعت اون برای داده‌های بزرگ چندان مناسب نیست.

۵. مرتب‌سازی درجی یا Insertion Sort

مرتب‌سازی درجی شبیه مرتب‌کردن کارت‌های بازی در دست انسانه.

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

برای مثال:

۵، ۳، ۸، ۲

عدد ۳ قبل از ۵ قرار می‌گیره:

۳، ۵، ۸، ۲

بعد عدد ۲ در جای درست خودش قرار می‌گیره:

۲، ۳، ۵، ۸

نمونه کد پایتون:

numbers = [5, 3, 8, 2]
for i in range(1, len(numbers)):
    current = numbers[i]
    j = i - 1
    while j >= 0 and numbers[j] > current:
        numbers[j + 1] = numbers[j]
        j -= 1
    numbers[j + 1] = current
print(numbers)

Insertion Sort برای لیست‌های کوچک یا داده‌هایی که تا حد زیادی مرتب هستند، عملکرد مناسبی داره.

۶. مرتب‌سازی ادغامی یا Merge Sort

Merge Sort یکی از معروف‌ترین الگوریتم‌های مرتب‌سازیه که از روش تقسیم و حل استفاده می‌کنه.

این الگوریتم:

1. لیست رو به دو بخش تقسیم می‌کنه.
2. هر بخش رو دوباره به قسمت‌های کوچک‌تر تقسیم می‌کنه.
3. بخش‌های کوچک رو مرتب می‌کنه.
4. اون‌ها رو با هم ترکیب می‌کنه.

برای مثال:

۸، ۳، ۶، ۲

ابتدا به دو بخش تقسیم میشه:

۸، ۳

و:

۶، ۲

بعد هر بخش مرتب میشه و در نهایت نتیجه زیر به دست میاد:

۲، ۳، ۶، ۸

Merge Sort برای داده‌های بزرگ سرعت مناسبی داره؛ اما برای ترکیب بخش‌ها به حافظه اضافی نیاز داره.

۷. مرتب‌سازی سریع یا Quick Sort

Quick Sort هم از روش تقسیم و حل استفاده می‌کنه.

در این الگوریتم، یک عنصر به‌عنوان محور یا Pivot انتخاب میشه. بعد عناصر کوچک‌تر از محور در یک سمت و عناصر بزرگ‌تر در سمت دیگه قرار می‌گیرن.

این روند روی هر بخش دوباره تکرار میشه تا لیست کاملاً مرتب بشه.

Quick Sort در بسیاری از شرایط عملکرد خیلی خوبی داره و یکی از الگوریتم‌های پرکاربرد مرتب‌سازیه. البته نحوه انتخاب محور می‌تونه روی سرعت اون تأثیر زیادی داشته باشه.

۸. الگوریتم بازگشتی فاکتوریل

فاکتوریل یکی از مثال‌های معروف برای درک بازگشته.

فاکتوریل عدد ۵ برابر است با:

۵ × ۴ × ۳ × ۲ × ۱ = ۱۲۰

در روش بازگشتی، فاکتوریل هر عدد با استفاده از فاکتوریل عدد قبلی محاسبه میشه:

فاکتوریل ۵ = ۵ × فاکتوریل ۴

نمونه کد پایتون:

def factorial(number):
    if number == 0 or number == 1:
        return 1
    return number * factorial(number - 1)

print(factorial(5))

شرط توقف در این الگوریتم خیلی مهمه. اگر شرط توقف وجود نداشته باشه، تابع به فراخوانی خودش ادامه میده و برنامه با خطا مواجه میشه.

۹. الگوریتم فیبوناچی

دنباله فیبوناچی به این شکل شروع میشه:

۰، ۱، ۱، ۲، ۳، ۵، ۸، ۱۳

هر عدد از جمع دو عدد قبلی به دست میاد.

روش ساده بازگشتی:

def fibonacci(number):
    if number <= 1:
        return number
    return fibonacci(number - 1) + fibonacci(number - 2)

این روش ساده است، اما بعضی محاسبات رو چند بار تکرار می‌کنه.

نسخه بهینه‌تر با ذخیره نتایج:

def fibonacci(number):
    if number <= 1:
        return number
    previous = 0
    current = 1
    for _ in range(2, number + 1):
        previous, current = current, previous + current
    return current

print(fibonacci(10))

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

۱۰. پیمایش عمقی یا DFS

الگوریتم Depth-First Search برای پیمایش گراف یا درخت استفاده میشه.

در این روش، الگوریتم یک مسیر رو تا جای ممکن ادامه میده و وقتی به انتهای مسیر رسید، برمی‌گرده و مسیر دیگه‌ای رو بررسی می‌کنه.

DFS در موارد زیر کاربرد داره:

• پیمایش پوشه‌ها و زیرپوشه‌ها
• پیدا کردن مسیر در هزارتو
• بررسی ارتباط گره‌ها
• تشخیص چرخه در گراف
• حل بعضی مسائل عقبگرد

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

۱۱. پیمایش سطحی یا BFS

الگوریتم Breadth-First Search گراف یا درخت رو سطح‌به‌سطح بررسی می‌کنه.

یعنی ابتدا گره‌های نزدیک‌تر بررسی میشن و بعد الگوریتم سراغ گره‌های دورتر میره.

BFS در موارد زیر کاربرد داره:

• پیدا کردن کوتاه‌ترین مسیر در گراف بدون وزن
• بررسی ارتباط کاربران در شبکه اجتماعی
• جست‌وجو در ساختارهای درختی
• پیدا کردن نزدیک‌ترین گزینه

این الگوریتم معمولاً با استفاده از ساختار Queue پیاده‌سازی میشه.

۱۲. الگوریتم دایکسترا

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

برای مثال، فرض کنید شهرها با جاده‌هایی به هم متصل هستند و هر جاده یک فاصله مشخص داره. دایکسترا می‌تونه کوتاه‌ترین مسیر بین مبدأ و مقصد رو پیدا کنه.

کاربردهای این الگوریتم:

• مسیریابی روی نقشه
• پیدا کردن مسیر مناسب در شبکه‌های کامپیوتری
• محاسبه کم‌هزینه‌ترین مسیر
• سیستم‌های حمل‌ونقل

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

جدول مقایسه الگوریتم‌های معروف

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

بعد از تسلط روی این موارد، میشه سراغ الگوریتم‌های پیشرفته‌تر مثل Merge Sort، Quick Sort، الگوریتم‌های گراف و برنامه‌نویسی پویا رفت.

پیچیدگی زمانی الگوریتم چیه و Big O چه مفهومی داره؟

ممکنه دو الگوریتم مختلف، یک مسئله رو به‌درستی حل کنند؛ اما سرعت اجرای اون‌ها یکسان نباشه.

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

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

برای بررسی این تفاوت از مفهومی به نام پیچیدگی زمانی یا Time Complexity استفاده می‌کنیم.

پیچیدگی زمانی دقیقاً چه چیزی رو بررسی می‌کنه؟

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

منظور از پیچیدگی زمانی، اندازه‌گیری زمان اجرا با ثانیه نیست؛ چون سرعت واقعی برنامه به عوامل مختلفی بستگی داره:

• قدرت پردازنده
• مقدار حافظه
• زبان برنامه‌نویسی
• نوع سیستم‌عامل
• نحوه پیاده‌سازی کد
• حجم و ساختار داده‌ها

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

برای نمایش این رشد معمولاً از نماد Big O استفاده میشه.

Big O چیه؟

نماد Big O یا Big O Notation روشی برای توصیف میزان رشد تعداد عملیات الگوریتمه.

در این نماد معمولاً از حرف n برای نمایش تعداد داده‌های ورودی استفاده می‌کنیم.

برای مثال، اگر یک فهرست شامل ۱۰۰ عدد داشته باشیم:

n = 100

و اگر فهرست شامل یک میلیون عدد باشه:

n = 1,000,000

Big O به ما کمک می‌کنه بررسی کنیم وقتی مقدار n بزرگ‌تر میشه، عملکرد الگوریتم چطور تغییر می‌کنه.

پیچیدگی O(1)؛ زمان ثابت

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

برای مثال، اگر بخوایم اولین عنصر یک لیست رو دریافت کنیم:

numbers = [10, 20, 30, 40, 50]
first_number = numbers[0]
print(first_number)

فرقی نمی‌کنه لیست ۵ عضو داشته باشه یا یک میلیون عضو؛ برای دسترسی به اولین عنصر، فقط یک عملیات اصلی انجام میشه.

به همین دلیل، این عملیات دارای پیچیدگی زمانی ثابت یا O(1) است.

نمونه‌های رایج:

• دریافت یک عنصر آرایه با شماره ایندکس
• مقداردهی یک متغیر
• مقایسه دو عدد
• انجام یک محاسبه ساده

O(1) معمولاً یکی از بهترین حالت‌های عملکردیه.

پیچیدگی O(n)؛ رشد خطی

در پیچیدگی O(n)، تعداد عملیات تقریباً به‌اندازه تعداد داده‌ها افزایش پیدا می‌کنه.

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

numbers = [4, 8, 12, 16, 20]
target = 20
for number in numbers:
    if number == target:
        print("عدد پیدا شد.")
        break

اگر لیست ۱۰ عضو داشته باشه، در بدترین حالت ممکنه ۱۰ مقایسه انجام بشه. اگر لیست یک میلیون عضو داشته باشه، ممکنه یک میلیون مقایسه انجام بشه.

بنابراین پیچیدگی جست‌وجوی خطی در بدترین حالت برابر با:

O(n)

است.

نمونه‌های رایج:

• پیمایش تمام اعضای یک لیست
• محاسبه مجموع عددها
• پیدا کردن بزرگ‌ترین مقدار
• جست‌وجوی خطی
• نمایش تمام رکوردها

پیچیدگی O(log n)؛ رشد لگاریتمی

در پیچیدگی O(log n)، الگوریتم در هر مرحله بخش بزرگی از داده‌ها رو حذف می‌کنه.

جست‌وجوی دودویی یکی از معروف‌ترین مثال‌های این حالته.

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

روند کاهش داده‌ها تقریباً به این شکله:

1,000,000

500,000

250,000

125,000

62,500

...

با حدود ۲۰ مقایسه میشه بین یک میلیون عنصر جست‌وجو کرد.

بنابراین پیچیدگی زمانی جست‌وجوی دودویی برابر با:

O(log n)

است.

این تفاوت وقتی حجم اطلاعات زیاد میشه، اهمیت خیلی زیادی پیدا می‌کنه.

پیچیدگی O(n log n)

بعضی الگوریتم‌ها داده‌ها رو چند بار تقسیم می‌کنن و در هر مرحله بخشی از داده‌ها رو هم بررسی می‌کنن.

الگوریتم‌هایی مثل موارد زیر معمولاً پیچیدگی O(n log n) دارن:

• Merge Sort
• Quick Sort در حالت میانگین
• بعضی الگوریتم‌های مرتب‌سازی پیشرفته

این پیچیدگی از O(n) بیشتره، اما برای داده‌های بزرگ معمولاً خیلی بهتر از O(n²) عمل می‌کنه.

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

پیچیدگی O(n²)؛ رشد درجه دوم

در پیچیدگی O(n²)، با افزایش داده‌ها، تعداد عملیات خیلی سریع‌تر زیاد میشه.

این حالت معمولاً زمانی ایجاد میشه که داخل یک حلقه، حلقه دیگه‌ای هم روی داده‌ها اجرا بشه.

برای مثال:

numbers = [1, 2, 3, 4, 5]
for first_number in numbers:
    for second_number in numbers:
        print(first_number, second_number)

اگر تعداد داده‌ها ۵ باشه، تقریباً ۲۵ عملیات انجام میشه:

5 × 5 = 25

اگر تعداد داده‌ها ۱۰۰۰ باشه:

1000 × 1000 = 1,000,000

الگوریتم‌هایی مثل Bubble Sort، Selection Sort و Insertion Sort در بدترین حالت معمولاً پیچیدگی زمانی O(n²) دارن.

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

مقایسه ساده پیچیدگی‌های زمانی

فرض کنید الگوریتم روی یک میلیون داده اجرا بشه:

این عددها تقریبی هستند و هدف اون‌ها نمایش تفاوت میزان رشد الگوریتم‌هاست.

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

مقایسه جست‌وجوی خطی و جست‌وجوی دودویی

فرض کنید میخوایم عددی رو بین یک میلیون عدد پیدا کنیم.

جست‌وجوی خطی

در بدترین حالت باید تمام عناصر بررسی بشن:

O(n)

یعنی ممکنه حدود یک میلیون مقایسه انجام بشه.

جست‌وجوی دودویی

در هر مرحله نصف داده‌ها حذف میشن:

O(log n)

یعنی ممکنه فقط حدود ۲۰ مقایسه انجام بشه.

البته جست‌وجوی دودویی یک شرط مهم داره:

داده‌ها باید از قبل مرتب شده باشن.

بنابراین انتخاب الگوریتم فقط به سرعت اون وابسته نیست و باید شرایط استفاده از اون رو هم در نظر بگیریم.

بهترین، متوسط و بدترین حالت اجرای الگوریتم

عملکرد یک الگوریتم ممکنه بسته به وضعیت ورودی متفاوت باشه.

برای مثال، در جست‌وجوی خطی:

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

به این حالت‌ها گفته میشه:

• بهترین حالت یا Best Case
• حالت متوسط یا Average Case
• بدترین حالت یا Worst Case

در بیشتر تحلیل‌های مقدماتی، پیچیدگی بدترین حالت بررسی میشه؛ چون میخوایم بدونیم الگوریتم در سخت‌ترین شرایط چه عملکردی داره.

پیچیدگی فضایی چیه؟

علاوه بر زمان اجرا، مقدار حافظه‌ای که الگوریتم مصرف می‌کنه هم اهمیت داره. به این موضوع پیچیدگی فضایی یا Space Complexity گفته میشه.

برای مثال، ممکنه یک الگوریتم خیلی سریع باشه، اما برای اجرای خودش مقدار زیادی حافظه اضافی نیاز داشته باشه.

الگوریتم Merge Sort سرعت مناسبی داره، اما برای ترکیب بخش‌های مختلف معمولاً به فضای حافظه اضافی نیاز پیدا می‌کنه.

در مقابل، بعضی الگوریتم‌ها ممکنه کمی کندتر باشند، اما حافظه کمتری مصرف کنند.

بنابراین برای انتخاب الگوریتم مناسب باید بین موارد زیر تعادل ایجاد کنیم:

• سرعت اجرا
• میزان مصرف حافظه
• سادگی پیاده‌سازی
• حجم داده‌ها
• نوع مسئله
• امکانات سخت‌افزاری

آیا همیشه باید سریع‌ترین الگوریتم رو انتخاب کنیم؟

نه لزوماً.

اگر فقط با ۱۰ یا ۲۰ داده سروکار داریم، ممکنه یک الگوریتم ساده مثل Bubble Sort کاملاً کافی باشه. در چنین شرایطی، استفاده از یک الگوریتم پیچیده‌تر ممکنه فقط کد رو سخت‌تر و نگهداری اون رو دشوارتر کنه.

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

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

خلاصه پیچیدگی‌های مهم

هدف از یادگیری Big O حفظ‌کردن چند فرمول نیست. مهم اینه که برنامه‌نویس بتونه تشخیص بده با بزرگ‌ترشدن حجم اطلاعات، الگوریتم موردنظر چه رفتاری خواهد داشت.

در نتیجه، الگوریتم خوب فقط الگوریتمی نیست که جواب درست تولید کنه؛ بلکه باید با توجه به حجم داده‌ها، سرعت مناسب و مصرف منطقی منابع رو هم داشته باشه.

آیا با وجود هوش مصنوعی هنوز باید الگوریتم یاد بگیریم؟

با گسترش ابزارهایی مثل ChatGPT، GitHub Copilot، Claude و Cursor، خیلی‌ها این سؤال رو مطرح می‌کنن که آیا هنوز یادگیری الگوریتم و حل مسئله برای برنامه‌نویس‌ها ضروریه یا نه.

پاسخ کوتاه اینه:

بله؛ حتی با وجود هوش مصنوعی، یادگیری الگوریتم هنوز یکی از پایه‌های اصلی برنامه‌نویسیه.

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

هوش مصنوعی می‌تونه کد بنویسه، اما باید مسئله رو درست تعریف کنیم

برای اینکه یک ابزار هوش مصنوعی کد مناسبی تولید کنه، اول باید دقیقاً بدونیم چه چیزی ازش میخوایم.

برای مثال، درخواست زیر خیلی کلیه:

یک سیستم جست‌وجو برام بنویس.

اما هنوز چند سؤال مهم بدون پاسخ باقی مونده:

• جست‌وجو روی چه نوع داده‌ای انجام میشه؟
• حجم داده‌ها چقدره؟
• داده‌ها مرتب هستند یا نه؟
• جست‌وجو باید دقیق باشه یا تقریبی؟
• سرعت مهم‌تره یا مصرف حافظه؟
• اگر داده پیدا نشد چه اتفاقی بیفته؟
• آیا جست‌وجو باید به حروف بزرگ و کوچک حساس باشه؟

پاسخ این سؤال‌ها به تحلیل مسئله و شناخت الگوریتم نیاز داره.

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

هر کد تولیدشده‌ای الزاماً کد خوبی نیست

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

کد تولیدشده ممکنه:

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

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

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

یک مثال ساده

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

ممکنه ابزار، جست‌وجوی خطی تولید کنه:

for item in items:
    if item == target:
        print("پیدا شد")
        break

این روش برای فهرست‌های کوچک کاملاً قابل قبوله.

اما اگر چند میلیون داده مرتب‌شده داشته باشیم، شاید جست‌وجوی دودویی گزینه خیلی مناسب‌تری باشه.

هر دو کد می‌تونن جواب درست بدن؛ ولی انتخاب روش مناسب به این بستگی داره که برنامه‌نویس شرایط مسئله رو بفهمه.

هوش مصنوعی می‌تونه گزینه‌ها رو پیشنهاد بده، اما تصمیم نهایی باید بر اساس نیاز واقعی پروژه گرفته بشه.

الگوریتم به ما کمک می‌کنه خروجی هوش مصنوعی رو ارزیابی کنیم

وقتی الگوریتم رو بلد باشیم، می‌تونیم کد تولیدشده توسط هوش مصنوعی رو از چند زاویه بررسی کنیم:

• آیا منطق حل مسئله درسته؟
• آیا تمام حالت‌های ممکن پوشش داده شده‌اند؟
• آیا الگوریتم بعد از تعداد مشخصی مرحله متوقف میشه؟
• آیا روی ورودی‌های نامعتبر هم رفتار مناسبی داره؟
• آیا پیچیدگی زمانی قابل قبوله؟
• آیا حافظه بی‌دلیل مصرف میشه؟
• آیا راه‌حل ساده‌تر یا سریع‌تری وجود داره؟

در واقع، هوش مصنوعی سرعت نوشتن کد رو بالا می‌بره؛ اما مسئولیت بررسی درستی کد همچنان با برنامه‌نویسه.

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

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

فرد اول فقط میگه:

این مسئله رو حل کن.

اما فرد دوم مسئله رو دقیق‌تر تعریف می‌کنه:

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

درخواست دوم دقیق‌تره؛ چون فرد:

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

بنابراین هرچه درک برنامه‌نویس از الگوریتم و حل مسئله بیشتر باشه، استفاده اون از ابزارهای هوش مصنوعی هم حرفه‌ای‌تر میشه.

هوش مصنوعی جای تفکر الگوریتمی رو نمی‌گیره

تفکر الگوریتمی یعنی بتونیم:

1. مسئله رو درست تعریف کنیم.
2. اون رو به بخش‌های کوچک‌تر تقسیم کنیم.
3. ورودی‌ها و خروجی‌ها رو مشخص کنیم.
4. شرط‌ها و حالت‌های مختلف رو پیدا کنیم.
5. مسیر حل مسئله رو مرحله‌به‌مرحله طراحی کنیم.
6. چند راه‌حل مختلف رو با هم مقایسه کنیم.
7. مناسب‌ترین راه‌حل رو انتخاب کنیم.

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

ابزارهای AI می‌تونن در هرکدوم از این مراحل کمک کنند، اما نمی‌تونن بدون شناخت درست مسئله، تصمیم فنی مطمئنی بگیرند.

نقش برنامه‌نویس در عصر هوش مصنوعی تغییر می‌کنه

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

امروز ابزارهای هوش مصنوعی می‌تونن بسیاری از این کارها رو سریع‌تر انجام بدن؛ مثل:

• تولید کد اولیه
• ساخت توابع ساده
• نوشتن تست
• توضیح کد
• تبدیل کد از یک زبان به زبان دیگه
• پیشنهاد روش‌های بازنویسی
• پیدا کردن بعضی خطاها
• تولید مستندات

به همین دلیل، ارزش برنامه‌نویس بیشتر به سمت مهارت‌های سطح بالاتر حرکت می‌کنه:

• تحلیل مسئله
• طراحی الگوریتم
• معماری نرم‌افزار
• انتخاب تکنولوژی
• بررسی کیفیت کد
• تست و اعتبارسنجی
• امنیت
• بهینه‌سازی
• درک نیاز کسب‌وکار

یعنی هوش مصنوعی اهمیت برنامه‌نویس رو از بین نمی‌بره؛ بلکه اهمیت مهارت‌های عمیق‌تر اون رو بیشتر می‌کنه.

آیا باید الگوریتم‌ها رو حفظ کنیم؟

نه. هدف اصلی یادگیری الگوریتم، حفظ‌کردن ده‌ها قطعه کد نیست.

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

مهم‌تر اینه که:

• انواع راه‌حل‌ها رو بشناسیم.
• بدونیم هر الگوریتم چه کاربردی داره.
• محدودیت‌های اون رو درک کنیم.
• بتونیم کد تولیدشده رو بررسی کنیم.
• در شرایط مختلف، انتخاب منطقی داشته باشیم.

برای مثال، لازم نیست کد Merge Sort رو از حفظ بنویسیم؛ اما بهتره بدونیم این الگوریتم از روش تقسیم و حل استفاده می‌کنه، پیچیدگی زمانی مناسبی داره و معمولاً به حافظه اضافی نیاز پیدا می‌کنه.

بهترین روش استفاده از هوش مصنوعی در یادگیری الگوریتم

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

برای یادگیری بهتر می‌تونیم از AI بخوایم:

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

برای مثال، به‌جای این درخواست:

جواب این تمرین رو بنویس.

درخواست بهتر می‌تونه این باشه:

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

در این حالت، هوش مصنوعی باعث تقویت مهارت حل مسئله میشه، نه اینکه جای اون رو بگیره.

خطر وابستگی کامل به کد تولیدشده

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

برای مثال، وقتی:

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

در چنین شرایطی، فقط کسی می‌تونه مشکل رو حل کنه که منطق برنامه رو بفهمه.

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

جمع‌بندی این بخش

هوش مصنوعی می‌تونه:

• سرعت کدنویسی رو بیشتر کنه.
• الگوریتم‌های مختلف پیشنهاد بده.
• کد اولیه تولید کنه.
• در یادگیری و رفع خطا کمک کنه.
• محاسبات تکراری رو کاهش بده.

اما برنامه‌نویس همچنان باید:

• مسئله رو تحلیل کنه.
• ورودی و خروجی رو مشخص کنه.
• الگوریتم مناسب رو انتخاب کنه.
• خروجی تولیدشده رو ارزیابی کنه.
• خطاها و حالت‌های خاص رو بررسی کنه.
• مسئولیت نتیجه نهایی رو بپذیره.

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

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

برای یادگیری الگوریتم از کجا شروع کنیم؟

یادگیری الگوریتم برای خیلی از افراد در ابتدا سخت و پیچیده به نظر میرسه؛ مخصوصاً وقتی مستقیماً با اصطلاحاتی مثل بازگشت، گراف، برنامه‌نویسی پویا و پیچیدگی زمانی روبه‌رو میشن.

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

مسیر پیشنهادی یادگیری الگوریتم به این شکله:

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

در ادامه هر مرحله رو بررسی می‌کنیم.

مرحله اول: منطق حل مسئله رو تقویت کنیم

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

برای هر مسئله بهتره ابتدا این سؤال‌ها رو از خودمون بپرسیم:

• مسئله دقیقاً از ما چی میخواد؟
• چه اطلاعاتی به‌عنوان ورودی دریافت می‌کنیم؟
• خروجی مورد انتظار چیه؟
• چه محاسباتی باید انجام بشه؟
• چه شرط‌هایی وجود داره؟
• آیا بخشی از مراحل تکرار میشه؟
• چه حالت‌های خاصی ممکنه اتفاق بیفته؟

برای مثال، در مسئله تشخیص زوج یا فرد بودن عدد باید بدونیم:

• ورودی یک عدده.
• باید باقی‌مانده تقسیم عدد بر ۲ بررسی بشه.
• خروجی یکی از دو حالت «زوج» یا «فرد» خواهد بود.

این نوع تحلیل، پایه تفکر الگوریتمیه.

مرحله دوم: ساختارهای ترتیبی، شرطی و تکراری رو یاد بگیریم

بیشتر الگوریتم‌های ساده از سه ساختار اصلی ساخته میشن:

ساختار ترتیبی

دستورها یکی‌یکی و به ترتیب اجرا میشن.

مثال:

1. طول رو دریافت کن.
2. عرض رو دریافت کن.
3. طول رو در عرض ضرب کن.
4. مساحت رو نمایش بده.

ساختار شرطی

برنامه بر اساس یک شرط، مسیر متفاوتی رو انتخاب می‌کنه.

مثال:

• اگر نمره ۱۰ یا بیشتر بود، دانشجو قبوله.
• در غیر این صورت، دانشجو مردوده.

ساختار تکراری

یک یا چند مرحله چند بار اجرا میشن.

مثال:

• نمایش اعداد ۱ تا ۱۰۰
• محاسبه مجموع نمرات
• بررسی تمام محصولات یک فروشگاه
• پیدا کردن یک نام در لیست

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

مرحله سوم: کار با متغیر، آرایه و تابع رو یاد بگیریم

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

مهم‌ترین مفاهیم این مرحله عبارت‌اند از:

• متغیر
• انواع داده
• عملگرهای محاسباتی و مقایسه‌ای
• شرط‌ها
• حلقه‌ها
• آرایه و لیست
• تابع
• ورودی و خروجی

برای مثال، برای پیدا کردن بزرگ‌ترین عدد در یک مجموعه باید بتونیم:

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

پس یادگیری الگوریتم از یادگیری مفاهیم پایه برنامه‌نویسی جدا نیست و این دو باید در کنار هم پیش برن.

مرحله چهارم: الگوریتم‌ها رو اول بدون کد بنویسیم

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

در حالی که بهتره ابتدا مسیر حل مسئله رو با زبان ساده بنویسیم.

برای مثال، قبل از نوشتن کد محاسبه میانگین:

1. تعداد نمرات رو دریافت کن.
2. مجموع نمرات رو برابر صفر قرار بده.
3. نمرات رو یکی‌یکی دریافت کن.
4. هر نمره رو به مجموع اضافه کن.
5. مجموع رو بر تعداد نمرات تقسیم کن.
6. میانگین رو نمایش بده.

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

مرحله پنجم: شبه‌کد و فلوچارت تمرین کنیم

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

برای شروع، بهتره برای مسائل ساده‌ای مثل موارد زیر شبه‌کد یا فلوچارت بنویسیم:

• تشخیص مثبت یا منفی بودن عدد
• تشخیص زوج یا فرد بودن عدد
• پیدا کردن بزرگ‌ترین عدد
• محاسبه میانگین
• محاسبه فاکتوریل
• شمارش تعداد اعداد زوج
• پیدا کردن یک مقدار داخل آرایه
• محاسبه مبلغ نهایی خرید

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

مرحله ششم: مسائل ساده رو زیاد حل کنیم

مهارت الگوریتم‌نویسی فقط با مطالعه به دست نمیاد. باید مسئله حل کنیم.

برای شروع، مسئله‌هایی مناسب هستند که با شرط، حلقه و آرایه حل میشن.

چند تمرین مناسب برای افراد مبتدی:

1. یک عدد رو دریافت کن و مشخص کن مثبت، منفی یا صفره.
2. دو عدد رو دریافت کن و عدد بزرگ‌تر رو نمایش بده.
3. سه عدد رو از کوچک به بزرگ مرتب کن.
4. مجموع اعداد ۱ تا عدد واردشده رو حساب کن.
5. جدول ضرب یک عدد رو نمایش بده.
6. تعداد رقم‌های یک عدد رو محاسبه کن.
7. عدد رو برعکس کن.
8. مشخص کن یک عدد اول هست یا نه.
9. بزرگ‌ترین عدد داخل یک آرایه رو پیدا کن.
10. تعداد تکرار یک مقدار داخل آرایه رو محاسبه کن.
11. یک کلمه رو دریافت کن و بررسی کن قرینه هست یا نه.
12. میانگین نمرات دانشجوها رو محاسبه کن.

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

بعد از اون می‌تونیم بررسی کنیم آیا روش ساده‌تر یا بهینه‌تری وجود داره یا نه.

مرحله هفتم: الگوریتم‌های جست‌وجو و مرتب‌سازی رو یاد بگیریم

بعد از تسلط روی مسائل مقدماتی، بهتره سراغ الگوریتم‌های پایه جست‌وجو و مرتب‌سازی بریم.

ترتیب پیشنهادی یادگیری:

1. Linear Search
2. Binary Search
3. Bubble Sort
4. Selection Sort
5. Insertion Sort
6. Merge Sort
7. Quick Sort

در این مرحله بهتره فقط کد الگوریتم رو حفظ نکنیم. برای هر الگوریتم باید بدونیم:

• چه مسئله‌ای رو حل می‌کنه؟
• مراحل اجرای اون چیه؟
• چه پیش‌شرطی داره؟
• روی چه نوع داده‌ای مناسبه؟
• چه نقاط ضعف و قوتی داره؟
• پیچیدگی زمانی اون چقدره؟

برای مثال، در Binary Search فقط نوشتن کد کافی نیست. باید بدونیم این الگوریتم روی داده‌های مرتب اجرا میشه و در هر مرحله نیمی از محدوده جست‌وجو رو حذف می‌کنه.

مرحله هشتم: اجرای الگوریتم رو روی کاغذ شبیه‌سازی کنیم

یکی از بهترین تمرین‌ها اینه که اجرای الگوریتم رو با چند داده ساده، مرحله‌به‌مرحله روی کاغذ بررسی کنیم.

برای مثال، برای Bubble Sort این آرایه رو در نظر بگیریم:

۵، ۲، ۸، ۱

بعد در هر مرحله بنویسیم:

• کدوم دو عدد مقایسه میشن؟
• آیا جابه‌جایی انجام میشه؟
• وضعیت آرایه بعد از جابه‌جایی چیه؟
• چند بار حلقه اجرا شده؟

این کار کمک می‌کنه منطق داخلی الگوریتم رو واقعاً درک کنیم و فقط کد اون رو حفظ نکنیم.

استفاده از شبیه‌سازهای تصویری الگوریتم هم برای همین هدف مفیده؛ چون مقایسه، انتخاب و جابه‌جایی داده‌ها رو به‌صورت مرحله‌به‌مرحله نمایش میده.

مرحله نهم: پیچیدگی زمانی رو به‌صورت ساده یاد بگیریم

بعد از آشنایی با چند الگوریتم، باید یاد بگیریم اون‌ها رو از نظر عملکرد با هم مقایسه کنیم.

در شروع، آشنایی با این پیچیدگی‌ها کافیه:

• O(1)
• O(log n)
• O(n)
• O(n log n)
• O(n²)

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

برای مثال:

• دسترسی مستقیم به یک عنصر آرایه معمولاً O(1) است.
• جست‌وجوی دودویی O(log n) است.
• جست‌وجوی خطی O(n) است.
• Bubble Sort در بدترین حالت O(n²) است.
• Merge Sort معمولاً O(n log n) است.

درک همین موارد ساده، دید خیلی خوبی برای انتخاب الگوریتم مناسب ایجاد می‌کنه.

مرحله دهم: سراغ الگوریتم‌های پیشرفته‌تر بریم

بعد از تسلط روی مباحث پایه، میشه یادگیری موضوعات پیشرفته‌تر رو شروع کرد:

• بازگشت
• Divide and Conquer
• Greedy Algorithms
• Backtracking
• Dynamic Programming
• الگوریتم‌های گراف
• BFS و DFS
• کوتاه‌ترین مسیر
• الگوریتم‌های رشته
• ساختمان داده‌ها

در این مرحله، یادگیری ساختمان داده‌ها هم اهمیت زیادی پیدا می‌کنه.

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

موضوعاتی مثل موارد زیر معمولاً در کنار الگوریتم‌ها یاد گرفته میشن:

• Array
• Linked List
• Stack
• Queue
• Hash Table
• Tree
• Graph
• Heap

انتخاب ساختمان داده مناسب می‌تونه تأثیر خیلی زیادی روی سرعت و سادگی الگوریتم داشته باشه.

با چه زبان برنامه‌نویسی الگوریتم یاد بگیریم؟

الگوریتم به زبان برنامه‌نویسی خاصی وابسته نیست. میشه الگوریتم‌ها رو با زبان‌های مختلفی مثل پایتون، سی‌شارپ، جاوا، ++C یا جاوا اسکریپت یاد گرفت.

برای افراد مبتدی، پایتون معمولاً گزینه ساده‌ایه؛ چون قواعد نگارشی کمتری داره و اجازه میده تمرکز بیشتری روی منطق مسئله داشته باشیم.

اما اگر هدف فرد ورود به برنامه‌نویسی سازمانی، توسعه وب با دات‌نت یا یادگیری اصولی سی‌شارپ باشه، یادگیری الگوریتم با C# هم انتخاب مناسبیه.

مهم‌تر از انتخاب زبان اینه که:

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

چطور از هوش مصنوعی برای یادگیری الگوریتم استفاده کنیم؟

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

برای مثال، می‌تونیم از AI بخوایم:

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

برای نمونه، پرامپت زیر از درخواست مستقیم جواب بهتره:

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

با این روش، هوش مصنوعی سرعت یادگیری رو بیشتر می‌کنه، بدون اینکه مهارت حل مسئله رو از ما بگیره.

اشتباه‌های رایج در یادگیری الگوریتم

افراد مبتدی معمولاً با چند اشتباه روبه‌رو میشن:

حفظ‌کردن کد الگوریتم‌ها

حفظ‌کردن کد Bubble Sort یا Binary Search بدون فهم منطق اون‌ها، ارزش زیادی نداره.

باید بدونیم چرا هر مرحله انجام میشه و تغییر هر بخش چه اثری روی نتیجه داره.

رفتن سریع سراغ مسائل خیلی سخت

شروع یادگیری با گراف، برنامه‌نویسی پویا یا مسائل سنگین مسابقه‌ای معمولاً باعث سردرگمی میشه.

بهتره ابتدا روی شرط، حلقه، آرایه و مسائل ساده مسلط بشیم.

دیدن جواب قبل از تلاش‌کردن

اگر بلافاصله جواب تمرین رو ببینیم، ذهن فرصت تحلیل مسئله رو پیدا نمی‌کنه.

بهتره حداقل چند دقیقه مسئله رو بررسی کنیم، ورودی و خروجی رو بنویسیم و یک راه‌حل اولیه طراحی کنیم.

تمرکز بیش از حد روی کوتاه‌کردن کد

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

نادیده‌گرفتن ورودی‌های خاص

باید الگوریتم رو فقط با ورودی‌های عادی آزمایش نکنیم.

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

یک برنامه تمرینی ساده برای شروع

برای شروع میشه این مسیر رو دنبال کرد:

هفته اول

• ورودی و خروجی
• متغیر و عملگر
• الگوریتم‌های ترتیبی
• حل ۱۰ مسئله محاسباتی ساده

هفته دوم

• شرط‌ها
• شرط‌های ترکیبی
• حل مسائل قبولی، تخفیف، زوج و فرد و مقایسه اعداد

هفته سوم

• حلقه‌ها
• مجموع و شمارش
• جدول ضرب
• فاکتوریل
• تشخیص عدد اول

هفته چهارم

• آرایه و لیست
• پیدا کردن بزرگ‌ترین و کوچک‌ترین عدد
• محاسبه میانگین
• جست‌وجوی خطی

هفته پنجم

• الگوریتم‌های مرتب‌سازی ساده
• Bubble Sort
• Selection Sort
• شبیه‌سازی مرحله‌به‌مرحله اجرا

هفته ششم

• Binary Search
• مفهوم Big O
• مقایسه الگوریتم‌ها
• حل تمرین‌های ترکیبی

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

آیا یادگیری الگوریتم برای همه برنامه‌نویس‌ها ضروریه؟

میزان عمقی که هر فرد به الگوریتم نیاز داره به مسیر شغلی اون بستگی داره.

برای مثال:

• یک برنامه‌نویس Front-End به منطق، آرایه، جست‌وجو، مرتب‌سازی و پیچیدگی پایه نیاز داره.
• یک برنامه‌نویس Back-End باید روی ساختمان داده، بهینه‌سازی، جست‌وجو و مدیریت حجم بالای داده تسلط بیشتری داشته باشه.
• یک متخصص تحلیل داده و هوش مصنوعی باید الگوریتم‌های آماری، بهینه‌سازی و یادگیری ماشین رو هم بشناسه.
• یک برنامه‌نویس سیستم یا نرم‌افزارهای سنگین به درک عمیق‌تری از حافظه، ساختمان داده و پیچیدگی الگوریتم نیاز داره.

اما در هر مسیر برنامه‌نویسی، توانایی تحلیل مسئله و تبدیل اون به مراحل واضح ضروریه.

جمع‌بندی مسیر یادگیری الگوریتم

برای یادگیری الگوریتم بهتره از حفظ‌کردن کدهای آماده فاصله بگیریم و این مسیر رو دنبال کنیم:

1. مسئله رو دقیق بخونیم.
2. ورودی و خروجی رو مشخص کنیم.
3. راه‌حل رو با زبان ساده بنویسیم.
4. شرط‌ها و تکرارها رو پیدا کنیم.
5. شبه‌کد یا فلوچارت طراحی کنیم.
6. الگوریتم رو با چند ورودی آزمایش کنیم.
7. اون رو به کد تبدیل کنیم.
8. خطاها و حالت‌های خاص رو بررسی کنیم.
9. راه‌حل‌های مختلف رو مقایسه کنیم.
10. پیچیدگی زمانی و مصرف حافظه رو در نظر بگیریم.

یادگیری الگوریتم یک مسیر یک‌روزه یا حفظ‌کردنی نیست. این مهارت با حل‌کردن مسئله، اشتباه‌کردن، اصلاح راه‌حل و بررسی روش‌های مختلف تقویت میشه.

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

جمع‌بندی: الگوریتم، نقشه حل مسئله در برنامه‌نویسیه

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

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

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

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

به همین دلیل، یک برنامه‌نویس فقط نباید بتونه کد بنویسه؛ بلکه باید بتونه:

• مسئله رو درست تحلیل کنه.
• ورودی و خروجی رو مشخص کنه.
• مسئله رو به مراحل کوچک‌تر تقسیم کنه.
• شرط‌ها و تکرارها رو تشخیص بده.
• چند راه‌حل مختلف رو مقایسه کنه.
• الگوریتم مناسب‌تری رو انتخاب کنه.
• کد نهایی رو با ورودی‌های مختلف آزمایش کنه.
• سرعت و میزان مصرف منابع رو در نظر بگیره.

با گسترش ابزارهایی مثل ChatGPT، Claude، Cursor و GitHub Copilot هم یادگیری الگوریتم بی‌اهمیت نشده. این ابزارها می‌تونن سرعت تولید کد رو بالا ببرن، اما برنامه‌نویس همچنان باید مسئله رو تعریف کنه، راه‌حل مناسب رو انتخاب کنه و درستی خروجی تولیدشده رو بررسی کنه.

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

در نهایت، الگوریتم‌نویسی یک موضوع حفظ‌کردنی نیست. این مهارت با حل مسئله، تمرین، بررسی اشتباه‌ها و مقایسه راه‌حل‌های مختلف تقویت میشه.

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

یادگیری برنامه‌نویسی و الگوریتم رو از پایه شروع کنید

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

در دوره آموزش برنامه‌نویسی از صفر: مبانی، الگوریتم و فلوچارت، این مفاهیم به‌صورت مرحله‌به‌مرحله و پروژه‌محور آموزش داده میشن تا فقط دستورات یک زبان رو حفظ نکنید و بتونید مسئله رو تحلیل و راه‌حل اون رو طراحی کنید.

سؤالات متداول درباره الگوریتم در برنامه‌نویسی