演算法：氣泡排序

本文內容：
1、什麼是氣泡排序？
2、氣泡排序的 C/OC 實現與演算法分析。

演算法總目錄：演算法？

---

1、什麼是氣泡排序？

氣泡排序：每次比較兩個相鄰的元素，如果它們的順序錯誤就把它們交換過來。

核心點 ：相鄰元素、比較、交換

氣泡排序的過程【請放大圖片，從下往上，從左往右，看】：

虛擬碼：

/*
  功能：用氣泡排序對陣列 A[0 .. n - 1] 進行排序
  輸入：一個可排序的陣列 A[0 .. n - 1]，即能夠對資料進行比較操作
  輸出：升序排列的陣列，即左小右大
  注：也可以用連結串列來代替陣列；
*/
BoubbleSort( A[0 .. n - 1] )
for i <-- 0 to n - 2 do
  for j <-- 0 to n - 2 - i do
    if A[j + 1] < A[j] swap A[j] and A[j + 1] 
複製程式碼

---

2、氣泡排序的 C/OC 實現與演算法分析。

• C 實現：

typedef enum _CompareResult {
	LESS = -1,
	SAME = 0,
	GRATER = 1,
} CompareResult;

typedef enum {
	FALSE = 0,
	TRUE = 1,
}BOOL;

typedef unsigned int uint;

typedef BOOL(*Compare)(void * array, uint idx1, uint idx2);
typedef void(*Swap)(void * array, uint idx1, uint idx2);

typedef size_t ArrayCount;

/*
	功能：利用氣泡排序原理，對資料進行重新排序
	引數 array : 要排序的陣列
	引數 count : 陣列的長度
	引數 compare : 資料的具體比較函式
	引數 swap : 資料的具體交換函式
*/
void BubbleSort(void * array, ArrayCount count, Compare compare, Swap swap) {
	if (array == NULL || compare == NULL || swap == NULL) { return; }
	for (unsigned int i = 0; i < (count - 1); i++) {
		for (unsigned int j = 0; j < (count - 1 - i); j++) {
			if (compare(array, j + 1, j)) {
				swap(array, j, j + 1);
			}
		}
	}
}
複製程式碼

// MARK: 低配版 [ 升序 ]
void BubbleSort(int *array, unsigned int count) {

	if (array == NULL || count <= 0) { return; }

    int temp = 0;
	for (unsigned int i = 0; i < (count - 1); i++) {
		for (unsigned int j = 0; j < (count - 1 - i); j++) {
			if (array[j + 1] < array[j]) {
                temp         = array[j];
                array[j]     = array[j + 1];
                array[j + 1] = temp;
			}
		}
	}

}
複製程式碼

Main 中的測試程式碼：

// 宣告
void BubbleSort(void * array, ArrayCount count, Compare compare, Swap swap);

BOOL CompareData(void * array, uint idx1, uint idx2);
void SwapData(void * array, uint idx1, uint idx2);

typedef float ElementType;
#define ARRAY_COUNT 5

int main() {
	
	ElementType array[ARRAY_COUNT] = {2, 3, 33, -2, 7};

	uint idx = 0;
	do {
		printf("Before: Array[%d] = %f\n", idx, array[idx]);
		idx++;
	} while (idx < ARRAY_COUNT);

	BubbleSort(array, ARRAY_COUNT, CompareData, SwapData);

	printf("\n");

	idx = 0;
	do {
		printf("After: Array[%d] = %f\n", idx, array[idx]);
		idx++;
	} while (idx < ARRAY_COUNT);

	// Pause
	getchar(); getchar();

	return 0;
}

// MARK: Compare & Swap

#if 0
	#define Reverse
#endif

BOOL CompareData(void * array, uint idx1, uint idx2) {

	ElementType *arr = (ElementType *)array;
	
#ifdef Reverse
	return ( (arr[idx1] > arr[idx2]) ? TRUE : FALSE );
#else
	return ((arr[idx1] < arr[idx2]) ? TRUE : FALSE);
#endif

}

void SwapData(void * array, uint idx1, uint idx2) {
	
	ElementType *arr = (ElementType *)array;

	ElementType temp = arr[idx1];
	arr[idx1] = arr[idx2];
	arr[idx2] = temp;

}
複製程式碼

測試結果：

演算法分析：

void BubbleSort(void * array, ArrayCount count, Compare compare, Swap swap) {
	if (array == NULL || compare == NULL || swap == NULL) { return; }
	for (unsigned int i = 0; i < (count - 1); i++) {
		for (unsigned int j = 0; j < (count - 1 - i); j++) {
			if (compare(array, j + 1, j)) {
				swap(array, j, j + 1);
			}
		}
	}
}
複製程式碼

解析：從實現程式碼就可以直接看出來它不是遞迴的實現方式；

1、輸入規模：count 【就是 n】 2、演算法基本操作：if (compare(array, j + 1, j)) 【先有比較再有交換】 3、是否只依賴輸入規模：compare(array, j + 1, j) 形參是 array 陣列元素、j + 1 和 j 都是屬於 [0 ~ (count - i - 1)]，而其中的 i 屬於 [0 ~ (count - 1)]，由此可知，compare 只依賴於輸入規模這個條件；所以不用考慮最差、最優、平均效率； 【觀察基本操作本身，以及基本操作的上層操作，如：那兩個 for 迴圈】 4、建立表示式並求出增長次數： 從外向裡看，第一個 for 迴圈，簡化表示有，

    for (unsigned int i = 0; i < (count - 1); i++) {
        Opreatipons();
    }
複製程式碼

那麼 Opreatipons(); 被執行的次數就是：（n - 1），當且僅當，陣列有序且第一個和第二個元素只要交換一次陣列就完成排序時，氣泡排序的時間複雜度為：Θ (n) ;

展開 Operations 有：

    for (unsigned int i = 0; i < (count - 1); i++) {
        for (unsigned int j = 0; j < (count - 1 - i); j++) {
            Ops();
        }
    }
複製程式碼

慢慢來： 當 i = 0 時，j 從 0 到 ( count - 1 - 0 ) --> ( count - 1 ) ;
當 i = 1 時，j 從 0 到 ( count - 1 - 1 ) --> ( count - 2 ) ;
... 當 i = count - 2 時，j 從 0 到 ( count - 1 - ( count - 2 ) ) --> 1;
當 i = count - 1 時，j 從 0 到 ( count - 1 - ( count - 1 ) ) --> 0;

即兩個迴圈結束後， j 的值就是從 0 一直加到 count - 1 ;就是一個等差數列：

代入公式有[ d = 1 ]： C(n) = (count - 1) * 0 + 0.5 * ((count - 1) * (count - 1 - 1)) * 1 ; C(n) = 0.5 * (count² - 3 * count + 2); 則可有氣泡排序的時間複雜度為：Θ (n²)

還有第二種分析方式：

同理的： 從外向裡看，第一個 for 迴圈，簡化表示有，

    for (unsigned int i = 0; i < (count - 1); i++) {
        Opreatipons();
    }
複製程式碼

這裡就可以有【同樣是累加】：

展開 Operations 有：

    for (unsigned int i = 0; i < (count - 1); i++) {
        for (unsigned int j = 0; j < (count - 1 - i); j++) {
            Ops();
        }
    }
複製程式碼

累加 Operations ：

又因為 Ops() 裡面我們只關心核心基本操作 if (compare(array, j + 1, j))，而這個比較的次數是一次；

即可有：

則綜上有：

現在就簡化它： 1、由【c 是指常量】

有：

2、再由

有：

3、再由

有：

4、最終簡化為：

則有氣泡排序的時間複雜度為：Θ (n²)

• Objective-C (OC) 實現： 【OC 這裡因為看不到原始碼，所以是不是冒泡演算法，就很難說，但它符合錯誤就交換這種思想】

// OC 中的 NSComparisonResult 定義：
/* typedef NS_ENUM(NSInteger, NSComparisonResult) {
  NSOrderedAscending = -1L, 
  NSOrderedSame, 
  NSOrderedDescending
};*/

typedef NSComparisonResult (*CompareObject)(id obj1, id obj2);

/*
    功能：利用氣泡排序對陣列進行重新排序
    引數 array：需要重新排序的陣列
    引數 compare：陣列元素的比較方法
    返回值：已經排好序的陣列
 */
NSArray * BubbleSort(NSArray *array, CompareObject compare) {

    if (compare == NULL) { return array; }
    
    NSArray *sorted = [array sortedArrayUsingComparator:^NSComparisonResult(id  _Nonnull obj1, id  _Nonnull obj2) {
        
        return compare(obj1, obj2);
        
    }];
    
    return sorted;
    
}

// MARK: 低配版（升序）
NSArray * BubbleSort(NSArray *array, CompareObject compare) {

    if (compare == NULL) { return array; }
    
    NSMutableArray *sorted = [array mutableCopy];
    NSUInteger count = sorted.count;

    for (NSUInteger i = 0; i < ( count - 1); i++) {

        for (NSUInteger j = 0; j < ( count - 1 - i ); j++) {

            id obj1 = [sorted objectAtIndex:j];
            id obj2 = [sorted objectAtIndex:(j + 1)];

            if (compare(obj1, obj2) == NSOrderedAscending ) {
                [sorted exchangeObjectAtIndex:j withObjectAtIndex:(j + 1)];
            }

        }

    }

    return sorted.copy;
    
}
複製程式碼

Main 中的測試程式碼：

NSArray * BubbleSort(NSArray *array, CompareObject compare);

NSComparisonResult CompareData(id obj1, id obj2);

// MARK: Main

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        
        NSArray *willSortedArr = @[@(23), @(3), @(55), @(-3), @(88)];
        
        NSArray *sortedArr = BubbleSort(willSortedArr, CompareData);
        
        NSLog(@"\n\r WillSortedArr : %@; \n\r SortedArray : %@", willSortedArr, sortedArr);
        
    }
    return 0;
}

// MARK: Compare Function

// 預設是升序，開啟 Reverse 就直接變成降序
#if 1
    #define Reverse
#endif

NSComparisonResult CompareData(id obj1, id obj2) {
    
    NSNumber *n1 = (NSNumber *)obj1;
    NSNumber *n2 = (NSNumber *)obj2;
    
#ifdef Reverse
    if ([n1 integerValue] < [n2 integerValue]) { return NSOrderedAscending; }
    
    return NSOrderedDescending;
#else
    if ([n1 integerValue] < [n2 integerValue]) { return NSOrderedDescending; }
    
    return NSOrderedAscending;
#endif
    
}
複製程式碼

執行結果：

---

參考書籍/文章：
書籍：《演算法設計與分析基礎 美 萊維汀 第3版》
書籍：《啊哈！演算法》

文章：常用的累加∑公式

---

如有錯漏，還望指出，不勝感激！