swift中的排序算法總結(jié)
- 冒泡排序
- 選擇排序
- 快速排序
- 插入排序
- 堆排序
- 歸并排序
- 系統(tǒng)排序
我們將這幾種數(shù)組排序?qū)戇M(jìn)Array的分類里面方便調(diào)用
冒泡排序
算法步驟
1．比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2．對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。在這一點(diǎn)，最后的元素應(yīng)該會是最大的數(shù)。
3．針對所有的元素重復(fù)以上的步驟，除了最后一個。
4.持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。
//冒泡排序
mutating func bubbleSort() {
for i in 0..<self.count {
for j in 0..<self.count - 1 - i {
if max(self[j], self[j+1]){
(self[j],self[j+1]) = (self[j+1],self[j])
}
}
}
}
算法原理圖
選擇排序
算法步驟
設(shè)數(shù)組為a[0…n-1]。
1.初始時，數(shù)組全為無序區(qū)為a[0..n-1]。令i=0
2.在無序區(qū)a[i…n-1]中選取一個最小的元素，將其與a[i]交換。交換之后a[0…i]就形成了一個有序區(qū)。
3.i++并重復(fù)第二步直到i==n-1。排序完成
//選擇排序（選擇最小元素）
mutating func selectSort() {
for i in 0..<self.count {
var min = i
for j in i+1..<self.count {
if max(self[min], self[j]){
min = j
}
}
(self[min],self[i]) = (self[i],self[min])
}
}
算法原理圖
快速排序
算法步驟
1.設(shè)置兩個變量i、j，排序開始的時候：i=0，j=N-1；
2.以第一個數(shù)組元素作為關(guān)鍵數(shù)據(jù)，賦值給key，即key=A[0]；
3.從j開始向前搜索，即由后開始向前搜索(j--)，找到第一個小于key的值A(chǔ)[j]，將A[j]和A[i]互換；
4.從i開始向后搜索，即由前開始向后搜索(i++)，找到第一個大于key的A[i]，將A[i]和A[j]互換；
5.重復(fù)第3、4步，直到i=j；
//快速排序
mutating func qkSort(left:Int,right:Int) {
if left >= right {
return
}
var i = left
var j = right
let temp = self[left]
while i < j {
while i<j && temp <= self[j] {
j -= 1
}
self[i] = self[j]
while i<j && temp >= self[i] {
i += 1
}
self[j] = self[i]
}
self[i] = temp
qkSort(left: left,right: i-1)
qkSort(left: i+1, right: right)
}
算法原理圖
插入排序
算法步驟
設(shè)數(shù)組為a[0…n-1]。
1.初始時，a[0]自成1個有序區(qū)，無序區(qū)為a[1..n-1]，令i=1；
2.將a[i]并入當(dāng)前的有序區(qū)a[0…i-1]中形成a[0…i]的有序區(qū)間；
3.i++并重復(fù)第二步直到i==n-1。排序完成。
//插入排序
mutating func insertionSort() {
for index in 1..<self.count {
var newArrCount = index - 1
let keyArr = self[index]
while newArrCount >= 0 && self[newArrCount] > keyArr {
self[newArrCount+1] = self[newArrCount]
newArrCount -= 1
}
self[newArrCount+1] = keyArr
}
}
算法原理圖
堆排序
算法步驟
1.先將初始文件R[1..n]建成一個大根堆，此堆為初始的無序區(qū)；
2.再將關(guān)鍵字最大的記錄R[1]（即堆頂）和無序區(qū)的最后一個記錄R[n]交換，由此得到新的無序區(qū)R[1..n-1]和有序區(qū)R[n]，且滿足R[1..n-1].keys≤R[n].key；
3.由于交換后新的根R[1]可能違反堆性質(zhì)，故應(yīng)將當(dāng)前無序區(qū)R[1..n-1]調(diào)整為堆。然后再次將R[1..n-1]中關(guān)鍵字最大的記錄R[1]和該區(qū)間的最后一個記錄R[n-1]交換，由此得到新的無序區(qū)R[1..n-2]和有序區(qū)R[n-1..n]，且仍滿足關(guān)系R[1..n-2].keys≤R[n-1..n].keys，同樣要將R[1..n-2]調(diào)整為堆。；
……
直到無序區(qū)只有一個元素為止。
//堆排序
mutating func heapSort() {
//建立滿足條件的堆
func heapAdjust(index:Int,length:Int) {
var temp = index
if 2*index + 1 < length && !max(self[index], self[2*index+1]){
temp = 2*index + 1
}
if 2*index + 2 < length && !max(self[temp] , self[2*index + 2]) {
temp = 2*index + 2
}
if index != temp {
(self[temp],self[index]) = (self[index],self[temp])
heapAdjust(index: temp, length: length)
}
}
//先建立個堆
var length = self.count
var index = length/2 - 1
while index >= 0 {
heapAdjust(index: index, length: length)
index -= 1
}
length = self.count - 1
var nextCount = length
//調(diào)整堆
for _ in 0..<self.count - 1 {
(self[0],self[nextCount]) = (self[nextCount],self[0])
heapAdjust(index: 0, length: nextCount)
nextCount -= 1
}
}
算法原理圖
歸并排序
算法步驟
1.比較a[i]和a[j]的大小，若a[i]≤a[j]，則將第一個有序表中的元素a[i]復(fù)制到r[k]中，并令i和k分別加上1；
2.否則將第二個有序表中的元素a[j]復(fù)制到r[k]中，并令j和k分別加上1；
3.如此循環(huán)下去，直到其中一個有序表取完，然后再將另一個有序表中剩余的元素復(fù)制到r中從下標(biāo)k到下標(biāo)t的單元。
//歸并排序
mutating func mergeSort() {
var temArr = self
//合并數(shù)組
func mergingArr(_ startIndex: Int,_ midIndex:Int,_ lastIndex:Int) {
var i = startIndex
var j = midIndex + 1
let k = lastIndex
let m = midIndex
var n = 0
while i <= m&&j <= k {
if max(self[i], self[j]) {
temArr[n] = self[j]
j += 1
n += 1
}else {
temArr[n] = self[i]
i += 1
n += 1
}
}
while i <= m {
temArr[n] = self[i]
i += 1
n += 1
}
while j <= k {
temArr[n] = self[j]
j += 1
n += 1
}
for index in 0..<n {
self[startIndex + index] = temArr[index]
}
}
//分離數(shù)組
func separateArr(_ startIndex: Int, _ endIndex: Int) {
if startIndex < endIndex {
let mid = (startIndex + endIndex)/2
separateArr(startIndex, mid)
separateArr(mid+1, endIndex)
mergingArr(startIndex, mid, endIndex)
}
}
separateArr(0, self.count-1)
}
算法原理圖
系統(tǒng)方法排序（sort）
sort方法在與其他方法作比較時，無論是運(yùn)行次數(shù)還是效率都是最優(yōu)的，看下他的運(yùn)行時間的效果圖吧（由于看不到方法怎么實(shí)現(xiàn)的，所以無法演示原理）
幾種排序算法比較
如下圖所示，分別從時間復(fù)雜度、空間復(fù)雜度和穩(wěn)定性來比較。
注意
- swift中數(shù)組在改變數(shù)組內(nèi)元素值時，如果是調(diào)用方法改變數(shù)組內(nèi)元素，則無法監(jiān)聽
- swift中在調(diào)用方法改變數(shù)組內(nèi)元素值時，方法體中如果再嵌套一個方法改變這個數(shù)組值時則這個數(shù)組的地址會改變當(dāng)整個方法結(jié)束時，才會把改變了地址的數(shù)組賦值給原來地址的數(shù)組。
最后
點(diǎn)擊觀看完整代碼地址
（轉(zhuǎn)載請說明出處，編寫代碼不易如對您有用請點(diǎn)贊，謝謝支持！）
