冒泡排序, 选择排序, 插入排序(c + swift)

冒泡思想就像爱炒股短线的人,不断的买进卖出,操作频繁,即使失误不多,也会因为操作手续费和印花税过高而获利很少, 那么有种做股票的人呢,很少出手,不断观察和判断,等到时机一到,果断买进卖出.因为交易次数少,最终受益颇丰,这就是选择排序的思想 --大话数据结构

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
           }
       }
   }