数据结构各类型排序算法c/c++代码实例

插入排序 

for (n = 0; n < a; n++) {
	for (m = n; m > 0; m--) {
		if (num[m] < num[m-1]) {
			num[m] = num[m] ^ num[m-1];
			num[m-1] = num[m] ^ num[m-1];
			num[m] = num[m] ^ num[m-1];
		}
	}
}

堆排序

void swap(int arr[],int a,int b)
{
	int tem = arr[a];
	arr[a] = arr[b];
	arr[b] = tem;
}

void heapInsert(int arr[],int i)
{
	while (arr[i] > arr[(i - 1) / 2]) {
		swap(arr, i, (i - 1) / 2);
		i = (i - 1) / 2;
	}
}

void heapify(int arr[],int index, int heapsize)
{
	int left = index * 2 + 1;
	while (heapsize > left)
	{
		int big = left + 1 < heapsize && arr[left] < arr[left + 1] ? left + 1 : left;
		big = arr[big] > arr[index] ? big : index;
		if (big == index) {
			break;
		}
		swap(arr, big, index);
		index = big;
		left = index * 2 + 1;
	}
}

void process(int arr[],int n) 
{
	for (int i = 0; i < n+1; i++) {
		heapInsert(arr, i);
	}
	int heapsize = n;
	swap(arr, 0, heapsize--);
	while (heapsize > 0) {
		heapify(arr, 0, heapsize+1);

归并排序

void process(int arr[], int reg[], int start, int end) {
	if (start >= end)return;
	int mid = start + ((end - start) >> 1);
	process(arr, reg, start, mid);
	process(arr, reg, mid + 1, end);
	int k = start, j = start, l = mid + 1;
	while (k <= mid && l <= end) {
		reg[j++] = arr[k] < arr[l] ? arr[k++] : arr[l++];
	}
	while (k <= mid) {
		reg[j++] = arr[k++];
	}
	while (l <= end) {
		reg[j++] = arr[l++];
	}
	for (k = start; k <= end; k++) {
		arr[k] = reg[k];
	}
	return;
}

快速排序

void process(int arr[], int p, int d) {
int a = p, b = d;
if (a >= b)return;
	while (a < b){
		while (arr[a] <= arr[p] && a <= b) a++;
		while (arr[b] >= arr[p] && a <= b) b--;
		if (a < b) {
			arr[a] = arr[a] ^ arr[b];
			arr[b] = arr[a] ^ arr[b];
			arr[a] = arr[a] ^ arr[b];
		}
	}
	if (p != b) {
		arr[p] = arr[p] ^ arr[b];
		arr[b] = arr[p] ^ arr[b];
		arr[p] = arr[p] ^ arr[b];
	}
	process(arr, p, b - 1);
	process(arr, b + 1, d);
	return;
}

冒泡排序

for (n = 0; n < a; n++) {
	for (m = 0, b = a-1; m < b; m++, b--) {
		if (num[m] > num[m + 1]) {
			num[m]=num[m] ^ num[m+1];
num[m+1]=num[m]^num[m+1];
num[m]=num[m]^num[m+1];
		}
	}
}

选择排序

for (n = 0; n < a; n++) {
	int min = n;
	for (m = n; m < a; m++) {
		if (num[m] < num[min]) {
			min = m;
		}
	}
	if (n != min) {
		num[n] = num[n] ^ num[min];
num[min] = num[n] ^ num[min];
num[n] = num[n] ^ num[min];
	}
}