【上机代码】函数调用栈，快速排序与归并排序

函数调用栈

内存四区

现代的应用程序都运行在一个虚拟内存空间里，在32位的系统里，这个内存空间拥有4GB的寻址能力。整个内存是一个统一的地址空间，程序可以直接使用32位的地址进行寻址，用户可以使用一个32位的指针访问任意内存位置。
当进程被加载到内存时，会被分成很多段；根据内存使用情况的不同可以粗略的分为四个区：代码区、全局区、堆区和栈区。前两者主要在程序编译后，代码执行前起作用。后两者主要在代码执行过程中起作用。

1,程序编译后，代码执行前
代码区：存放二进制的代码数据
全局区：存放全局变量（常量、字符串常量和其他常量；三种又分布在各自的小区域）、静态变量；全局区在程序结束后系统自动释放。

2，代码执行时
栈区：存放局部变量，函数参数，当前状态，函数调用信息等;程序自动分配释放

堆区：由程序员分配释放，C语言可以利用malloc和free在堆区开辟、释放内存空间；程序员不释放，程序结束时自动释放。

//定义一个堆区数组
int *p = (int*)malloc(sizeof(int)*5);
free(p);

函数调用栈

代码中的函数，是在栈区运行的，随着程序运行，函数依次被压入栈中，执行结束后出栈。特别是在递归中有很大的作用。
下面举例说明：

def Fact(x):
  if x == 1:
    return 1
  else:
    return x * Fact(x-1)
int a;    
a=Fact(3)

递归可以分为压栈和出栈两个阶段：

运行Fact(3)函数，将Fact(3)压入栈中
运行到Fact(3)中的return x * Fact(x-1)时，将Fact(x-1)也就是Fact(2)压入栈中；
同理在Fact(2)中也会将Fact(1)入栈。

执行Fact(1)时，不再满足条件x!=1；Fact(1)结束，并返回值到Fact(2)；

Fact(2)中继续执行x * Fact(1)，返回到x * Fact(3)，并结束Fact(2)

Fact(3)中继续执行x * Fact(2)，返回值给a；此时栈中无函数结束运行，最终结果为a=6.

快速排序

下面以快速排序为例介绍函数调用栈在其中的应用。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void print(int A[], int length)
{
	for (int i = 0; i < length; ++i)
	{
		printf("%d ", A[i]);
	}
}
//partition实现从low和high向中间扫描序列，以low指向的元素为基准，将序列分为两个部分，基准在中间，左边所有元素小于基准，右边所有元素大于等于基准。
//返回基准值，和排序好的序列
int partition(int A[], int low, int high)
{
	int pivot = A[low];
	while (low < high) {
		while (low < high && A[high] >= pivot)
			--high;
		A[low] = A[high];
		while (low < high && A[low] <= pivot)
			++low;
		A[high] = A[low];
	}
	A[low]= pivot;
	return low;
}
//基于递归实现，先按基准排序，然后分别递归处理基准左右的子表，子表长度>1时就继续划分，直到所有子表被处理完毕。
void QuickSort(int A[], int low, int high) {
	if (low < high) {
		int pivotpos = partition(A, low, high);
		QuickSort(A, low, pivotpos - 1);
		QuickSort(A, pivotpos + 1, high);
	}
}

void test()
{
	int A[10];
	int length = sizeof(A) / sizeof(A[0]);
	for (int i = 0; i < length; ++i)
	{
		A[i]= rand() % 100;//取0-99的随机数  0-99，都为原值，100-199为0-99，以此类推

	}
	printf("原始序列为：\n");
	print(A, length);
	QuickSort(A, 0, length-1);
	printf("\n排序后为：\n");
	print(A, length);
}


int main()
{
	test();
}

初始序列为[49 38 65 97 76 13 27 49]
QuickSort（）函数对0-7处理，low<high，先执行pivotpos（）函数对0-7处理。
以49为基准，排序后的序列为[27 38 13 49 76 97 65 49]

递归调用QuickSort(A,low,pivotpos-1);对基准的左子表处理。输入序列为[27 38 13]，以27为基准进行排序。输出序列为[13 27 38]

然后在输出序列这一层还会调用QuickSort函数对其左右子表处理，但因为子表长度为1，因此不做排序。

同理对上层序列的右子表处理，输入序列为[76 97 65 49]，输出 序列为[49 65 76 97 ]

对上层序列的左子表处理，输入序列为[49 65]，输出仍然为[49 65]；该层的左右子表、以及上一层的右子表均无需排序，依次出栈，函数结束。此处不再赘述。

最终的序列为[13 27 38 49 49 65 76 97]

2路归并排序

思路

1，总体思路
将两个或两个以上的有序序列两两合并为新的有序表。
初始将序列中n个元素视为n个长度为1的有序表，执行两两合并为⌈n/2⌉个长度为2或1的有序表。然后继续归并，直到合并为一个长度为n的有序序列。

2，如何归并
Merge(int A[],int low,int mid,int high)执行两两归并
两段有序序列为A[low,…,mid]和A[mid+,…,high]，将两段序列复制到辅助数组B中，对数组B的两段序列，分别依次从头到尾取元素对比，较小者放入A中（从A[low]开始放，即覆盖原序列）；若一段序列元素取完，则把剩下的元素都放入A中。

3，递归调用
MergeSort()
对序列进行递归调用，不满足low < high就会结束递归，然后从长度为1的相邻序列开始排序。最后对左右有序子表归并为长度为n的序列。

代码

#define _CRT_SECURE_NO_DEPRECATE
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
void print(int A[], int length)
{
	for (int i = 0; i < length; ++i)
	{
		printf("%d ", A[i]);
	}
}
int* B = (int*)malloc(100 * sizeof(int));

void Merge(int A[], int low, int mid, int high) {
	int i, j, k;
	for (k = low; k <= high; k++)
		B[k] = A[k];
	for (i = low, j = mid + 1, k = i; i <= mid && j <= high; k++) {
		if (B[i] <= B[j])
			A[k] = B[i++];
		else
			A[k] = B[j++];
	}
	while (i <= mid) A[k++] = B[i++];
	while (j <= high) A[k++] = B[j++];
}

void MergeSort(int A[], int low, int high) {
	if (low < high) {
		int mid = (low + high) / 2;
		MergeSort(A, low, mid);
		MergeSort(A, mid + 1, high);
		Merge(A, low, mid, high);
	}
}


void test()
{
	int A[10];
	int length = sizeof(A) / sizeof(A[0]);
	for (int i = 0; i < length; ++i)
	{
		A[i] = rand() % 100;//取0-99的随机数  0-99，都为原值，100-199为0-99，以此类推

	}
	printf("原始序列为：\n");
	print(A, length);
	MergeSort(A, 0, length-1);
	printf("\n排序后为：\n");
	print(A, length);
}


int main()
{
	test();
}

1，初试序列[ 49 38 65 97 76 13 27]
运行函数1
mid=3
MergeSort(A,0,3);
MergeSort(A,4,6);
Merge(A,0,3,6);

2，执行函数1中的MergeSort(A,0,3);递归到函数2
mid=1
MergeSort(A,0,1);
MergeSort(A,2,3);
Merge(A,0,1,3);

3，执行函数2中的MergeSort(A,0,1);递归到函数3
mid=0
MergeSort(A,0,0);
MergeSort(A,1,1);
Merge(A,0,0,1);

其中MergeSort(A,0,0);和MergeSort(A,1,1);不满足low<high的条件，之间结束。

执行Merge(A,0,0,1);对序列[49 38]排序，结果为[38 49];

4，函数3结束，回到函数2，执行MergeSort(A,2,3);，递归到函数4
mid=2
MergeSort(A,2,2);
MergeSort(A,3,3);
Merge(A,2,2,3);
同函数3类似，跳过MergeSort(A,2,2);和MergeSort(A,3,3);执行Merge(A,2,2,3);结果为[65 97].

5，函数4结束，回到函数2，执行Merge(A,0,1,3);
对序列[38 49 65 97]排序，结果为[38 49 65 97]

6,函数2结束，回到函数1，执行MergeSort(A,4,6);递归到函数5，
mid=5
MergeSort(A,4,5);
MergeSort(A,6,6);
Merge(A,0,1,3);
类似的，先对[76 13]排序为[13 76]，然后对[27]排序；最后对[13 76 27]排序 结果为[13 27 76]

7,函数5结束，回到函数1，执行Merge(A,0,3,6);对[38 49 65 97 13 27 76]排序，结果为[13 27 38 49 65 76 97]