6 commonly used sorting algorithm codes

#include <stdio.h>
int num[] = {5, 2, 8, 12, 213, 43, 0, 1, 234, 3, 6, 89, 123};//要排序的数组
//0 1 2 3 5 6 8 12 43 89 123 213 234
const int LENGTH = sizeof(num) / sizeof(int);//要排序的数组的长度
void swap(int * a, int * b);

void bubbleSort(int a[], int len);//冒泡排序
void selectionSort(int a[], int len);//选择排序
void insertionSort(int a[], int len);//插入排序

//归并排序
void mergeSort(int a[], int first, int last);
void mergeArray(int a[], int first, int mid, int last);
//快速排序
void quickSort(int a[], int first, int last);
int partitionArray(int a[], int first, int last);
//堆排序
void heapSort(int a[], int len);
void heapAdjust(int a[], int parent, int last);




void print_array(int a[], int len);

int main() {
	int len = sizeof(num) / sizeof(int);
	//bubbleSort(num, len);
	//selectingSort(num, len);
	//insertionSort(num, len);
	//mergeSort(num, 0, len - 1);
	//quickSort(num, 0, len - 1);
	heapSort(num, len);
	print_array(num, len);
  return 0;
}

//交换两个数
void swap(int * a, int * b) {
	int t;
	t = *a;
	*a = *b;
	*b = t;
}

/**
	时间复杂读O(n*n)
	空间复杂度O(1)
**/

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


/**
	时间复杂读O(n*n)
	空间复杂度O(1)
**/

void selectingSort(int a[], int len) {
  for (int i = 0; i < len; i++) {
		for (int j = i + 1; j < len; j++) {
			if (a[i] > a[j]) swap(&a[j], &a[i]);
		}
  }
}

/**
	时间复杂读O(n*n)
	空间复杂度O(1)
**/

void insertionSort(int a[], int len) {
  for (int i = 0; i < len; i++) {
		for (int j = i; j > 0; j--) {
			if (a[j] < a[j-1]) swap(&a[j], &a[j-1]);
		}
  }
}

/**
	时间复杂读O(nlog(n))
	空间复杂度O(n)
**/

void mergeSort(int a[], int first, int last) {
	if (first < last) {
		int mid = (first + last) / 2;
		mergeSort(a, first, mid);
		mergeSort(a, mid + 1, last);
		mergeArray(a, first, mid, last);
	}
}

//合并大数放前小数放后
void mergeArray(int a[], int first, int mid, int last) {
	int temp[LENGTH + 1];
	int position = 0;
	int i = first;
	int j = mid + 1;
  while (i <= mid && j <= last) {
		if (a[i] <= a[j]) temp[position++] = a[i++];
		else temp[position++] = a[j++];
  }
  while (i <= mid) temp[position++] = a[i++];
  while (j <= last) temp[position++] = a[j++];
  for (i = 0; i < position; i++) a[first++] = temp[i];
}


/**
	时间复杂读O(n*n)
	空间复杂度O(log(n))
**/
void quickSort(int a[], int first, int last) {
	if (first < last) {
		int q = partitionArray(a, first, last);
		quickSort(a, first, q - 1);
		quickSort(a, q + 1, last);
	}
}
//选取一个数他前面得数比他小后面的数比他大
int partitionArray(int a[], int first, int last) {
  int s = first;
  int e = last + 1;
  int temp = a[first];
  while (1) {
		while (s < last && a[++s] < temp);
		while (a[--e] > temp);
		if (s >= e) break;
		swap(&a[s], &a[e]);
  }
  swap(&a[first], &a[e]);
  return e;
}


/**
	时间复杂读O(nlog(n))
	空间复杂度O(1)
**/
void heapAdjust(int a[], int parent, int last) {
	int temp = a[parent];//父节点数据
	int child = parent * 2 + 1;//左孩子
	//构造大根堆
	while (child < last) {
		//选取左右孩子中最大的
    if (child + 1 < last && a[child] < a[child + 1]) child++;
    if (temp >= a[child]) break;

    a[parent] = a[child];

    //遍历更深层
    parent = child;
    child = parent * 2 + 1;

	}

	a[parent] = temp;
}

void heapSort(int a[], int len) {
	//调整堆到大根堆
	for (int i = len / 2; i >= 0; i--) {
		heapAdjust(a, i, len);
	}
	for (int i = len - 1; i > 0; i--) {
    swap(&a[0], &a[i]);
		heapAdjust(a, 0, i);
	}
}


void print_array(int a[], int len) {
	for (int i = 0; i < len; i++) {
    printf("%d ", a[i]);
	}
	printf("\n");
}