{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Algoritma Sorting (Pengurutan)\n",
    "Algoritma pengurutan adalah metode yang digunakan untuk mengatur kumpulan data dalam urutan tertentu. Beberapa jenis algoritma pengurutan yang umum digunakan meliputi quick sort, heap sort, counting sort, radix sort, dan bucket sort. Quick sort bekerja dengan memilih elemen pivot dan mempartisi data menjadi dua bagian. Heap sort menggunakan struktur data heap untuk mengurutkan elemen. Counting sort cocok untuk mengurutkan data yang memiliki rentang nilai tertentu. Radix sort mengurutkan berdasarkan digit-digit angka dalam data. Bucket sort membagi data ke dalam beberapa \"ember\" dan mengurutkan masing-masing ember. Setiap algoritma memiliki kelebihan dan kelemahan serta kondisi penggunaan yang berbeda. Memahami berbagai jenis algoritma pengurutan dapat membantu pemrogram memilih algoritma yang paling efisien dan sesuai dengan situasi tertentu, baik dalam hal waktu eksekusi maupun penggunaan memori."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Quick Sort\n",
    "Quick sort adalah algoritma pengurutan yang efisien dan sering digunakan untuk mengurutkan kumpulan data besar. Algoritma ini bekerja dengan memilih elemen pivot dari data dan mempartisi data menjadi dua bagian: elemen-elemen yang lebih kecil dari pivot dan elemen-elemen yang lebih besar dari pivot. Proses ini diulang pada kedua bagian data hingga seluruh data terurut. Langkah-langkah dalam Quick sort:\n",
    "1. Pilih elemen pivot dari data.\n",
    "2. Partisi data sehingga elemen-elemen yang lebih kecil dari pivot berada di satu sisi, dan elemen-elemen yang lebih besar berada di sisi lain.\n",
    "3. Lakukan langkah 2 untuk kedua bagian data secara rekursif.\n",
    "4. Gabungkan kembali bagian-bagian data yang telah terurut.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://wat-images.s3.ap-south-1.amazonaws.com/images/course/ci6ldqnqthum/Quick_Sort_0.png\" width=\"575px\" />\n",
    "Sumber Gambar: https://workat.tech\n",
    "\n",
    "##### **Kelebihan Quick Sort**\n",
    "Kelebihan Quick sort termasuk efisiensi dan kinerja yang baik pada data besar. Namun, efektivitasnya bisa dipengaruhi jika pivot dipilih dengan buruk, sehingga algoritma memerlukan pemilihan pivot yang cermat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "def quick_sort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    \n",
    "    pivot = arr[len(arr) // 2]\n",
    "    left = [x for x in arr if x < pivot]\n",
    "    middle = [x for x in arr if x == pivot]\n",
    "    right = [x for x in arr if x > pivot]\n",
    "    \n",
    "    return quick_sort(left) + middle + quick_sort(right)\n",
    "\n",
    "data = [3, 6, 8, 10, 1, 2, 1]\n",
    "sorted_data = quick_sort(data)\n",
    "print(sorted_data)  # Output: [1, 1, 2, 3, 6, 8, 10]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2. Circle Sort\n",
    "Algoritma pengurutan lingkaran dapat divisualisasikan dengan menggambar lingkaran konsentris pada larik bilangan bulat. Elemen-elemen dari array yang terletak pada lingkaran yang sama secara diametris berlawanan satu sama lain dibandingkan dan jika ditemukan dalam urutan yang salah, mereka akan ditukar. Ini berlangsung secara rekursif di mana array dibagi menjadi sub-array di mana proses di atas diulang sampai kita mendapatkan pasangan elemen yang diurutkan yang bila disatukan membentuk array yang diurutkan. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"http://forth-4th.sourceforge.net/images/CircleSort.png\" width=\"350px\" />\n",
    "Sumber Gambar: forth-4th.sourceforge.net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Counting Sort\n",
    "Counting sort adalah algoritma pengurutan yang efisien untuk mengurutkan data dengan rentang nilai terbatas. Algoritma ini bekerja dengan menghitung berapa kali setiap elemen muncul dalam data, dan kemudian menghasilkan data yang terurut berdasarkan hasil perhitungan tersebut. Langkah-langkah dalam Counting sort:\n",
    "1. Buat array frekuensi yang menghitung berapa kali setiap elemen muncul dalam data.\n",
    "2. Buat array akumulatif yang menjumlahkan frekuensi untuk setiap elemen.\n",
    "3. Buat array output yang akan menyimpan data yang terurut.\n",
    "4. Iterasi dari belakang data asli, masukkan elemen ke dalam array output sesuai dengan posisinya dalam array akumulatif, lalu kurangi frekuensi elemen tersebut.\n",
    "5. Output akan berisi data yang terurut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def counting_sort(arr):\n",
    "    max_value = max(arr)\n",
    "    min_value = min(arr)\n",
    "    range_of_elements = max_value - min_value + 1\n",
    "    \n",
    "    counting_array = [0] * range_of_elements\n",
    "    output_array = [0] * len(arr)\n",
    "    \n",
    "    for i in range(len(arr)):\n",
    "        counting_array[arr[i] - min_value] += 1\n",
    "        \n",
    "    for i in range(1, len(counting_array)):\n",
    "        counting_array[i] += counting_array[i - 1]\n",
    "        \n",
    "    for i in range(len(arr) - 1, -1, -1):\n",
    "        output_array[counting_array[arr[i] - min_value] - 1] = arr[i]\n",
    "        counting_array[arr[i] - min_value] -= 1\n",
    "        \n",
    "    return output_array\n",
    "\n",
    "data = [4, 2, 2, 8, 3, 3, 1]\n",
    "sorted_data = counting_sort(data)\n",
    "print(sorted_data)  # Output: [1, 2, 2, 3, 3, 4, 8]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Counting sort sangat efisien jika nilai data memiliki rentang yang terbatas, tetapi dapat menjadi tidak praktis jika rentang nilai sangat besar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4. Bucket Sort\n",
    "Bucket atau bin sort adalah algoritma pengurutan yang cocok untuk mengurutkan data dengan rentang nilai yang terbatas dan mendistribusikan data dalam \"ember\" (bucket) berdasarkan nilai-nilai tertentu. Setiap bucket kemudian diurutkan secara terpisah, dan hasilnya digabungkan menjadi satu data yang terurut. Langkah-langkah dalam Bucket sort:\n",
    "1. Membagi rentang nilai data menjadi beberapa bucket.\n",
    "2. Memasukkan elemen-elemen data ke dalam bucket yang sesuai berdasarkan nilai.\n",
    "3. Mengurutkan setiap bucket secara terpisah (misalnya menggunakan algoritma insertion sort).\n",
    "4. Menggabungkan semua bucket yang telah diurutkan menjadi satu data yang terurut."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![bucketsort](https://files.codingninjas.in/article_images/bucket-sort-0-1635318303.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bucket sort cocok untuk data dengan distribusi yang merata dalam rentang nilai tertentu, dan cocok untuk data dengan nilai desimal atau pecahan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[-10, -2, 0, 1, 2, 15]\n"
     ]
    }
   ],
   "source": [
    "def bucket_sort(my_list: list) -> list:\n",
    "    if len(my_list) == 0:\n",
    "        return []\n",
    "    min_value, max_value = min(my_list), max(my_list)\n",
    "    bucket_count = int(max_value - min_value) + 1\n",
    "    buckets: list[list] = [[] for _ in range(bucket_count)]\n",
    "\n",
    "    for i in my_list:\n",
    "        buckets[int(i - min_value)].append(i)\n",
    "\n",
    "    return [v for bucket in buckets for v in sorted(bucket)]\n",
    "\n",
    "print(bucket_sort([4, 5, 3, 2, 1]))\n",
    "print(bucket_sort([0, 1, -10, 15, 2, -2]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 5. Heap Sort\n",
    "Heap sort adalah algoritma pengurutan yang menggunakan struktur data heap untuk mengurutkan kumpulan data. Heap adalah struktur data pohon biner yang memiliki properti khusus: setiap node memiliki nilai yang lebih kecil atau lebih besar daripada anak-anaknya, tergantung pada jenis heap (max heap atau min heap). Langkah-langkah dalam Heap sort:\n",
    "1. Bangun heap dari data yang akan diurutkan.\n",
    "2. Pindahkan elemen teratas heap (akar) ke akhir data yang terurut.\n",
    "3. Perbaiki properti heap setelah memindahkan elemen teratas.\n",
    "4. Ulangi langkah 2-3 hingga seluruh data terurut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/MtQL_ll5KhQ\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "            \n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x203bfdc3450>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('MtQL_ll5KhQ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Kelebihan Heap sort termasuk kecepatan yang stabil pada berbagai ukuran data dan kecocokan terbaiknya pada data yang sudah ada dalam struktur heap. Namun, implementasinya dapat memerlukan lebih banyak memori dibandingkan dengan beberapa algoritma pengurutan lainnya. Contoh Heap sort dalam Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def heapify(arr, n, i):\n",
    "    largest = i\n",
    "    left = 2 * i + 1\n",
    "    right = 2 * i + 2\n",
    "    if left < n and arr[left] > arr[largest]:\n",
    "        largest = left\n",
    "        \n",
    "    if right < n and arr[right] > arr[largest]:\n",
    "        largest = right\n",
    "        \n",
    "    if largest != i:\n",
    "        arr[i], arr[largest] = arr[largest], arr[i]\n",
    "        heapify(arr, n, largest)\n",
    "\n",
    "def heap_sort(arr):\n",
    "    n = len(arr)\n",
    "    \n",
    "    for i in range(n // 2 - 1, -1, -1):\n",
    "        heapify(arr, n, i)\n",
    "        \n",
    "    for i in range(n - 1, 0, -1):\n",
    "        arr[i], arr[0] = arr[0], arr[i]\n",
    "        heapify(arr, i, 0)\n",
    "\n",
    "data = [3, 6, 8, 10, 1, 2, 1]\n",
    "heap_sort(data)\n",
    "print(data)  # Output: [1, 1, 2, 3, 6, 8, 10]"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}