1、不用中間變數，變換A和B的值

// 1.中間變數
void swap(int a, int b) {
   int temp = a;
   a = b;
   b = temp;
}

// 2.加法
void swap(int a, int b) {
   a = a + b;
   b = a - b;
   a = a - b;
}

// 3.異或（相同為0，不同為1. 可以理解為不進位加法）
void swap(int a, int b) {
   a = a ^ b;
   b = a ^ b;
   a = a ^ b;
}

/** 1.直接遍歷法 */
int maxCommonDivisor(int a, int b) {
    int max = 0;
    for (int i = 1; i <=b; i++) {
        if (a % i == 0 && b % i == 0) {
            max = i;
        }
    }
    return max;
}
/** 2.輾轉相除法 */
int maxCommonDivisor(int a, int b) {
    int r;
    while(a % b > 0) {
        r = a % b;
        a = b;
        b = r;
    }
    return b;
}

// 擴充套件：最小公倍數 = (a * b)/最大公約數
 

 /**
 *  棧是一種資料結構，特點：先進後出
 *  練習：使用全域性變數模擬棧的操作
 */
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
//保護全域性變數：在全域性變數前加static後，這個全域性變數就只能在本檔案中使用
static int data[1024];//棧最多能儲存1024個數據
static int count = 0;//目前已經放了多少個數(相當於棧頂位置)

//資料入棧 push
void push(int x){
  	assert(!full());//防止陣列越界
	data[count++] = x;
}
//資料出棧 pop
int pop(){
	assert(!empty());
	return data[--count];
}
//檢視棧頂元素 top
int top(){
	assert(!empty());
	return data[count-1];
}

//查詢棧滿 full
bool full() {
	if(count >= 1024) {
     	return 1;
	}
     return 0; 
}

//查詢棧空 empty
bool empty() {
	if(count <= 0) {
		return 1;
	}
    return 0;
}

int main(){
    //入棧
    for (int i = 1; i <= 10; i++) {
        push(i);
    }
  
    //出棧
    while(!empty()){
        printf("%d ", top()); //棧頂元素
        pop(); //出棧
    }
    printf("\n");
    
    return 0;
}
 

選擇排序、氣泡排序、插入排序三種排序演算法可以總結為如下：

都將陣列分為已排序部分和未排序部分。

1. 選擇排序將已排序部分定義在左端，然後選擇未排序部分的最小元素和未排序部分的第一個元素交換。
2. 氣泡排序將已排序部分定義在右端，在遍歷未排序部分的過程執行交換，將最大元素交換到最右端。
3. 插入排序將已排序部分定義在左端，將未排序部分元的第一個元素插入到已排序部分合適的位置。

選擇排序

/** 
 *	【選擇排序】：最值出現在起始端
 *	
 *	第1趟：在n個數中找到最小(大)數與第一個數交換位置
 *	第2趟：在剩下n-1個數中找到最小(大)數與第二個數交換位置
 *	重複這樣的操作...依次與第三個、第四個...數交換位置
 *	第n-1趟，最終可實現資料的升序（降序）排列。
 *
 */
void selectSort(int *arr, int length) {
    for (int i = 0; i < length - 1; i++) { //趟數
        for (int j = i + 1; j < length; j++) { //比較次數
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

氣泡排序

/** 
 *	【氣泡排序】：相鄰元素兩兩比較，比較完一趟，最值出現在末尾
 *	第1趟：依次比較相鄰的兩個數，不斷交換（小數放前，大數放後）逐個推進，最值最後出現在第n個元素位置
 *	第2趟：依次比較相鄰的兩個數，不斷交換（小數放前，大數放後）逐個推進，最值最後出現在第n-1個元素位置
 *	 ……   ……
 *	第n-1趟：依次比較相鄰的兩個數，不斷交換（小數放前，大數放後）逐個推進，最值最後出現在第2個元素位置	
 */
void bublleSort(int *arr, int length) {
    for(int i = 0; i < length - 1; i++) { //趟數
        for(int j = 0; j < length - i - 1; j++) { //比較次數
            if(arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        } 
    }
}

折半查詢（二分查詢）

/**
 *	折半查詢：優化查詢時間（不用遍歷全部資料）
 *
 *	折半查詢的原理：
 *   1> 陣列必須是有序的
 *   2> 必須已知min和max（知道範圍）
 *   3> 動態計算mid的值，取出mid對應的值進行比較
 *   4> 如果mid對應的值大於要查詢的值，那麼max要變小為mid-1
 *   5> 如果mid對應的值小於要查詢的值，那麼min要變大為mid+1
 *
 */ 

// 已知一個有序陣列, 和一個key, 要求從陣列中找到key對應的索引位置 
int findKey(int *arr, int length, int key) {
    int min = 0, max = length - 1, mid;
    while (min <= max) {
        mid = (min + max) / 2; //計算中間值
        if (key > arr[mid]) {
            min = mid + 1;
        } else if (key < arr[mid]) {
            max = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
}