کتابخانه‌ی استاندارد · عدد و مجموعه

مرتب سازی sort

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

واردسازی مرتب سازی

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

بسته‌ی مرتب سازی یک وکتور را مرتب می‌کند و در وکتوری که از قبل مرتب است جستجو می‌کند. برای بیشتر کارها همین دو تابع کافی‌اند: مرتب برای عددها و رشته‌ها، و مرتب سازی با وقتی خودتان تعیین می‌کنید چه چیزی «کوچک‌تر» است؛ مثلاً دانشجوها بر اساس نمره. همه‌ی تابع‌ها عمومی‌اند: برای هر گونه‌ای که کوچکتر دارد کار می‌کنند، و با تابع مقایسه‌ی خودتان برای هر گونه‌ی دیگری. برای ظرف‌هایی که هنگام افزودن مرتب می‌مانند (نگاشت مرتب، صف اولویت‌دار) بسته‌ی مجموعه ها و برای میانه و صدک عددها بسته‌ی آمار را ببینید.

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

اشتباه‌های رایج:

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

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

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

sort-guide-records.salam
واردسازی مرتب سازی

ساختار کارمند:
    همگانی نام: رشته = ""
    همگانی تیم: رشته = ""
    همگانی حقوق: صحیح = ۰
پایان

تابع نمایش(کارکنان: وکتور<کارمند>):
    هر ک در کارکنان:
        سرچاپ "  " + ک.تیم، ک.نام، ک.حقوق
    پایان
پایان

تابع ریشه:
    ناپایا کارکنان := وکتور {} برگردان وکتور<کارمند>
    دیرکن کارکنان.آزادکن()
    کارکنان.بیفزا(کارمند { نام = "سارا"، تیم = "وب"، حقوق = ۵۲۰۰ })
    کارکنان.بیفزا(کارمند { نام = "امید"، تیم = "داده"، حقوق = ۶۱۰۰ })
    کارکنان.بیفزا(کارمند { نام = "لیلا"، تیم = "وب"، حقوق = ۶۱۰۰ })
    کارکنان.بیفزا(کارمند { نام = "بابک"، تیم = "داده"، حقوق = ۴۸۰۰ })
    کارکنان.بیفزا(کارمند { نام = "نیما"، تیم = "وب"، حقوق = ۵۲۰۰ })

    ترتیب تیمی := (الف: کارمند، ب: کارمند):
        اگر الف.تیم != ب.تیم: برگشت الف.تیم کوچکتر ب.تیم پایان
        اگر الف.حقوق != ب.حقوق: برگشت الف.حقوق بزرگتر ب.حقوق پایان
        برگشت الف.نام کوچکتر ب.نام
    پایان
    مرتب سازی.مرتب سازی با(کارکنان، ترتیب تیمی)
    سرچاپ "تیم، بعد بیشترین حقوق، بعد نام:"
    نمایش(کارکنان)

    ارزان‌ترین := مرتب سازی.مرتب شده با(کارکنان، (الف: کارمند، ب: کارمند): برگشت الف.حقوق کوچکتر ب.حقوق پایان)
    سرچاپ "کمترین حقوق:"، ارزان‌ترین.بگیر(۰).نام
    سرچاپ "هنوز به ترتیب تیم است:"، مرتب سازی.مرتب است با(کارکنان، ترتیب تیمی)
پایان
خروجیتیم، بعد بیشترین حقوق، بعد نام: داده امید 6100 داده بابک 4800 وب لیلا 6100 وب سارا 5200 وب نیما 5200 کمترین حقوق: بابک هنوز به ترتیب تیم است: true

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

مرتب کردن ستون به ستون

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

sort-guide-stable.salam
واردسازی مرتب سازی

ساختار سفارش:
    همگانی شماره: صحیح = ۰
    همگانی وضعیت: رشته = ""
    همگانی تاریخ: رشته = ""
پایان

تابع ریشه:
    ناپایا سفارش‌ها := وکتور {} برگردان وکتور<سفارش>
    دیرکن سفارش‌ها.آزادکن()
    سفارش‌ها.بیفزا(سفارش { شماره = ۱۰۴۱، وضعیت = "ارسال‌شده"، تاریخ = "1405-07-11" })
    سفارش‌ها.بیفزا(سفارش { شماره = ۱۰۴۲، وضعیت = "در انتظار"، تاریخ = "1405-07-09" })
    سفارش‌ها.بیفزا(سفارش { شماره = ۱۰۴۳، وضعیت = "ارسال‌شده"، تاریخ = "1405-07-06" })
    سفارش‌ها.بیفزا(سفارش { شماره = ۱۰۴۴، وضعیت = "در انتظار"، تاریخ = "1405-07-13" })
    سفارش‌ها.بیفزا(سفارش { شماره = ۱۰۴۵، وضعیت = "لغوشده"، تاریخ = "1405-07-10" })
    سفارش‌ها.بیفزا(سفارش { شماره = ۱۰۴۶، وضعیت = "در انتظار"، تاریخ = "1405-07-08" })

    مرتب سازی.مرتب سازی ترتیب‌نگه‌دار با(سفارش‌ها، (الف: سفارش، ب: سفارش): برگشت الف.تاریخ کوچکتر ب.تاریخ پایان)
    مرتب سازی.مرتب سازی ترتیب‌نگه‌دار با(سفارش‌ها، (الف: سفارش، ب: سفارش): برگشت الف.وضعیت کوچکتر ب.وضعیت پایان)
    هر س در سفارش‌ها:
        سرچاپ س.وضعیت، س.تاریخ، س.شماره
    پایان
پایان
خروجیارسال‌شده 1405-07-06 1043 ارسال‌شده 1405-07-11 1041 در انتظار 1405-07-08 1046 در انتظار 1405-07-09 1042 در انتظار 1405-07-13 1044 لغوشده 1405-07-10 1045

تاریخ‌هایی که به شکل YYYY-MM-DD نوشته شده‌اند به‌عنوان متن ساده هم درست مرتب می‌شوند، و برای همین مثال آن‌ها را با کوچکتر مقایسه می‌کند. همین ترفند برای D/M/YYYY کار نمی‌کند.

رتبه‌بندی یک فهرست بر اساس فهرستی دیگر

وقتی داده در وکتورهای موازی است، مثل نام‌ها، امتیازها و بردها، مرتب کردن یکی پیوندش را با بقیه می‌شکند. مرتب‌سازی نمایه و مرتب‌سازی نمایه نزولی به جای داده، وکتوری از جایگاه‌ها را مرتب می‌کنند و داده را سر جایش می‌گذارند؛ بعد همه‌ی وکتورها را از راه همین جایگاه‌ها می‌خوانید. کلیدها باید وکتور<اعشار۶۴> باشند و هر دو وکتور با ارجاع فرستاده می‌شوند، پس آن‌ها را با ناپایا تعریف کنید. جایگاه‌ها را پیش از کار با ۰ تا n-۱ پر کنید.

sort-guide-leaderboard.salam
واردسازی مرتب سازی

تابع ریشه:
    بازیکنان := ["علی"، "سارا"، "رضا"، "مینا"، "کاوه"]
    ناپایا امتیازها := وکتور {} برگردان وکتور<اعشار۶۴>
    ناپایا بردها := وکتور {} برگردان وکتور<صحیح>
    ناپایا ترتیب := وکتور {} برگردان وکتور<صحیح>
    دیرکن امتیازها.آزادکن()
    دیرکن بردها.آزادکن()
    دیرکن ترتیب.آزادکن()
    هر ا در [۷۲.۵، ۹۱.۰، ۶۴.۰، ۸۸.۵، ۹۱.۵]:
        امتیازها.بیفزا(ا)
    پایان
    هر ب در [۳، ۷، ۲، ۶، ۸]:
        بردها.بیفزا(ب)
    پایان
    تکرار بازیکنان.طول() در ی:
        ترتیب.بیفزا(ی)
    پایان

    مرتب سازی.مرتب‌سازی نمایه نزولی(ترتیب، امتیازها)
    سرچاپ "رتبه بازیکن امتیاز برد"
    هر رتبه، ی در ترتیب:
        سرچاپ رتبه + ۱، بازیکنان[ی]، امتیازها.بگیر(ی)، بردها.بگیر(ی)
    پایان

    مرتب := مرتب سازی.مرتب شده(امتیازها)
    سرچاپ "میانه‌ی امتیاز:"، مرتب.بگیر(مرتب.طول() / ۲)
    سرچاپ "بهترین:"، مرتب سازی.بیشینه(امتیازها)، "بدترین:"، مرتب سازی.کمینه(امتیازها)
پایان
خروجیرتبه بازیکن امتیاز برد 1 کاوه 91.5 8 2 سارا 91 7 3 مینا 88.5 6 4 علی 72.5 3 5 رضا 64 2 میانه‌ی امتیاز: 88.5 بهترین: 91.5 بدترین: 64

جستجو در وکتور مرتب

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

sort-guide-ranges.salam
واردسازی مرتب سازی

تابع ریشه:
    ناپایا قیمت‌ها := وکتور {} برگردان وکتور<صحیح>
    دیرکن قیمت‌ها.آزادکن()
    هر ق در [۱۲۰، ۴۵، ۳۰۰، ۹۹، ۴۵، ۲۱۰، ۱۵۰، ۸۰]:
        قیمت‌ها.بیفزا(ق)
    پایان
    مرتب سازی.مرتب(قیمت‌ها)
    سرچاپ "مرتب‌شده:"، قیمت‌ها

    پایین := مرتب سازی.کران پایین(قیمت‌ها، ۸۰)
    بالا := مرتب سازی.کران بالا(قیمت‌ها، ۱۵۰)
    سرچاپ "میان ۸۰ و ۱۵۰:"، بالا - پایین، "کالا"
    تکرار پایین تا بالا - ۱ در ی:
        چاپ قیمت‌ها.بگیر(ی)، ""
    پایان
    سرچاپ ""

    سرچاپ "چند کالا ۴۵ است:"، مرتب سازی.کران بالا(قیمت‌ها، ۴۵) - مرتب سازی.کران پایین(قیمت‌ها، ۴۵)

    هر تازه در [۱۰۰، ۱۰، ۵۰۰]:
        سرچاپ "قیمت تازه‌ی"، تازه، "در اندیس"، مرتب سازی.کران پایین(قیمت‌ها، تازه)، "ترتیب را نگه می‌دارد"
    پایان
    سرچاپ "جای ۲۱۰:"، مرتب سازی.جستجوی دودویی(قیمت‌ها، ۲۱۰)، "جای ۲۱۱:"، مرتب سازی.جستجوی دودویی(قیمت‌ها، ۲۱۱)
پایان
خروجیمرتب‌شده: [45, 45, 80, 99, 120, 150, 210, 300] میان ۸۰ و ۱۵۰: 4 کالا 80 99 120 150 چند کالا ۴۵ است: 2 قیمت تازه‌ی 100 در اندیس 4 ترتیب را نگه می‌دارد قیمت تازه‌ی 10 در اندیس 0 ترتیب را نگه می‌دارد قیمت تازه‌ی 500 در اندیس 8 ترتیب را نگه می‌دارد جای ۲۱۰: 6 جای ۲۱۱: -1

واژه‌های یکتا و ترتیب دلخواه برای رشته‌ها

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

sort-guide-unique.salam
واردسازی مرتب سازی
واردسازی رشته

تابع ریشه:
    متن := "the quick fox and the lazy dog and the cat"
    ناپایا واژه‌ها := رشته.واژه ها(متن)
    دیرکن واژه‌ها.آزادکن()
    مرتب سازی.مرتب(واژه‌ها)

    ناپایا یکتا := وکتور {} برگردان وکتور<رشته>
    دیرکن یکتا.آزادکن()
    هر واژه در واژه‌ها:
        اگر یکتا.طول() برابر ۰ یا یکتا.بگیر(یکتا.طول() - ۱) != واژه:
            یکتا.بیفزا(واژه)
        پایان
    پایان
    سرچاپ یکتا.طول()، "واژه‌ی متفاوت:"، یکتا

    مرتب سازی.مرتب سازی با(یکتا، (الف: رشته، ب: رشته):
        اگر الف.طول() != ب.طول(): برگشت الف.طول() بزرگتر ب.طول() پایان
        برگشت الف کوچکتر ب
    پایان)
    سرچاپ "بلندترین اول:"، یکتا

    مرتب سازی.مرتب نزولی(واژه‌ها)
    سرچاپ "نخستین واژه به ترتیب وارونه:"، واژه‌ها.بگیر(۰)
پایان
خروجی7 واژه‌ی متفاوت: ["and", "cat", "dog", "fox", "lazy", "quick", "the"] بلندترین اول: ["quick", "lazy", "and", "cat", "dog", "fox", "the"] نخستین واژه به ترتیب وارونه: the

ترتیب الفبای فارسی

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

sort-guide-persian.salam
واردسازی مرتب سازی
واردسازی رشته

پایا الفبا := "آابپتثجچحخدذرزژسشصضطظعغفقکگلمنوهی"

تابع جایگاه(حرف: رشته): صحیح:
    ی := رشته.اندیس(الفبا، حرف)
    اگر ی کوچکتر ۰: برگشت ۱۰۰۰ پایان
    برگشت ی
پایان

تابع الفبایی جلوتر(الف: رشته، ب: رشته): منطقی:
    ناپایا ی := ۰
    تا ی کوچکتر الف.طول() و ی کوچکتر ب.طول():
        جا الف := جایگاه(الف.زیررشته(ی، ۲))
        جا ب := جایگاه(ب.زیررشته(ی، ۲))
        اگر جا الف != جا ب: برگشت جا الف کوچکتر جا ب پایان
        ی += ۲
    پایان
    برگشت الف.طول() کوچکتر ب.طول()
پایان

تابع ریشه:
    ناپایا نام‌ها := وکتور {} برگردان وکتور<رشته>
    دیرکن نام‌ها.آزادکن()
    هر ن در ["هما"، "پریسا"، "وحید"، "آرش"، "ژاله"، "گلناز"، "بابک"، "چکاوک"، "زهرا"، "کاوه"، "یاسمن"، "حسن"]:
        نام‌ها.بیفزا(ن)
    پایان
    ناپایا بایتی := مرتب سازی.مرتب شده(نام‌ها)
    دیرکن بایتی.آزادکن()
    سرچاپ "مرتب:"، بایتی
    مرتب سازی.مرتب سازی با(نام‌ها، (الف: رشته، ب: رشته): برگشت الفبایی جلوتر(الف، ب) پایان)
    سرچاپ "الفبایی:"، نام‌ها
پایان
خروجیمرتب: ["آرش", "بابک", "حسن", "زهرا", "هما", "وحید", "پریسا", "چکاوک", "ژاله", "کاوه", "گلناز", "یاسمن"] الفبایی: ["آرش", "بابک", "پریسا", "چکاوک", "حسن", "زهرا", "ژاله", "کاوه", "گلناز", "وحید", "هما", "یاسمن"]

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

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

تابع‌ها

جابجایی Swap

تابع جابجایی<T>(v: وکتور<T>، i: صحیح، j: صحیح)
جای دو عضو وکتور را عوض می‌کند.
sort-Sort.salam
واردسازی مرتب سازی

تابع ریشه:
    ناپایا عددها := وکتور {} برگردان وکتور<صحیح>
    دیرکن عددها.آزادکن()
    هر ع در [۵، ۳، ۹، ۱، ۷]:
        عددها.بیفزا(ع)
    پایان
    سرچاپ مرتب سازی.مرتب است(عددها)
    مرتب‌شده := مرتب سازی.مرتب شده(عددها)
    سرچاپ مرتب‌شده، عددها
    مرتب سازی.مرتب(عددها)
    سرچاپ عددها، مرتب سازی.مرتب است(عددها)
    مرتب سازی.مرتب نزولی(عددها)
    سرچاپ عددها
    مرتب سازی.برعکس(عددها)
    سرچاپ عددها، مرتب سازی.کمینه(عددها)، مرتب سازی.بیشینه(عددها)
    مرتب سازی.جابجایی(عددها، ۰، ۴)
    سرچاپ عددها
پایان
خروجیfalse [1, 3, 5, 7, 9] [5, 3, 9, 1, 7] [1, 3, 5, 7, 9] true [9, 7, 5, 3, 1] [1, 3, 5, 7, 9] 1 9 [9, 3, 5, 7, 1]

مرتب سازی با SortBy

تابع مرتب سازی با<T>(v: وکتور<T>، less: تابع(T، T): منطقی)
وکتور را با تابع مقایسه‌ی less مرتب می‌کند؛ less(a، b) باید درست برگرداند اگر a باید پیش از b بیاید. مرتب‌سازی سریع است و ترتیب‌نگه‌دار نیست، و وقتی عضوهای زیادی برابرند کُند می‌شود؛ آن‌جا مرتب سازی ترتیب‌نگه‌دار با را به کار ببرید.
sort-SortBy.salam
واردسازی مرتب سازی

ساختار دانشجو:
    همگانی نام: رشته = ""
    همگانی نمره: صحیح = ۰
پایان

تابع ریشه:
    ناپایا کلاس := وکتور {} برگردان وکتور<دانشجو>
    دیرکن کلاس.آزادکن()
    کلاس.بیفزا(دانشجو { نام = "سارا"، نمره = ۱۸ })
    کلاس.بیفزا(دانشجو { نام = "علی"، نمره = ۱۵ })
    کلاس.بیفزا(دانشجو { نام = "رضا"، نمره = ۱۸ })
    کلاس.بیفزا(دانشجو { نام = "مریم"، نمره = ۲۰ })
    بیشتر := (الف: دانشجو، ب: دانشجو): برگشت الف.نمره > ب.نمره پایان
    مرتب سازی.مرتب سازی ترتیب‌نگه‌دار با(کلاس، بیشتر)
    هر د در کلاس:
        چاپ د.نام، ""
    پایان
    سرچاپ ""
    سرچاپ مرتب سازی.مرتب است با(کلاس، بیشتر)
    کمتر := (الف: دانشجو، ب: دانشجو): برگشت الف.نمره < ب.نمره پایان
    صعودی := مرتب سازی.مرتب شده با(کلاس، کمتر)
    سرچاپ صعودی.بگیر(۰).نام
    مرتب سازی.مرتب سازی با(کلاس، کمتر)
    سرچاپ کلاس.بگیر(۰).نام
پایان
خروجیمریم سارا رضا علی true علی علی

مرتب سازی ترتیب‌نگه‌دار با StableSortBy

تابع مرتب سازی ترتیب‌نگه‌دار با<T>(v: وکتور<T>، less: تابع(T، T): منطقی)
مثل مرتب سازی با، ولی عضوهای برابر ترتیب اولیه‌شان را حفظ می‌کنند؛ در نمونه، سارا پیش از رضا می‌ماند چون زودتر آمده بود. مرتب‌سازی ادغامی است: روی هر ورودی n log n، با یک رونوشت موقت از وکتور.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-SortBy.salam

مرتب شده با SortedBy

تابع مرتب شده با<T>(v: وکتور<T>، less: تابع(T، T): منطقی): وکتور<T>
رونوشت مرتب‌شده با تابع مقایسه‌ی دلخواه (با مرتب سازی با، پس ترتیب‌نگه‌دار نیست). وکتور اصلی تغییر نمی‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-SortBy.salam

مرتب است با IsSortedBy

تابع مرتب است با<T>(v: وکتور<T>، less: تابع(T، T): منطقی): منطقی
اگر وکتور بر اساس تابع مقایسه مرتب باشد، درست برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-SortBy.salam

مرتب سازی سطلی BucketSort

تابع مرتب سازی سطلی(v: وکتور<صحیح>)
مرتب‌سازی سطلی برای عددهای صحیح؛ وقتی عددها در بازه‌ای یکنواخت پخش‌اند سریع است.
sort-IntSorts.salam
واردسازی مرتب سازی

تابع ریشه:
    تکرار ۳ در ر:
        ناپایا و۱ := وکتور {} برگردان وکتور<صحیح>
        دیرکن و۱.آزادکن()
        هر ع در [۱۷۰، ۴۵، ۷۵، ۹۰، ۸۰۲، ۲۴، ۲، ۶۶]:
            و۱.بیفزا(ع)
        پایان
        اگر ر == ۰:
            مرتب سازی.مرتب سازی مبنایی(و۱)
        وگرنه ر == ۱:
            مرتب سازی.مرتب سازی شمارشی(و۱)
        وگرنه:
            مرتب سازی.مرتب سازی سطلی(و۱)
        پایان
        سرچاپ و۱
    پایان
پایان
خروجی[2, 24, 45, 66, 75, 90, 170, 802] [2, 24, 45, 66, 75, 90, 170, 802] [2, 24, 45, 66, 75, 90, 170, 802]

مرتب سازی شمارشی CountingSort

تابع مرتب سازی شمارشی(v: وکتور<صحیح>)
مرتب‌سازی شمارشی برای عددهای صحیح؛ وقتی بازه‌ی عددها کوچک است، بسیار سریع است. برای هر مقدار میان کوچک‌ترین و بزرگ‌ترین یک شمارنده می‌سازد، پس بازه‌ی پهن حافظه‌ی زیادی می‌گیرد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-IntSorts.salam

مرتب سازی مبنایی RadixSort

تابع مرتب سازی مبنایی(v: وکتور<صحیح>)
مرتب‌سازی مبنایی برای عددهای صحیح؛ رقم به رقم مرتب می‌کند و مقایسه ندارد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-IntSorts.salam

مرتب سازی پنکیکی PancakeSort

تابع مرتب سازی پنکیکی<T>(v: وکتور<T>)
مرتب‌سازی پنکیکی؛ فقط با برعکس کردن ابتدای وکتور مرتب می‌کند. برای آموزش.
sort-Algorithms.salam
واردسازی مرتب سازی

تابع ریشه:
    داده := [۹، ۴، ۷، ۱، ۸، ۲، ۶، ۳، ۵، ۰]
    تکرار ۱۳ در ر:
        ناپایا و۱ := وکتور {} برگردان وکتور<صحیح>
        هر ع در داده:
            و۱.بیفزا(ع)
        پایان
        ترابرد ر:
            ۰: مرتب سازی.مرتب سازی سریع(و۱) بشکن پایان
            ۱: مرتب سازی.مرتب سازی ادغامی(و۱) بشکن پایان
            ۲: مرتب سازی.مرتب سازی هرمی(و۱) بشکن پایان
            ۳: مرتب سازی.مرتب سازی درجی(و۱) بشکن پایان
            ۴: مرتب سازی.مرتب سازی درجی دودویی(و۱) بشکن پایان
            ۵: مرتب سازی.مرتب سازی انتخابی(و۱) بشکن پایان
            ۶: مرتب سازی.مرتب سازی حبابی(و۱) بشکن پایان
            ۷: مرتب سازی.مرتب سازی شل(و۱) بشکن پایان
            ۸: مرتب سازی.مرتب سازی شانه ای(و۱) بشکن پایان
            ۹: مرتب سازی.مرتب سازی کوکتلی(و۱) بشکن پایان
            ۱۰: مرتب سازی.مرتب سازی حلزونی(و۱) بشکن پایان
            ۱۱: مرتب سازی.مرتب سازی زوج فرد(و۱) بشکن پایان
            ۱۲: مرتب سازی.مرتب سازی پنکیکی(و۱) بشکن پایان
        پایان
        چاپ مرتب سازی.مرتب است(و۱)، ""
        و۱.آزادکن()
    پایان
    سرچاپ ""
    ناپایا د := وکتور {} برگردان وکتور<صحیح>
    دیرکن د.آزادکن()
    هر ع در داده:
        د.بیفزا(ع)
    پایان
    مرتب سازی.مرتب سازی درون نگر(د)
    سرچاپ د
پایان
خروجیtrue true true true true true true true true true true true true [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

مرتب سازی شانه ای CombSort

تابع مرتب سازی شانه ای<T>(v: وکتور<T>)
مرتب‌سازی شانه‌ای؛ نسخه‌ی بهبودیافته‌ی حبابی.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی حبابی BubbleSort

تابع مرتب سازی حبابی<T>(v: وکتور<T>)
مرتب‌سازی حبابی؛ ساده و کند، برای آموزش.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

جستجوی دودویی BinarySearch

تابع جستجوی دودویی<T>(v: وکتور<T>، x: T): صحیح
جای x را در وکتور مرتب با جستجوی دودویی پیدا می‌کند؛ اگر نباشد، منفی یک. اگر تکراری باشد یکی از جایگاه‌ها را می‌دهد، نه لزوماً نخستین را؛ برای نخستین کران پایین را به کار ببرید.
sort-BinarySearch.salam
واردسازی مرتب سازی

تابع ریشه:
    ناپایا عددها := وکتور {} برگردان وکتور<صحیح>
    دیرکن عددها.آزادکن()
    هر ع در [۱، ۳، ۳، ۳، ۷، ۹]:
        عددها.بیفزا(ع)
    پایان
    سرچاپ مرتب سازی.جستجوی دودویی(عددها، ۷)، مرتب سازی.جستجوی دودویی(عددها، ۴)
    سرچاپ مرتب سازی.کران پایین(عددها، ۳)، مرتب سازی.کران بالا(عددها، ۳)
پایان
خروجی4 -1 1 4

کران پایین LowerBound

تابع کران پایین<T>(v: وکتور<T>، x: T): صحیح
نخستین جایی که عضوش کمتر از x نیست؛ جایی که x باید درج شود تا وکتور مرتب بماند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-BinarySearch.salam

کران بالا UpperBound

تابع کران بالا<T>(v: وکتور<T>، x: T): صحیح
نخستین جایی که عضوش بزرگ‌تر از x است. فاصله‌ی کران بالا و پایین، تعداد تکرارهای x است.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-BinarySearch.salam

مرتب‌سازی نمایه SortIndex

تابع مرتب‌سازی نمایه(idx &: وکتور<صحیح>، keys &: وکتور<اعشار۶۴>)
به‌جای مرتب کردن داده‌ها، شماره‌های idx را بر اساس keys (یک وکتور<اعشار۶۴>) صعودی مرتب می‌کند؛ وقتی چند وکتور هم‌ترتیب دارید و می‌خواهید همه را با هم مرتب ببینید. ترتیب‌نگه‌دار نیست.
sort-SortIndex.salam
واردسازی مرتب سازی

تابع ریشه:
    نام‌ها := ["تهران"، "شیراز"، "تبریز"]
    ناپایا جمعیت := وکتور {} برگردان وکتور<اعشار۶۴>
    ناپایا ترتیب := وکتور {} برگردان وکتور<صحیح>
    دیرکن جمعیت.آزادکن()
    دیرکن ترتیب.آزادکن()
    جمعیت.بیفزا(۸.۷)
    جمعیت.بیفزا(۱.۶)
    جمعیت.بیفزا(۱.۶۵)
    تکرار ۳ در ای:
        ترتیب.بیفزا(ای)
    پایان
    مرتب سازی.مرتب‌سازی نمایه(ترتیب، جمعیت)
    هر ش در ترتیب:
        چاپ نام‌ها[ش]، ""
    پایان
    سرچاپ ""
    مرتب سازی.مرتب‌سازی نمایه نزولی(ترتیب، جمعیت)
    هر ش در ترتیب:
        چاپ نام‌ها[ش]، ""
    پایان
    سرچاپ ""
پایان
خروجیشیراز تبریز تهران تهران تبریز شیراز

مرتب‌سازی نمایه نزولی SortIndexDesc

تابع مرتب‌سازی نمایه نزولی(idx &: وکتور<صحیح>، keys &: وکتور<اعشار۶۴>)
مثل مرتب‌سازی نمایه، نزولی؛ صعودی مرتب و بعد وارونه می‌کند، پس کلیدهای برابر وارونه درمی‌آیند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-SortIndex.salam

مرتب سازی زوج فرد OddEvenSort

تابع مرتب سازی زوج فرد<T>(v: وکتور<T>)
مرتب‌سازی زوج و فرد؛ برای پردازش موازی طراحی شده است.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی حلزونی GnomeSort

تابع مرتب سازی حلزونی<T>(v: وکتور<T>)
مرتب‌سازی حلزونی؛ مثل درجی، ساده و کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی انتخابی SelectionSort

تابع مرتب سازی انتخابی<T>(v: وکتور<T>)
مرتب‌سازی انتخابی؛ هر بار کوچک‌ترین عضو باقیمانده را جلو می‌آورد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی هرمی HeapSort

تابع مرتب سازی هرمی<T>(v: وکتور<T>)
مرتب‌سازی هرمی؛ همیشه سریع (n log n) و بدون حافظه‌ی اضافه.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی ادغامی MergeSort

تابع مرتب سازی ادغامی<T>(v: وکتور<T>)
مرتب‌سازی ادغامی؛ همیشه سریع و پایدار، ولی حافظه‌ی اضافه می‌گیرد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی شل ShellSort

تابع مرتب سازی شل<T>(v: وکتور<T>)
مرتب‌سازی شل؛ نسخه‌ی سریع‌تر درجی.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی درجی InsertionSort

تابع مرتب سازی درجی<T>(v: وکتور<T>)
مرتب‌سازی درجی؛ برای وکتورهای کوچک یا تقریباً مرتب خیلی خوب است.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی درجی دودویی BinaryInsertionSort

تابع مرتب سازی درجی دودویی<T>(v: وکتور<T>)
مرتب‌سازی درجی که جای درج را با جستجوی دودویی پیدا می‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی درون نگر IntroSort

تابع مرتب سازی درون نگر<T>(v: وکتور<T>)
مرتب‌سازی درون‌نگر؛ با سریع شروع می‌کند و اگر لازم شد به هرمی تغییر می‌دهد تا هیچ‌وقت کند نشود.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب است IsSorted

تابع مرتب است<T>(v: وکتور<T>): منطقی
اگر وکتور صعودی مرتب باشد، درست برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Sort.salam

برعکس Reverse

تابع برعکس<T>(v: وکتور<T>)
ترتیب عضوهای وکتور را برعکس می‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Sort.salam

کمینه Min

تابع کمینه<T>(v: وکتور<T>): T
کوچک‌ترین عضو وکتور. وکتور نباید خالی باشد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Sort.salam

بیشینه Max

تابع بیشینه<T>(v: وکتور<T>): T
بزرگ‌ترین عضو وکتور. وکتور نباید خالی باشد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Sort.salam

مرتب Sort

تابع مرتب<T>(v: وکتور<T>)
وکتور را با مرتب‌سازی درون‌نگر صعودی مرتب می‌کند: روی هر ورودی n log n، بدون حفظ ترتیب برابرها. انتخاب پیش‌فرض برای مرتب کردن. رشته‌ها بایت به بایت مقایسه می‌شوند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Sort.salam

مرتب نزولی SortDesc

تابع مرتب نزولی<T>(v: وکتور<T>)
وکتور را نزولی مرتب می‌کند: یک مرتب‌سازی صعودی و بعد وارونه کردن.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Sort.salam

مرتب شده Sorted

تابع مرتب شده<T>(v: وکتور<T>): وکتور<T>
رونوشت صعودی مرتب‌شده‌ی وکتور؛ اصلی تغییر نمی‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Sort.salam

مرتب سازی سریع QuickSort

تابع مرتب سازی سریع<T>(v: وکتور<T>)
مرتب‌سازی سریع؛ در عمل سریع‌ترین برای داده‌ی تصادفی، ولی روی مقدارهای برابر فراوان کُند می‌شود.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam

مرتب سازی کوکتلی CocktailSort

تابع مرتب سازی کوکتلی<T>(v: وکتور<T>)
مرتب‌سازی کوکتلی؛ حبابی که در هر دور، هم از چپ به راست و هم برعکس می‌رود.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: sort-Algorithms.salam