Cara menggunakan python 2 list sort

Question

Here's one way: You basically re-write your sort function to take a list of sort functions, each sort function compares the attributes you want to test, on each sort test, you look and see if the cmp function returns a non-zero return if so break and send the return value. You call it by calling a Lambda of a function of a list of Lambdas.

Table of Contents Show

Bubble Sort
Selection Sort
Insertion Sort

Its advantage is that it does single pass through the data not a sort of a previous sort as other methods do. Another thing is that it sorts in place, whereas sorted seems to make a copy.

I used it to write a rank function, that ranks a list of classes where each object is in a group and has a score function, but you can add any list of attributes. Note the un-lambda-like, though hackish use of a lambda to call a setter. The rank part won't work for an array of lists, but the sort will.

Kembali lagi ke FunCode anbies, disini kita akan membahas macam - macam algoritma sorting atau pengurutan menggunakan bahasa Python.

Pengurutan (sorting) adalah yang sangat penting saat memanipulasi data. Ketika kita mengurutkan data, data akan terlihat rapi dan mudah dibaca. Sehingga memudahkan juga dalam menganalisa.

Kenapa kita perlu algoritma untuk mengurutkan sesuatu? Saat pengurutan data dilakukan, program akan mengkalkulasi dan membandingkan setiap data agar dapat menemukan mana yang terbesar dan terkecil.

Oke, mungkin jika datanya cuman “ratusan” atau “ribuan” mungkin komputer kita masih bisa menanganinya. Tapi bagaimana jika datanya sampai jutaan atau miliaran seperti yang dilakukan Google?

Bisa kalian bayangkan kan? Maka dari itu pemilihan algoritma untuk pengurutan (sorting) juga mempengaruhi cepat atau lambatnya sistem dalam memanipulasi data.

Hahaha 😄 santai aja anbi disini bakal bahas algoritma sorting yang sederhana aja kok. Enggak yang sampai setara punya Google. Oke kita mulai aja.

Bubble Sort

Bubble Sort adalah algoritma sorting yang paling populer dan sederhana diantara algoritma lainnya. Proses pengurutan pada algoritma ini dengan membandingkan masing - masing elemen secara berpasangan lalu menukarnya dalam kondisi tertentu.

Proses ini akan terus diulang sampai elemen terakhir atau sampai tidak ada lagi elemen yang dapat ditukar. Inilah kenapa algoritma ini diberi nama “Bubble”, dimana gelembung yang terbesar akan naik ke atas.

def bubble_sort(array):
    n = len(array) # jumlah list
    # perulangan pertama
    for i in range(n): 
        # perulangan kedua
        for j in range(n - i - 1):
            # bandingkan masing" elemen
            if array[j] > array[j + 1]:
                # jika lebih besar, tukar.
                array[j], array[j + 1] = array[j + 1], array[j]
    return array

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

Outputnya seperti ini :

[1, 2, 3, 4, 5, 6, 8, 9]

Apa yang terjadi pada kode diatas? Ini penjelasannya.

Alur Kode :

Kita hitung jumlah list menggunakan

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

9 sebagai parameter perulangan.

Buat dua perulangan untuk membandingkan elemen pada list.
Bandingkan elemen pertama dengan elemen kedua menggunakan
```
[1, 2, 3, 4, 5, 6, 8, 9]
```
0.

Jika elemen pertama lebih besar daripada elemen kedua maka tukar posisinya.

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

Jika elemen kedua lebih besar dari pada elemen pertama maka biarkan saja.
Langkah 3 - 5 diulang sampai elemen terakhir (atau perulangan selesai).

Kurang lebih gambarannya akan seperti ini :

Bubble Sort

Lalu, untuk mengurutkan secara descending (dari terbesar ke terkecil) bagaimana? Mudah, tinggal kita ubah saja perbandingannya (

[1, 2, 3, 4, 5, 6, 8, 9]

0).

# descending
if array[j] < array[j + 1]:
    ...

[9, 8, 6, 5, 4, 3, 2, 1]

Dari yang tadinya elemen besar di tukar elemen kecil, sekarang elemen kecil ditukar elemen yang besar. Simple AF 😄.

Selection Sort

Selection Sort adalah algoritma sorting yang mengurutkan data dengan cara mencari elemen paling kecil dari list, lalu menukar elemen tersebut ke urutan paling awal.

Dalam algoritma ini memiliki konsep yang sama dengan bubble sort, yaitu membandingkan dan menukar. Tetapi, dalam selection sort ia akan mencari

[1, 2, 3, 4, 5, 6, 8, 9]

2 dengan elemen paling kecil, ketika sudah ketemu, elemen pada

[1, 2, 3, 4, 5, 6, 8, 9]

2 itu akan ditukar dengan elemen pada

[1, 2, 3, 4, 5, 6, 8, 9]

2 pertama.

Begitu seterusnya sampai perulangan selesai atau tidak ada lagi elemen yang bisa ditukar.

def selection_sort(arr):  
    n = len(arr)
    # perulangan list elemen
    for i in range(n):
        # cari nilai elemen terendah
        # yang masih tersedia
        min_idx = i
        for j in range(i+1, n):
            if arr[min_idx] > arr[j]:
                min_idx = j
                
        # tukar dengan nilai elemen ke-i
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

listku = [64, 25, 12, 22, 11]
print(selection_sort(listku))

Lalu, outputnya seperti ini :

[11, 12, 22, 25, 64]

Apa yang terjadi pada kode diatas? Penjelasannya

Alur Kode :

Kita cari dulu jumlah elemen pada list dengan
```
[1, 2, 3, 4, 5, 6, 8, 9]
```
5.
Lalu lakukan perulangan pertama yang didalamnya terdapat kode untuk mencari nilai minimium dan menukar nilai.
Jika kalian perhatikan terdapat
```
[1, 2, 3, 4, 5, 6, 8, 9]
```
6 yang berperan untuk menampung index dengan nilai terendah.
Lalu pada perulangan kedua, setiap elemen akan terus dibandingkan menggunakan
```
[1, 2, 3, 4, 5, 6, 8, 9]
```
0 untuk mendapatkan index dengan nilai terkecil.
```
for j in range(i+1, n):
    if arr[min_idx] > arr[j]:
        min_idx = j
```
Pada perulangan kedua, semua elemen setelah elemen ke-
```
[1, 2, 3, 4, 5, 6, 8, 9]
```
8 atau
```
[1, 2, 3, 4, 5, 6, 8, 9]
```
9, saling dibandingkan untuk mencari nilai terkecil.

Setelah menemukan elemen dengan nilai terkecil, index tersebut ditukar dengan nilai ke-

[1, 2, 3, 4, 5, 6, 8, 9]

8.

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

0

Hal tersebut diulang sampai perulangan pertama selesai (atau tidak elemen tuk diulang).

Kurang lebih gambarannya akan seperti ini :

Selection Sort

Lalu bagaimana untuk descending order menggunakan Selection Sort? Sama seperti sebelumnya, kita tinggal ubah pembandingnya (

[1, 2, 3, 4, 5, 6, 8, 9]

0).

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

1

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

2

Insertion Sort

Insertion Sort adalah algoritma yang melakukan pengurutan dengan membandingkan elemen satu dengan elemen lainnya dalam sebuah list. Elemen yang dibandingkan akan ditempatkan ke posisi yang sesuai (urut) pada list.

Analoginya seperti mengurutkan kumpulan kartu. Setiap kartu yang kalian ambil, kalian bandingkan terlebih dahulu ke kumpulan kartu yang sudah diurutkan. Dan ketika tahu urutan ke berapa, kalian selipkan kartu itu ke tumpukan kartu agar urut.

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

3

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

4

Outputnya akan seperti ini :

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

5

Apa yang terjadi pada kode diatas? berikut penjelasannya.

Alur Kode

Kita mulai dari perulangan dari elemen kedua (
```
if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]
```
2) sampai elemen terakhir. Kenapa tidak dari elemen pertama? karena elemen pertama adalah elemen yang dibandingkan oleh elemen yang lain.
Variabel
```
if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]
```
3, adalah tempat untuk menampung elemen yang akan diposisikan.

Sedangkan variabel

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

4 dengan nilai

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

5 adalah tujuan index yang nantinya elemen

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

3 akan ditempatkan.

Menggunakan perulangan

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

7 yang memiliki kondisi selama

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

8 dan elemen index

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

4 lebih besar dari

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

3, Maka elemen yang lain akan digeser dan index

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

4 diperbarui.

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

6

Setelah tidak ada lagi elemen yang lebih besar dari

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

3, maka perulangan

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

7 akan berhenti.

Lalu tempatkan elemen pada

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

3 ke index

# descending
if array[j] < array[j + 1]:
    ...

5. Kenapa

# descending
if array[j] < array[j + 1]:
    ...

5? karena sebelumnya kita memberikan nilai

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

5 yang seharusnya tidak sesuai.

Kurang lebih gambarannya seperti ini.

Insertion Sort

Lalu untuk descending order menggunakan Insertion Sort, kita tinggal ubah pembanding pada saat

if array[j] > array[j + 1]:
    array[j], array[j + 1] = array[j + 1], array[j]

7.

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

7

Outputnya akan seperti ini :

unordered = [5, 3, 4, 8, 1, 2, 9, 6]
print(bubble_sort(unordered))

8

. . .

Ketiga sorting diatas adalah ketiga sorting paling sederhana. Penerapannya pun menggunakan python cukup singkat. Menurut kalian, dari ketiga sorting diatas, mana yang paling cepat proses sortingnya?

Untuk full codenya kalian bisa kalian di github AnbiDev.

🐙 https://github.com/AnbiDev/anbi-funcode/tree/master/sorting-case

Oke, mungkin sekian dulu untuk algoritma sorting menggunakan python. Nanti anbi akan buat Part 2 untuk lebih mendalami algoritma dalam python.

kode python