php 尾递归 快速排序,算法点点滴滴：函数调用栈，递归，尾递归，快速排序

函数调用的时候，会有函数栈，使用过递归的童鞋应该遇到过栈溢出错误：

Exception in thread "main" java.lang.StackOverflowError

比如斐波那契数列，我们采用递归的形式计算，我的电脑计算级数50的时候就已经千呼万唤不出来了，计算一个较大的级数，就只能报溢出的错误了。递归计算的时候，为了能够找到基线的值，程序需要把函数一层一层压入内存栈，直到找到基线的值，然后一层层出栈。这种递归式的压栈增长是非常恐怖的，直到把栈内存打爆。

接着我们谈一下递归，既然递归这么容易引发错误，为什么还有递归呢？正常的递归调用层级不会太深，所以不会引发上述的错误，并且递归方法的调用可以说清晰明了，便于理解。所谓的递归，就是满足基线值时我们给予返回，否则我们继续调用函数本身。当然我们可以采用更普通的循环替代递归，也可以使用尾递归，尾递归算是递归的变种，算是一种另类的循环。

尾递归可以将每次调用的结果直接返回给调用者，这样函数回归时就无需再次压栈，相比递归大大降低了压栈操作，所以效率会有明显提升，说的直白点，就是函数不需要逆向等待计算，我可以把操作当成正向的操作，直到回归到基线值，调用栈只有函数自己，大大减少了栈的深度。当然这个还得依靠编译器优化，不是你说尾递归就尾递归，我们返回函数调用自身，不再有任何的操作或表达式。

下面我们使用斐波那契数列简单对比一下递归，循环，尾递归操作：

public static int fibonacci(int n) {

if(n==1 || n==2) {

return 1;

}else {

return fibonacci(n-1) + fibonacci(n-2);

}

}

public static int fibonacciLoop(int n) {

int[] result = new int

;

if(n==1 || n==2) {

return 1;

}

result[0] = result[1] = 1;

for(int i=2;i

result[i] = result[i-1] + result[i-2];

}

return result[n-1];

}

public static int fibonacci(int n,int ret1,int ret2) {

if(n==0) {

return ret1;

}else {

return fibonacci(n-1,ret2,ret1+ret2);

}

}

public static void main(String[] args) {

Long start = System.currentTimeMillis();

int result = fibonacci(45);

Long end = System.currentTimeMillis();

System.out.println(String.format("time: %s, result: %s", (end-start),result));

start = System.currentTimeMillis();

result = fibonacciLoop(45);

end = System.currentTimeMillis();

System.out.println(String.format("time: %s, result: %s", (end-start),result));

start = System.currentTimeMillis();

result = fibonacci(45,0,1);

end = System.currentTimeMillis();

System.out.println(String.format("time: %s, result: %s", (end-start),result));

}

--------------------------------------------------------------------------------------

time: 5218, result: 1134903170

time: 0, result: 1134903170

time: 0, result: 1134903170

显然循环操作和尾递归效率要远远高于递归操作，但是递归操作貌似是最直观明了的表达方式。

我们继续讨论一下快速排序，快速排序的大概思路就是，在一个集合里，我们先找好一个基准值，然后将小于基准值的扔到左边，大于基准值的扔到右边，然后递归调用左右两个集合，直到再也找不到这样的基准值。说的直白点就是，右边大于基准值的不动，右边小于基准值的覆盖到左边，左边小于基准值的不动，左边大于基准值的覆盖到右边，直到找到基准值的位置。

public static void quickSort(int[] destArray,int start,int end) {

if(start>=end) {

return;

}

int middle = getMiddle(destArray,start,end);

quickSort(destArray,start,middle-1);

quickSort(destArray,middle+1,end);

}

public static int getMiddle(int[] destTemp,int start,int end) {

int base = destTemp[start];

while(start < end) {

//从尾部索引开始向前循环，如果比基准值大，尾部索引减1，继续向前和基准值比较

while(destTemp[end]>=base && start < end) {

end--;

}

//如果尾部索引值比基准值小，把这个尾部索引位置的值扔到当前头部索引位置

destTemp[start] = destTemp[end];

//从头部索引开始向后循环，如果比基准值小，头部索引加1，继续向后和基准值比较

while(destTemp[start]<=base && start < end) {

start++;

}

//如果头部索引值比基准值大，把这个头部索引位置的值扔到当前尾部索引位置

destTemp[end] = destTemp[start];

}

destTemp[start] = base;

return start;

}

最后的废话：快速排序并不稳定，算是一种平均速度较优的排序算法。快速排序关于基准值的选取可以采取三值取中加以优化。排序算法采用递归的形式，还有分而治之的思想，将大问题分割为小问题，直至无法再分割。