数据结构期末复习排序算法实现（C++版）

0x01. 冒泡排序

void bubbleSort(int arr[],int len) {				//len为数组长度
	//冒泡排序核心算法
	for (int i = 0; i < len-1; i++) {				//i表示冒泡轮数
		for (int j = 0; j < len - i-1; j++) {
			if (arr[j] > arr[j+1]) {
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
}

冒泡排序优化

void bubbleSort_pro(int arr[], int len) {
	bool isSort = true;
	
		for (int i = 0; i < len - 1; i++) {				//i表示冒泡轮数
			for (int j = 0; j < len - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					isSort = false;
				}
			}
			if (isSort) {
				break;
			}
		}
}

0x02. 选择排序

void selectSort(int arr[], int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = i + 1; j < len; j++) {
			if (arr[i] > arr[j]) {
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

0x03. 插入排序

void insertionSort_pro(int arr[], int len) {
	int i = 0;
	int j = 0;
	
	for (i = 1; i < len; i++) {
		if (arr[i] < arr[i - 1]) {
			int value = arr[i];
			for (j = i - 1; arr[j] > value && j >= 0; j--) {
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = value;
		}
	}
}

0x04. 希尔排序

//希尔排序
void shellSort(int arr[], int len) {
	int gap = 1;
	while (gap < len) {
		gap = gap * 3 + 1;
	}
	while (gap > 0) {
		for (int i = gap; i < len; i++) {
			int tmp = arr[i];
			int j = i - gap;
			while (j >= 0 && arr[j] > tmp) {
				arr[j + gap] = arr[j];
				j -= gap;
			}
			arr[j + gap] = tmp;
		}
		gap = gap / 3;
	}
/*直接对插入排序改写
int i = 0;
	int j = 0;
	int flag = 0;
	int gap = len;
	while (gap > 1) {
		gap = gap / 3 + 1;
		for (i = gap; i < len; i++) {
			flag = arr[i];
			if (arr[i] < arr[i - gap]) {
				for (j = i - gap; arr[j] > flag&& j >= 0; j -= gap) {
					arr[j + gap] = arr[j];
				}
				arr[j + gap] = flag;
			}
		}
	}
*/

}

0x05. 快速排序

//快速排序
int get_index(int* arr, int left, int right) {				//获取中轴下标函数
	int pivot = arr[left];									//默认第一个为中轴			
	while (left < right) {
		while (arr[right] > pivot&& left < right) {			//首先移动right，如果右边的数大于中轴就不移动
			right--;
		}
		arr[left] = arr[right];								//如果右边的数小于中轴，就移动到中轴左边，之后移动left
		while (arr[left] < pivot && left < right) {			//如果左边边的数小于中轴就不移动
			left++;
		}
		arr[right] = arr[left];								//如果左边的数大于于中轴，就移动到中轴右边
	}
	arr[left] = pivot;
	return left;
}


void quickSort(int* arr, int left, int right) {
	if (left < right) {
		int index = get_index(arr, left, right);			//调用找中轴函数，
		quickSort(arr, left, index - 1);					//确定好中轴后，对中轴左边进行快速排序
		quickSort(arr, index+1, right);						//确定好中轴后，对中轴右边进行快速排序

	}
}

0x06. 归并排序

void merge(int arr[], int left, int mid, int right) {
	int i = 0;
	int j = 0;
	int k = 0;
	int len = sizeof(arr) / sizeof(int);
	int* temp = (int*)malloc((len)* sizeof(int));				//辅助数组
	for (int k = left; k <= right; k++) {
		temp[k] = arr[k];				//将arr中所有元素复制到temp中
	}
	for (i = left, j = mid + 1, k = i; i <= mid && j <= right; k++) {
		if (temp[i] < temp[j]) {				//比较temp的左右两端中的元素
			arr[k] = temp[i++];					//将较小的值复制到arr中
		}
		else {
			arr[k] = temp[j++];
		}
	}//for
	while (i <= mid) {				//若第一个表没有检测完，复制
		arr[k++] = temp[i++];
	}
	while (j < right) {				//若第二个表没有检测完，复制
		arr[k++] = temp[j++];
	}
}
 
void mergeSort(int arr[], int low, int high) {
	if (low >= high) {
		return;
	}
	int mid = low + (high - low) / 2;				//从中间划分两个子序列

	mergeSort(arr, low, mid);						//对左侧子序列进行递归排序
	mergeSort(arr, mid + 1, high);					//对右侧子序列进行递归排序
	merge(arr, low, mid, high);						//归并
}

0x07. 堆排序

//堆排序
void adjustDown(int arr[], int k, int len) {				//向下调整堆
	//函数adjustDown 将元素k向下进行调整
	arr[0] = arr[k];				//arr[0] 暂存
	for (int i = 2 * k; i <= len; i *= 2) {			//沿key较大的子节点向下筛选
		if (i < len && arr[i] < arr[i + 1]) {
			i++;				//取key较大的子节点下标
		}
		if (arr[0] > arr[i]) {				//筛选结束
			break;
		}
		else {
			arr[k] = arr[i];		//将arr[i] 调整到双亲节点上
			k = i;					//修改k值，以便继续向下筛选
		}
	}//for
	arr[k] = arr[0];				//被筛选的节点的值放入最终位置

}

void adjustUp(int arr[], int k) {
	//参数k为向上调整的节点，也为堆元素的个数
	arr[0] = arr[k];
	int i = k / 2;				//若节点的值大于双亲节点，则双亲节点向下调，并继续向上比较
	while (i > 0 && arr[i] < arr[0]) {
		arr[k] = arr[i];				//双亲节点下调
		k = i;
		i = k / 2;				//继续向上比较
	}//while
	arr[k] = arr[0];				//复制到最终位置
}
void buildMaxHeap(int arr[], int len) {
	for (int i = len / 2; i > 0; i--) {				//从i=[n/2] ~ 1, 反复调整堆
		adjustDown(arr, i, len);
	}
}

void heapSort(int arr[], int len) {
	buildMaxHeap(arr, len);				//初始建立堆
	for (int i = len; i > 1; i--) {
		swap(arr[i], arr[1]);
		adjustDown(arr, 1, i - 1);
	}//for

}