数据结构——递归

一、递归的一般定义
       所谓递归，通俗来说就是函数自己调用自己的过程，但是要明确的一点是，递归一定要有自己的出口，要不然就会陷入一种“无法自拔”的境地！！！
二、递归的用处
       递归一般用于解决三类问题：
      1.数据的定义是按照递归定义的（斐波那契）；
      2.问题解法按照递归算法解决（回溯）；
      3.数据的结构形式按照递归定义的（树的遍历，图的搜索）。
三、递归小算法

//斐波那契数列递归
long long Fac(int N)
{
	if (N <= 2)
	{
		return 1;
	}
	else
	{
		return (Fac(N - 1) + Fac(N - 2));
	}
}

//改变参数列表来实现
long long Fac(int first,int second,int N)
{
	if (N <= 2)
	{
		return first + second;
	}
	else
	{
		return Fac(second, first + second, N-1);
	}
}

//二分查找
int BinarySearch(int *array,int data,int left,int right)
{
	int mid = 0;
	while (left <= right)
	{
		mid = left + ((right - left) >> 1);
		if (array[mid] > data)
		{
			return BinarySearch(array, data, left, mid - 1);
		}
		else if (array[mid] < data)
		{
			return BinarySearch(array, data, mid + 1, right);
		}
		else
		{
			return mid;
		}
	}
}

//逆向打印数组
void PrintArray(int *array, int size)
{
	if (size > 0)
	{
		cout << array[size - 1]<<" ";
		PrintArray(array, size - 1);
	}
}

//递归实现一个字符串是否是回文

int IsPalindereme(char *str,int size)
{
	for (int idx = 0; idx <= ((size) / 2); idx++)
	{
		if (str[idx] != str[size - idx - 1])
		{
			return -1;
		}
	}
	return 0;
}

int IsPalindereme(char *str, int size)
{
	if (str == NULL)
	{
		return -1;
	}
	if ((size == 0) || (size == 1))
	{
		return 0;
	}
	if (*str != *(str + size - 1))
	{
		return -1;
	}
	else
	{
		return IsPalindereme(str + 1, size - 2);
	}
}

//全排列
void Perm(int *array, int size, int N)
{
	if (N == size)
	{
		for (int idx = 0; idx < size; idx++)
		{
			cout << array[idx] << " ";
		}
		cout << endl;
	}
	else
	{
		for (int idx = N; idx < size; idx++)
		{
			std::swap(array[idx], array[N]);
			Perm(array, size, N + 1);
			std::swap(array[idx], array[N]);
		}
	}
}

//单链表操作

struct Node
{
	Node(int data)
	:_data(data)
	, _pnext(NULL)
	{}

	int _data;
	Node* _pnext;
};


void Print(Node* pHead)//逆向打印单链表
{
	if (pHead)
	{
		Print(pHead->_pnext);
		cout << pHead->_data << "->";
	}
}


void Destroy(Node* pHead)//逆向销毁单链表中的各个节点
{
	if (pHead)
	{
		Destroy(pHead->_pnext);
		delete pHead;
		pHead = NULL;
	}
}


Node* Find(Node* pHead,int data)//单链表中查找某个值为data的节点
{
	if (pHead)
	{
		Node *node = Find(pHead->_pnext, data);
		{
			if (node)
			{
				return node;
			}
		}
		if (pHead->_data == data)
		{
			return pHead;
		}
	}
	return NULL;
}

//求n的阶乘
long long recursive(int n)
{
	int sum = 0;
	if ((n == 1)||(n==0))
	{
		return 1;
	}
	else
	{
		sum=n*recursive(n - 1);
		return sum;
	}
}

//河内塔问题——把第一个柱子上的柱子借助第二个柱子移动到第三个柱子上，并且不改变顺序
void hanoi(int n,int p1,int p2,int p3)
{
	if (n == 1)
	{
		cout << "珠子从" << p1 << "移动到" << p3 << endl;
	}
	else
	{
		hanoi(n - 1, p1, p3, p2);
		cout << "珠子从" << p1 << "移动到" << p3 << endl;
		hanoi(n - 1, p2, p1, p3);
	}
}

如有错误，欢迎批评指正呦！！！