排序算法2—归并、快速排序

4、归并排序

https://blog.csdn.net/left_la/article/details/8656953

最好、最坏、平均时间性能都为O(nlogn）

空间复杂度O(n+logn)

归并排序是一种占用内存，但效率高且稳定的算法

//归并排序
void Merge(int *a, int p, int q, int r)
{
	//1、分配空间
	int n1 = q - p + 1;
	int n2 = r - q;
	int *L = new int[n1];
	int *R = new int[n2];

	//2、赋值,分成了两个数组
	int i, j, k;
	for (i = 0; i < n1; i++)
		L[i] = a[p + i];
	for (j = 0; j < n2; j++)
		R[j] = a[q + j + 1];

	//3、排序合并
	for (i = 0, j = 0, k = p; k <= r; k++)
	{
		if (L[i] <= R[j])
		{
			a[k] = L[i];
			i++;
		}
		else
		{
			a[k] = R[j];
			j++;
		}
	}
	//释放内存
	delete[]L;
	delete[]R;
}
void MergeSort(int *a, int p, int r)
{
	if ((r - p) >= 50) // 小于50个数据的数组进行插入排序
	{
		int q = (p + r) / 2;
		MergeSort(a, p, q);
		MergeSort(a, q + 1, r);
		Merge(a, p, q, r);
	}
	else
	{
		InsertSort(a + p, r - p + 1);
	}
}

5、快速排序

https://blog.csdn.net/qq_33611947/article/details/84562988

最好的情况下：时间复杂度为O(nlogn），空间复杂度为O(logn)

最差的情况（正序或逆序）下：时间复杂度为O(n*n）,空间复杂度为O(n)

平均的情况下：时间复杂度为O(nlogn）,空间复杂度为O(logn)

int partition(int a[], int p, int r)
{
    int flag = a[r];
    int i = p - 1;
    for (int j = p; j < r; j++)
    {
        if (a[j] <= flag)
        {
            i = i + 1;
            Swap(a[i], a[j]);
        }
    }
    Swap(a[i + 1], a[r]);
 
    return (i+1);
}
 
 
void quick_sort(int a[], int p,int r)
{
    int q;
    if (p < r)
    {
        q=partition(a, p, r);
        quick_sort(a, p, q - 1);
        quick_sort(a, q, r);
    }
 
}