递归与迭代算法（二）

#include <stdio.h>

/************************************************************************/
/*                                                                      */
/* Recursive data structures (structural recursion)                     */
/* 打印链表 (Linked lists)                                               */
/*                                                                      */
/************************************************************************/
struct list_node
{
    int n;
    struct list_node *next;
};
typedef struct list_node *LIST;

void printList(LIST lst)
{
    if (lst)
    {
        printf("%d ", lst->n);
        printList(lst->next);
    }
}

/************************************************************************/
/*                                                                      */
/* Recursive data structures (structural recursion)                     */
/* 判断二叉树中是否存在指定值 (Binary trees)                               */
/*                                                                      */
/************************************************************************/
struct bt_node
{
    int n;
    struct bt_node *left;
    struct bt_node *right;
};
typedef struct bt_node *TREE;

// Inorder traversal:
void printTree(TREE t)
{
    if (t)
    {
        printTree(t->left);
        printf("%d ", t->n);
        printTree(t->right);
    }
}

// Test if t contains i; return 1 if so, 0 if not.
int contains(TREE t, int i) {
    if (!t)
        return 0;
    else if (t->n == i)
        return 1;
    else
        return contains(t->left, i) || contains(t->right, i);
}


/************************************************************************/
/*                                                                      */
/* Tail-recursives VS Not tail-recursives                               */
/* Tail-recursives: all recursive calls are tail calls and hence do     */
/*                  not build up any deferred operations                */
/* Not tail-recursives: its recursive call is not in tail position,     */
/*                      it builds up deferred multiplication operations */
/*                      that must be performed after the final recursive*/
/*                      call completes                                  */
/*                                                                      */
/************************************************************************/

//INPUT: Integers x, y such that x >= y and y > 0
int gcd(int x, int y)    /* Tail recursion */
{
    if (y == 0)
        return x;
    else
        return gcd(y, x % y);
}
//INPUT: n is an Integer such that n >= 1
int fact(int n)          /* Augmenting recursion */
{
    if (n == 1)
        return 1;
    else
        return n * fact(n - 1);
}

/************************************************************************/
/*                                                                      */
/* Order of function calling                                            */
/*                                                                      */
/************************************************************************/

//function 1
void recursiveFunction1(int num) {
    printf("%d\n", num);
    if (num < 4)
        recursiveFunction1(num + 1);
}
/*
recursiveFunction(0)
printf(0)
         recursiveFunction(0+1)
         printf(1)
                  recursiveFunction(1+1)
                  printf(2)
                           recursiveFunction(2+1)
                           printf(3)
                                    recursiveFunction(3+1)
                                    printf(4)
*/

//function 2
void recursiveFunction2(int num) {
    if (num < 4)
        recursiveFunction2(num + 1);
    printf("%d\n", num);
}
/*
recursiveFunction(0)
         recursiveFunction(0+1)
                  recursiveFunction(1+1)
                           recursiveFunction(2+1)
                                    recursiveFunction(3+1)
                                    printf(4)
                           printf(3)
                  printf(2)
         printf(1)
printf(0)
*/

void main()
{
    LIST lst = new list_node;
    lst->n = 10;
    lst->next = new list_node;
    lst->next->n = 20;
    lst->next->next = NULL;
    printList(lst); printf("\n");

    TREE t = new bt_node;
    t->n = 100;
    t->left = new bt_node;
    t->right = new bt_node;
    t->left->n = 90;
    t->left->left = NULL;
    t->left->right = new bt_node;
    t->left->right->n = 95;
    t->left->right->left = NULL;
    t->left->right->right = NULL;
    t->right->n = 110;
    t->right->right = NULL;
    t->right->left = new bt_node;
    t->right->left->n = 105;
    t->right->left->left = NULL;
    t->right->left->right = NULL;
    printTree(t);
    printf("%s\n", contains(t, 105) ? "Contain 105!" : "Not contain 105!");
    printf("%s\n", contains(t, 106) ? "Contain 106!" : "Not contain 106!");

    recursiveFunction1(5);
    recursiveFunction2(6);
}