函数调用栈
内存四区
现代的应用程序都运行在一个虚拟内存空间里,在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]