الگوریتم های مرتب سازی در سوئیفت (Swift) — به زبان ساده

1//array of unsorted integers
2let numberList : Array<Int> = [8, 2, 10, 9, 7, 5]

1extension Array where Element: Comparable {
2 
3 func insertionSort() -> Array<Element> {
4        
5        //check for trivial case
6        guard self.count > 1 else {
7            return self
8        }
9        
10        //mutated copy        
11        var output: Array<Element> = self
12        
13        for primaryindex in 0..<output.count {
14            
15            let key = output[primaryindex]
16            var secondaryindex = primaryindex
17            
18            while secondaryindex > -1 {
19                if key < output[secondaryindex] {
20                    
21                    //move to correct position
22                    output.remove(at: secondaryindex + 1)
23                    output.insert(key, at: secondaryindex)
24                }
25                
26                secondaryindex -= 1
27            }            
28        }
29        
30        return output        
31    }   }
32//execute sort
33let results: Array<Int> = numberList.insertionSort()

1extension Array where Element: Comparable {
2func bubbleSort() -> Array<Element> {
3                
4        //check for trivial case
5        guard self.count > 1 else {
6            return self
7        }
8                
9        //mutated copy
10        var output: Array<Element> = self        
11        
12        for primaryIndex in 0..<self.count {                        
13            let passes = (output.count - 1) - primaryIndex
14                        
15            //"half-open" range operator
16            for secondaryIndex in 0..<passes {                
17                let key = output[secondaryIndex]                                
18                
19                //compare / swap positions
20                if (key > output[secondaryIndex + 1]) {
21                  output.swapAt(secondaryIndex, secondaryIndex + 1)
22                }
23            }
24        }
25                
26        return output        
27    }
28}
29//execute sort
30let results: Array<Int> = numberList.bubbleSort()

1extension Array where Element: Comparable {
2func selectionSort() -> Array<Element> {     
3        
4        //check for trivial case
5        guard self.count > 1 else {
6            return self
7        }        
8        
9        //mutated copy
10        var output: Array<Element> = self
11                
12        for primaryindex in 0..<output.count {
13                        
14            var minimum = primaryindex
15            var secondaryindex = primaryindex + 1
16                        
17            while secondaryindex < output.count {
18         
19          //store lowest value as minimum
20                if output[minimum] > output[secondaryindex] {
21                    minimum = secondaryindex
22                }                
23                secondaryindex += 1
24            }
25            
26            
27            //swap minimum value with array iteration
28            if primaryindex != minimum {
29            output.swapAt(primaryindex, minimum)
30            }            
31        }
32                
33        return output        
34    }
35}
36//execute sort
37let results: Array<Int> = numberList.selectionSort()