🪙
Leetcode
  • Content
  • Algorithms
    • Linear Search
    • Binary Search
    • Counting Sort
    • Merge Sort
    • Insertion Sort
    • Selection Sort
  • Array and String
    • Introduction to Array
      • Introduction to Array
      • Introduction to Dynamic Array
      • Find Pivot Index
      • Largest Number At Least Twice of Others
      • Plus One
    • Introduction to 2D Array
      • Introduction to 2D Array
      • Diagonal Traverse
      • Spiral Matrix
      • Pascal's Triangle
    • Introduction to String
      • Introduction to String
      • Immutable String - Problems & Solutions
      • Add binary
      • Implement strStr()
      • Longest Common Prefix
    • Two-Pointer Technique
      • Two-pointer Technique - Scenario I
      • Reverse String
      • Array Partition I
      • Two Sum II - Input array is sorted
      • Two-pointer Technique - Scenario II
      • Remove Element
      • Max Consecutive Ones
      • Minimum Size Subarray Sum
    • Conclusion
      • Array-related Techniques
      • Rotate Array
      • Pascal's Triangle II
      • Reverse Words in a String
      • Reverse Words in a String III
      • Remove Duplicates from Sorted Array
      • Move Zeroes
  • Linked List
    • Singly Linked List
      • Introduction - Singly Linked List
      • Add Operation - Singly Linked List
      • Delete Operation - Singly Linked List
      • Design Linked List
    • Two Pointer Technique
      • Two-Pointer in Linked List
      • Linked List Cycle
      • Linked List Cycle II
      • Intersection of Two Linked Lists
      • Remove Nth Node From End of List
      • Summary - Two-Pointer in Linked List
  • Problems
    • 1. Two Sum
    • 2. Add Two Numbers
    • 7. Reverse Integer
    • 9. Palindrome Number
    • 11. Container With Most Water
    • 12. Integer to Roman
    • 13. Roman to Integer
    • 14. Longest Common Prefix
    • 15. 3Sum
    • 21. Merge Two Sorted Lists
    • 26. Remove Duplicates from Sorted Array
    • 27. Remove Element
    • 28. Find the Index of the First Occurrence in a String
    • 34. Find First and Last Position of Element in Sorted Array
    • 35. Search Insert Position
    • 43. Multiply Strings
    • 49. Group Anagrams
    • 50. Pow(x, n)
    • 54. Spiral Matrix
    • 58. Length of Last Word
    • 66. Plus One
    • 67. Add Binary
    • 69. Sqrt(x)
    • 73. Set Matrix Zeroes
    • 75. Sort Colors
    • 88. Merge Sorted Array
    • 104. Maximum Depth of Binary Tree
    • 121. Best Time to Buy and Sell Stock
    • 122. Best Time to Buy and Sell Stock II
    • 136. Single Number
    • 146. LRU Cache
    • 189. Rotate Array
    • 206. Reverse Linked List
    • 217. Contains Duplicate
    • 219. Cotains Duplicate II
    • 226. Invert Binary Tree
    • 238. Product of Array Except Self
    • 242. Valid Anagram
    • 268. Missing Number
    • 283. Move Zeroes
    • 350. Intersection of Two Arrays II
    • 383. Ransom Note
    • 389. Find the Difference
    • 412. Fizz Buzz
    • 414. Third Maximum Number
    • 445. Add Two Numbers II
    • 448. Find All Numbers Disappeared in an Array
    • 459. Repeated Substring Pattern
    • 485. Max Consecutive Ones
    • 509. Fibonacci Number
    • 637. Average of Levels in Binary Tree
    • 657. Robot Return to Origin
    • 682. Baseball Game
    • 704. Binary Search
    • 705. Design HashSet
    • 709. To Lower Case
    • 724. Find Pivot Index
    • 876. Middle of the Linked List
    • 896. Monotonic Array
    • 860. Lemonade Change
    • 905. Sort Array By Parity
    • 916. Word Subsets
    • 941. Valid Mountain Array
    • 976. Largest Perimeter Triangle
    • 977. Squares of a Sorted Array
    • 1041. Robot Bounded In Circle
    • 1051. Height Checker
    • 1089. Duplicate Zeros
    • 1232. Check If It Is a Straight Line
    • 1275. Find Winner on a Tic Tac Toe Game
    • 1295. Find Numbers with Even Number of Digits
    • 1299. Replace Elements with Greatest Element on Right Side
    • 1342. Number of Steps to Reduce a Number to Zero
    • 1346. Check If N and Its Double Exist
    • 1476. Subrectangle Queries
    • 1480. Running Sum of 1d Array
    • 1491. Average Salary Excluding the Minimum and Maximum Salary
    • 1502. Can Make Arithmetic Progression From Sequence
    • 1523. Count Odd Numbers in an Interval Range
    • 1572. Matrix Diagonal Sum
    • 1672. Richest Customer Wealth
    • 1768. Merge Strings Alternately
    • 1752. Check if Array Is Sorted and Rotated
    • 1769. Minimum Number of Operations to Move All Balls to Each Box
    • 1790. Check if One String Swap Can Make Strings Equal
    • 1800. Maximum Ascending Subarray Sum
    • 1822. Sign of the Product of an Array
    • 1930. Unique Length-3 Palindromic Subsequences
    • 1991. Find the Middle Index in Array
    • 2185. Counting Words With a Given Prefix
    • 2235. Add Two Integers
    • 2236. Root Equals Sum of Children
    • 2270. Number of Ways to Split Array
    • 2381. Shifting Letters II
    • 2559. Count Vowel Strings in Ranges
    • 2610. Convert an Array Into a 2D Array With Conditions
    • 2657. Find the Prefix Common Array of Two Arrays
    • 3042. Count Prefix and Suffix Pairs I
    • 3105. Longest Strictly Increasing or Strictly Decreasing Subarray
    • 3151. Special Array I
    • 3223. Minimum Length of String After Operations
Powered by GitBook
On this page
  • How does Selection Sort Algorithm work?
  • Implementation of Selection Sort
  • Complexity Analysis of Selection Sort
  • Advantages of Selection Sort Algorithm
  • Disadvantages of the Selection Sort Algorithm

Was this helpful?

Edit on GitHub
  1. Algorithms

Selection Sort

PreviousInsertion SortNextArray and String

Last updated 1 year ago

Was this helpful?

Selection sort - oddiy va samarali tartiblash algoritmi boʻlib, roʻyxatning tartiblanmagan qismidan eng kichik (yoki eng katta) elementni qayta-qayta tanlab, uni roʻyxatning tartiblangan qismiga koʻchirish orqali ishlaydi.

Algoritm ro'yxatning tartiblanmagan qismidan eng kichik (yoki eng katta) elementni qayta-qayta tanlaydi va uni tartiblanmagan qismning birinchi elementi bilan almashtiradi. Bu jarayon qolgan saralanmagan qism uchun butun ro'yxat saralanmaguncha takrorlanadi.

How does Selection Sort Algorithm work?

Misol sifatida quyidagi massivni ko'rib chiqamiz: arr[] = {64, 25, 12, 22, 11}

Birinchi o'tish:

  • Saralangan massivdagi birinchi o'rin uchun butun massiv 0 dan 4 gacha bo'lgan indeksdan ketma-ket o'tkaziladi. Hozirda 64 saqlanadigan birinchi pozitsiya, butun massivni aylanib o'tgandan so'ng, 11 eng past qiymat ekanligi ayon bo'ladi.

  • Shunday qilib, 64 ni 11 bilan almashtiring. Bir marta takrorlangandan so'ng, massivdagi eng kichik qiymat bo'lgan 11 tartiblangan ro'yxatning birinchi pozitsiyasida paydo bo'ladi.

image

Ikkinchi o'tish:

  • 25 mavjud bo'lgan ikkinchi pozitsiya uchun massivning qolgan qismini yana ketma-ketlikda aylantiring.

  • Ketishdan so'ng biz 12 massivdagi ikkinchi eng past qiymat ekanligini va u massivda ikkinchi o'rinda paydo bo'lishi kerakligini aniqladik, shuning uchun bu qiymatlarni almashtiring.

Uchinchi o'tish:

  • Endi, uchinchi o'rin uchun, 25 mavjud bo'lgan joyda, yana massivning qolgan qismini kesib o'ting va massivdagi uchinchi eng kam qiymatni toping.

  • Ketish paytida 22 uchinchi eng kam qiymat bo'lib chiqdi va u massivda uchinchi o'rinda paydo bo'lishi kerak, shuning uchun 22 ni uchinchi o'rindagi element bilan almashtiring.

To'rtinchi o'tish:

  • Xuddi shunday, to'rtinchi pozitsiya uchun massivning qolgan qismini kesib o'ting va massivdagi to'rtinchi eng kichik elementni toping.

  • 25 4-eng past qiymat bo'lgani uchun u to'rtinchi o'rinni egallaydi.

Beshinchi o'tish:

  • Nihoyat, massivda mavjud bo'lgan eng katta qiymat avtomatik ravishda massivning oxirgi pozitsiyasiga joylashtiriladi

  • Olingan massiv tartiblangan massivdir.

Implementation of Selection Sort

// Selection sort - massivni o'sish tartibida saralash uchun algoritm
// arr - saralash kerak bo'lgan massiv
func selectionSort(arr []int) []int {

    // Massivdan eng kiçik elementni topib, uni massivning pastki o'riniga almashtirish
    for i:=0; i<len(arr); i++{

        minIndex := i

        // Eng kichik elementi indexini topish
        for j:=i+1; j<len(arr); j++{
            if arr[j] < arr[minIndex]{
                minIndex = j
            }
        }

        // Eng kichik elementni almashtirish
        arr[i], arr[minIndex] = arr[minIndex], arr[i]
    }
    return arr
}

Complexity Analysis of Selection Sort

Time Complexity

Selection sort vaqt murakkabligi O(N^2) ga teng, chunki ikkita ichki oʻrnatilgan tsikl mavjud:

  • Massiv elementini birma-bir tanlash uchun bitta tsikl = O(N)

  • Ushbu elementni boshqa massiv elementi bilan solishtirish uchun yana bir tsikl = O(N)

  • Shuning uchun umumiy murakkablik = O(N) * O(N) = O(N*N) = O(N^2)

Space Complexity

  • O(1) qo'shimcha xotira sifatida faqat massivdagi ikkita qiymatni almashtirishda vaqtinchalik o'zgaruvchilar uchun ishlatiladi. Selection sort hech qachon O(N) almashinuvidan ko'proq narsani qilmaydi va xotirani yozish qimmat bo'lganda foydali bo'lishi mumkin.

Advantages of Selection Sort Algorithm

  • Oddiy va tushunish oson.

  • Kichik ma'lumotlar to'plamlari bilan yaxshi ishlaydi.

Disadvantages of the Selection Sort Algorithm

  • Seelction sort eng yomon va o'rtacha holatda O(n^2) vaqt murakkabligiga ega.

  • Katta ma'lumotlar to'plamlarida yaxshi ishlamaydi.

  • Teng kalitli elementlarning nisbiy tartibini saqlamaydi, bu barqaror emasligini anglatadi.

image
image
image
image

Source:

GeeksforGeeks