八大排序算法代码实现

排序算法分支图

各大排序算法分析

排序方法	时间复杂度（平均情况）	（最好情况）	（最坏情况）	空间复杂度	稳定性
冒泡排序	O(n²)	O(n²)	O(n)	O(1)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n²)	O(nlogn)	不稳定
选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
插入排序	O(n²)	O(n)	O(n²)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
希尔排序	O(n的1.3次方)	O(n)	O(n²)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
基数排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	稳定

冒泡排序

void sort(vector<int>& a)
{
	int n = a.size(), temp;
	for (int i = 0; i < n; i++) {
		for (int j = i; j < n; j++) {
			if (a[i] > a[j]) {
				temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
		}
	}
}

快速排序

void sort(vector<int>& a, int i, int j)
{
	if (i >= j) return;
	else {
		int k = a[i], x = i, y = j;
		while (x < y) {
			while (a[y] > k && x < y) y--;
			a[x] = a[y];
			while (a[x] < k && x < y) x++;
			a[y] = a[x];
		}
		a[x] = k;
		sort(a, i, x - 1);
		sort(a, x + 1, j);
	}
}

选择排序

void sort(vector<int>& a)
{
	int n = a.size(), temp, min;
	for (int i = 0; i < n - 1; i++) {
		min = i;
		for (int j = i + 1; j < n; j++) {
			if (a[j] < a[min]) min = j;
		}
		temp = a[i];
		a[i] = a[min];
		a[min] = temp;
	}
}

插入排序

void sort(vector<int>& a)
{
	int n = a.size(), temp;
	for (int i = 1; i < n; i++) {
		for (int j = i; j > 0; j--) {
			if (a[j] < a[j - 1]) {
				temp = a[j];
				a[j] = a[j - 1];
				a[j - 1] = temp;
			}
			else break;
		}
	}
}

归并排序

void mergearray(vector<int>& a, int left, int mid, int right, vector<int>& b) //治
{
	int i = left, j = mid + 1, k = 0;
	while (i <= mid && j <= right) {
		if (a[i] <= a[j]) {
			b[k++] = a[i++];
			continue;
		}
		b[k++] = a[j++];
	}
	while (i <= mid) b[k++] = a[i++];
	while (j <= right) b[k++] = a[j++];
	for (int i = left; i <= right; i++) a[i] = b[i-left];
}
void MergeSort(vector<int>& a, int left, int right, vector<int>& b) //分
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		MergeSort(a, left, mid, b);
		MergeSort(a, mid + 1, right, b);
		mergearray(a, left, mid, right, b);
	}
}
void sort(vector<int>& a)
{
	int n = a.size();
	vector<int> b(n);
	MergeSort(a, 0, n - 1, b);
}

希尔排序

void sort(vector<int>& a)
{
	int n = a.size(), temp;
	for (int i = n / 2; i >= 1; i /= 2) { //增量
		for (int j = 0; j < i; j++) {  //每一增量对应的所需循环次数
			for (int k = i + j; k < n; k += i) {
				for (int l = k; l > j; l -= i) {
					if (a[l] < a[l - i]) {
						temp = a[l];
						a[l] = a[l - i];
						a[l - i] = temp;
 					}
					else break;
				}
			}
		}
	}
}

堆排序

void adjustheap(vector<int>& a, int node, int len) //调节堆
{
	int index = node, temp;
	int child = 2 * index + 1;
	while (child < len) {
		if (child + 1 < len && a[child] < a[child + 1]) {
			child++;
		}
		if (a[index] >= a[child]) break;
		temp = a[index];
		a[index] = a[child];
		a[child] = temp;
		index = child;
		child = 2 * index + 1;
	}
}
void makeheap(vector<int>& a) //建堆
{
	for (int i = a.size() / 2; i >= 0; i--) {
		adjustheap(a, i, a.size());
	}
}
void sort(vector<int>& a)
{
	makeheap(a);
	int temp;
	for (int i = a.size() - 1; i >= 0; i--) { //排序
		temp = a[i];
		a[i] = a[0];
		a[0] = temp;
		adjustheap(a, 0, i);
	}
}

基数排序

int GetMaxDight(int* h, int len)
{
    if(h==NULL) return 0;
    if(len<1) return 0;

    int max=h[0];
    for(int i=1;i<len;++i)
    {
        if(h[i]>max) max=h[i];
    }

    int digit=1;
    while(max/10!=0)
    {
        max/=10;
        ++digit;
    }

    return digit;
}

int GetReminder(int value,int digit)
{
    int div=1;
    for(int i=1;i<digit;++i)
        div*=10;

    return value/div%10;
}

void RadixSort_LSD(int* h, int len)
{
    if(h==NULL) return;
    if(len<=1) return;

    int digit=GetMaxDight(h,len);
    //printf("MaxDigit:%d\n", digit);

    int count[10]={0};
    int *tmp=(int*)calloc(len,sizeof(int));

    for(int d=1;d<=digit;++d)
    {
        memset(count,0,sizeof(count));

        for(int i=0;i<len;++i)
        {
            count[GetReminder(h[i],d)]++;
        }

        //求右边界
        for(int i=1;i<10;++i)
        {
            count[i]+=count[i-1];
        }

        for(int i=len-1;i>=0;--i)
        {
            int r=GetReminder(h[i],d);
            int index=count[r];
            tmp[index-1]=h[i];
            count[r]--;
        }

        memcpy(h,tmp,len*sizeof(int));
    }

    free(tmp);
}

void RadixSort_LSD_Reverse(int* h, int len)
{
    if(h==NULL) return;
    if(len<=1) return;

    int digit=GetMaxDight(h,len);
    //printf("MaxDigit:%d\n", digit);

    int count[10]={0};

    int *tmp=(int*)calloc(len,sizeof(int));

    for(int d=1;d<=digit;++d)
    {
        memset(count,0,sizeof(count));

        for(int i=0;i<len;++i)
        {
            count[GetReminder(h[i],d)]++;
        }

        //printf("haha\n");

        //求右边界
        for(int i=8;i>=0;--i)
        {
            count[i]+=count[i+1];
        }



        for(int i=len-1;i>=0;--i)
        {
            int r=GetReminder(h[i],d);
            int index=count[r];
            tmp[index-1]=h[i];
            count[r]--;
        }

        memcpy(h,tmp,len*sizeof(int));
    }

    free(tmp);
}