冒泡排序

原理:

临近的数字两两进行比较, 按照从小到大或者从大到小的顺序进行交换, 这样一趟过去之后, 最大或最小的数字被交换到了最后一位. 然后再从头开始两两进行比较, 直到倒数第二位时结束

代码

void bubbleSort(int *a, int n) {
	int exeCount = 0;
	for(int i = 0; i < n - 1; i++) {
		for(int j = 0; j < n - 1 - i; j++) {
			if (a[j] > a[j + 1]) {
				swap(a + j , a + j + 1);
			}
		}
	}
}

优化

有一个无序数列（2，1，3，4，5，6，7，8，9，10）, 从第一次循环交换后的操作，可以说都是没必要的。所以需要优化 优化方式: 设置一个标记变量, 标记数列中的数是否在循环结束前就已经排好序

优化代码

void bubbleSortBetter(int *a, int n) {
	bool isSorted = true;
	for(int i = 0; i < n - 1 && isSorted; i++) {
		isSorted = false;
		for(int j = 0; j < n - 1 - i; j++) {
			if (a[j] > a[j + 1]) {
				isSorted = true;
				swap(a + j , a + j + 1);
			}
		}
	}
}

快速排序

原理

设要排序的数组是a[0]...a[n-1], 首先任取一个数据(一般第一个元素)最为关键数据, 然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。然后对关键数据两边的数据，再分组分别进行上述的过程，直到不能再分组(只有一个数据)为止。 多个相同值的相对位置也许会在算法结束时产生变动

代码

void quickSort(int *a, int low, int high) {
        // 如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了
	if (low >= high) {
		return;
	}
	
	int first = low;
	int last = high;
	int key = a[first];
	
	while (first < last) {
		while (first < last && a[last] >= key) {
			--last;			
		}
		a[first] = a[last];
		while (first < last && a[first] <= key) {
			++first;
		}
		a[last] = a[first];		
	}	
	a[first] = key;
	quickSort(a, low, first - 1);
	quickSort(a, first + 1, high);
}

void quickSort(int *a, int low, int high) {
    
    if (low < high) {
        int pivotLoc = Partition(a, low, high);
        quickSort(a, low, pivotLoc - 1);
        quickSort(a, pivotLoc + 1, high);
    }
}

int Partition(int *a, int low, int high) {
    
    int pivotKey = a[low];
    while (low < high) {
        while (low < high && a[high] >= pivotKey) {
            --high;
        }
        a[low] = a[high];
        while (low < high && a[low] <= pivotKey) {
            ++low;
        }
        a[high] = a[low];
    }
    a[low] = pivotKey;
    return low;
}