冒泡思想就像愛炒股短線的人,不斷的買進賣出,操作頻繁,即使失誤不多,也會因爲操作手續費和印花稅過高而獲利很少, 那麼有種做股票的人呢,很少出手,不斷觀察和判斷,等到時機一到,果斷買進賣出.因爲交易次數少,最終受益頗豐,這就是選擇排序的思想 --大話數據結構
C語言 冒泡排序
這裏自己寫錯了 注意一下
a = a^b;
b = a^b;
a = a^b;
或者
a ^= b;
b ^= a;
a ^= b;
C語言公共代碼
void mhfPrint(int array[], int len) {
for (int i = 0; i < len; i++) {
printf("%d ", array[i]);
}
printf("\n");
}
void mhfSwap(int array[], int i, int j) {
if (i == j) return;
array[i] ^= array[j];
array[j] ^= array[i];
array[i] ^= array[j];
}
void bubbleSort(int array[], int len) {
printf("排序之前的數組: ");
mhfPrint(array, len);
for (int i = 0; i < len - 1; i++) {
int flag = true;
for (int j = len - 2; j >= i; j--) {
if (array[j] > array[j + 1]) {
mhfSwap(array, j, j + 1);
flag = false;
}
}
if (flag == true) {
break;
}
}
printf("排序之後的數組: ");
mhfPrint(array, len);
}
int main(int argc, const char * argv[]) {
int array[] = {9, 8, 7, 4, 6, 10, 5, 3, 1, 2};
int len = sizeof(array)/sizeof(int);
bubbleSort(array, len);
// 排序之前的數組: 9 8 7 6 5 4 3 2
// 排序之後的數組: 2 3 4 5 6 7 8 9
}
滿足兩兩比較相鄰記錄的冒泡排序思想,是最最簡單的交換排序, 思路是 讓每一個關鍵字都與它後面的每一個關鍵字比較,大則交換,這樣第一位置關鍵字在一次外循環後一定變成最小值.代碼中較小的元素,通過兩兩相鄰比較,如同氣泡般慢慢的浮到上面,因此爲冒泡排序.
代碼增加了flag判斷,經過改進,避免因有序的情況下的無意義循環判斷.
Swift語言 冒泡排序
class BubbleSort {
func bubbleSort(_ nums: [Int]) -> [Int] {
var nums = nums
self._bubbleSort2(&nums)
// self._bubbleSort(&nums)
return nums
}
func _bubbleSort(_ nums: inout [Int]) {
for i in 0..<nums.count {
var flag = false
// 將最小的放在了最左邊
for j in stride(from: nums.count - 2, through: i, by: -1) {
if nums[j] > nums[j + 1] {
swap(&nums, i: j, j: j + 1)
flag = true
}
}
if flag == false {
break
}
}
}
// 利用異或交換
func swap(_ nums: inout [Int], i: Int, j: Int) {
if i == j {return}
nums[i] ^= nums[j];
nums[j] ^= nums[i];
nums[i] ^= nums[j];
}
func _bubbleSort2(_ nums: inout [Int]) {
for i in 0..<nums.count {
var flag = false
// 將最大的放到最右邊
for j in 0..<nums.count - i - 1 {
if nums[j] > nums[j + 1] {
// 利用元祖交換
(nums[j], nums[j + 1]) = (nums[j + 1], nums[j])
flag = true
}
}
if flag == false {
break
}
}
}
}
冒泡排序思想就是不斷的交換,通過交換完成最終的排序; 而選擇排序的思想是內循環每一趟記錄中都只選取最小關鍵字的記錄,在走出內循環時判斷記錄是否與外循環的i不同,不同則將最小關鍵字與i進行交換,將最小關鍵字所在的位置放到i的位置.
C語言 選擇排序
void selectionSort(int array[], int len) {
printf("排序之前的數組: ");
mhfPrint(array, len);
for (int i = 0; i < len - 1; i++) {
int min = i;
for (int j = i + 1; j < len; j++) {
if (array[min] > array[j]) {
min = j;
}
}
if (min != i) {
mhfSwap(array, min, i);
}
}
printf("排序之後的數組: ");
mhfPrint(array, len);
}
int main(int argc, const char * argv[]) {
int array[] = {9, 8, 7, 6, 5, 4, 3, 2};
int len = sizeof(array)/sizeof(int);
selectionSort(array, len);
}
// 排序之前的數組: 9 8 7 6 5 4 3 2
// 排序之後的數組: 2 3 4 5 6 7 8 9
Swift語言 選擇排序
func selectionSort(_ nums: [Int]) -> [Int] {
var nums = nums
_selectionSort(&nums)
return nums
}
func _selectionSort(_ nums: inout [Int]) {
for i in 0..<nums.count {
var minIndex = i
for j in i + 1..<nums.count {
if nums[minIndex] > nums[j] {
minIndex = j
}
}
if minIndex != i {
(nums[minIndex], nums[i]) = (nums[i], nums[minIndex])
}
}
}
C語言 插入排序
void insertSort(int array[], int len) {
printf("排序之前的數組: ");
mhfPrint(array, len);
for (int i = 1; i < len; i++) {
int temp = array[i];//注意這裏是把對應的值取出來,以便後續array[i]的位置插入其他數值修改了當初的值
int j;
for (j = i - 1; j >= 0 && array[j] > temp; j--) {
array[j + 1] = array[j];// 這裏其實已經把array[i]覆蓋了,因爲j = i - 1, j+1 = i;
}
array[j + 1] = temp;// 將原來的temp值插入到合適的位置
}
printf("排序之後的數組: ");
mhfPrint(array, len);
/**
{0, 5, 3, 4, 6, 2}
打印
0 5 3 4 6 2
0 3 5 4 6 2
0 3 4 5 6 2
0 3 4 5 6 2
0 2 3 4 5 6
*/
}
插入排序算法思想：每趟將一個元素，按照其關鍵字的大小插入到它前面已經排序的子序列中，依此重複，直到插入全部元素。
Swift 語言 插入排序
func insertionSort(_ nums: [Int]) -> [Int] {
var nums = nums
self._insertionSort(&nums)
return nums
}
func _insertionSort(_ nums: inout [Int]) {
for i in stride(from: 1, to: nums.count, by: 1) {
let temp = nums[i]
var j = i - 1
while j >= 0 && nums[j] > temp {
nums[j + 1] = nums[j]
j -= 1
}
nums[j + 1] = temp
}
}
func _insertionSort2(_ nums: inout [Int]) {
for i in stride(from: 1, to: nums.count, by: 1) {
var j = i - 1
while j > 0 && nums[j] < nums[j - 1] {
(nums[j], nums[j - 1]) = (nums[j - 1], nums[j])
j -= 1
}
}
}