递归...

递归可以简单地理解为函数通过直接或间接的方法调用自己。

通过自上向底的顺序,不断地直接或间接的调用自身函数，直到达到边界结束调用。

举一个在书上看到的小小的例子：

        你问了a一个问题，a说你去问b，b说你去问a，然后无限反复，这就算递归。

再举一个在别的地方看到的例子：

        一群人排队，然后有一个人想知道自己是第几个，就问前面的人，前面的人继续问自己前面的人，最后问到第一个人的时候大家就都知道了自己是第几。

        这个例子中可以分为两步，第一步是回溯，由开始提问的人一步一步的回溯到第一个人；第二步是递推，通过第一个人的结果一步一步的倒推回开始提问的人。

通过这两个例子就可以大致理解递推的概念了，但是这两个例子有一些细微的差别，就是第一个例子他没有一个边界，属于无限递归，而第二个例子中当问到第一个人的时候就可以停止了，所以在用递归思想的时候首先就需要设置一个出口，使其在某一次调用结束后下来，就是所谓的停止条件；再下来设置一个递归条件就over了。

递归算法的特点：如果递归函数能解决n的问题，就一定能解决n+1或者n-1的问题。

快速排序和归并排序就使用到了递归的思想。

1、快速排序

        快速排序的基本思想就是首先找一个基准值，然后用两个指针从左右边界开始向中间判断。

        如图：

        像这样的一组数，我们首先找到一个基准点，这里用的基准点是最左边的数，然后在左右两端分别设置指针，先从右边开始向左边遍历数组，当遇到一个小于基准值的数时右端指针停止移动，左端指针开始向右边遍历，当遇到一个大于基准值的数时左端指针也停止移动，并将此时左右两端指针所指的数进行交换

 

        完成交换后再次从右边指针开始遍历，找到下一个小于基准点的值，找到后停止移动，左边指针开始向右遍历数组，然后就重复这样的过程直到左右两端的指针相遇

 

        我们可以发现这一次交换结束后，右端指针再向左遍历时，在0处与左端指针相遇，此时我们再将最左端的基准值与相遇点进行交换就可以啦

        观察后我们可以发现，此时5所处的位置便是排序后他应在的位置 ，而他左端的数全部都小于它，右边的数全部都大于它，此时我们将这组数分为两部分，再分别使用快速排序对其进行操作就可以得到一组有序的数啦

 （1）代码

#include <bits/stdc++.h>
using namespace std;

const int N=1e8+10;

int a[N],n;
void quicksort(int left,int right)
{
	int i,j,temp;
	if(left>=right)
	{
		return;
	}
	i=left;
	j=right;
	temp=a[left];
	while(i!=j)
	{
		while(i<j&&a[j]>=temp)
		{
			j--;
		}
		while(i<j&&a[i]<=temp)
		{
			i++;
		}
		if(i<j)
		{
			swap(a[i],a[j]);
		}
	}
	swap(a[left],a[i]);
	
	quicksort(left,i-1);
	quicksort(i+1,right);
	return;
}

int main(){
	cin>>n;
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	quicksort(0,n-1);
	for(int i=0;i<n;i++)
	{
		printf("%d ",a[i]);
	}
	return 0;
}

 2、归并排序

 

        归并排序的基本思想是先将需要排序的数字分为尽量相等的两部分然后将两部分的元素分别排序，最后将他们合并为一个有序序列。

        （1）递归的拆分（只剩一个数的时候停止）

        （2）递归的合并

        （3）代码

#include <bits/stdc++.h>
using namespace std;

int n;

void merge(int a[],int temp[],int start,int mid,int end)
{
	int i=start;
	int j=mid+1;
	int k=start;
	
	while(i<mid+1&&j<end+1) 
	{
		if(a[i]>a[j])
		{
			temp[k++]=a[j++];
		}
		else
		{
			temp[k++]=a[i++];
		}
	}
	while(i!=mid+1)
	{
		temp[k++]=a[i++];
	}
	while(j<end+1)
	{
		temp[k++]=a[j++];
	}
	for(i=start;i<=end;i++)
	{
		a[i]=temp[i];
	}
}
 
void mergesort(int a[],int temp[],int start,int end)
{
	if(start>=end)
	{
		return;
	}
	int mid=start+(end-start)/2;
	mergesort(a,temp,start,mid);
	mergesort(a,temp,mid+1,end);
	merge(a,temp,start,mid,end);
}

int main(){
	cin>>n;
	int a[100],temp[100];
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	mergesort(a,temp,0,n-1);
	for(int i=0;i<n;i++)
	{
		printf("%d ",a[i]);
	}
	return 0;
}

其实这两个例子也用到了分治法的思想。

分治法是什么呢，就是将一个大问题拆分成几个小问题然后去解决他们，比如我们熟知的二分法也用到了分治的思想。

目前学习了许多不同的排序方法，例如快速排序归并排序冒泡排序选择排序插入排序桶排序基数排序和计数排序，但其实一般排序直接用sort函数就可以解决。

3、sort函数

        sort函数一般用于一组无重复数字或重复数字不影响结果的数d的排序，处理后的这组数会默认升序排序也就是以从小到大的顺序排列。

      

#include <bits/stdc++.h>
using namespace std;

int main(){
	int a[20];
	for(int i=0;i<20;i++)
	{
		cin>>a[i];
	}
	sort(a,a+20);
	for(int i=0;i<20;i++)
	{
		cout<<a[i]<<" ";
	}
	return 0;
}

我们可以看到，sort函数在使用时需要两个值，而这两个值代表的是数的地址，它所限定的区间是一个左闭右开的区间，像上面这段代码中sort（a,a+20)就是对a[0]到a[19]进行排序，因此我们在使用时应该注意边界问题。

当我们想要他从大到小排序怎么办呢，很简单，只要加上一个cmp参数就可以啦！

#include <bits/stdc++.h>
using namespace std;
bool cmp(int a,int b)
{
	return a>b;
}
int main(){
	int a[20];
	for(int i=0;i<20;i++)
	{
		cin>>a[i];
	}
	sort(a,a+20,cmp);
	for(int i=0;i<20;i++)
	{
		cout<<a[i]<<" ";
	}
	return 0;
}

cmp参数一般在有结构体参与的排序中有很大用处，但我还不太会用，等我掌握的差不多了再写ᕕ( ᐛ )ᕗ​