c11-1.c
/* code: c11-1.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int factorial (int n) {
int v;
if (n == 0)
return 1;
v = n * factorial (n - 1);
return v;
}
/* ------------------------------------------- */
int main () {
int i;
i = 5;
printf ("factorial(%d) = %d\n", i, factorial (i));
return 0;
}
c11-2.c
/* code: c11-2.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int factorial (int n) {
int i, v;
for (i = 0; i < n; i++)
printf (" ");
printf ("Called 'factorial(%d)' \n", n);
if (n == 0)
return 1;
v = n * factorial (n - 1);
for (i = 0; i < n; i++)
printf (" ");
printf ("Returning 'factorial(%d)=%d' \n", n, v);
return v;
}
/* ------------------------------------------- */
int main () {
int i;
i = 5;
printf ("Factorial of %d is %d\n", i, factorial (i));
return 0;
}
c11-3.c
/* code: c11-3.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int fibonacci (int n) {
int v;
if (n == 0)
return 0;
if (n == 1)
return 1;
v = fibonacci (n - 1) + fibonacci (n - 2);
return v;
}
/* ------------------------------------------- */
int main () {
int i;
i = 5;
printf ("Fibonacci(%d) = %d\n", i, fibonacci (i));
return 0;
}
c11-4.c
/* code: c11-4.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int fibonacci (int n) {
int i, v;
for (i = 0; i < n; i++)
printf (" ");
printf ("Called 'fibonacci(%d)' \n", n);
if (n == 0)
return 0;
if (n == 1)
return 1;
v = fibonacci (n - 1) + fibonacci (n - 2);
for (i = 0; i < n; i++)
printf (" ");
printf ("Returning 'fibonacci(%d)=%d' \n", n, v);
return v;
}
/* ------------------------------------------- */
int main () {
int i;
i = 5;
printf ("Fibonacci(%d) = %d\n", i, fibonacci (i));
return 0;
}
c11-5.c
/* code: c11-5.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int gcd (int x, int y) {
int v;
if (y == 0)
return x;
v = gcd (y, (x % y));
return v;
}
/* ------------------------------------------- */
int main () {
int a, b;
a = 12;
b = 18;
printf ("GCD(%d, %d) = %d\n", a, b, gcd (a, b));
return 0;
}
c11-6.c
/* code: c11-6.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int gcd (int x, int y) {
int v;
printf ("Called 'gcd(%d,%d)' \n", x, y);
if (y == 0)
return x;
v = gcd (y, (x % y));
printf ("Returning 'gcd(%d,%d)=%d' \n", x, y, v);
return v;
}
/* ------------------------------------------- */
int main () {
int a, b;
a = 12;
b = 18;
printf ("GCD(%d, %d) = %d\n", a, b, gcd (a, b));
return 0;
}
c11-7.c
/* code: c11-7.c (v1.18.00) */
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *left;
struct Node *right;
};
typedef struct Node NODE_TYPE;
struct Stack {
struct Node *t;
struct Stack *next;
};
typedef struct Stack STACK_TYPE;
/* ------------------------------------------ */
void push (STACK_TYPE ** stack, NODE_TYPE * t) {
STACK_TYPE *newnode;
newnode = malloc (sizeof (STACK_TYPE));
if (newnode == NULL) {
printf ("ERROR: stack overflow \n");
exit (-1);
}
newnode->t = t;
newnode->next = *stack;
*stack = newnode;
}
/* ------------------------------------------ */
int is_stack_empty (STACK_TYPE * top) {
return (top == NULL) ? 1 : 0;
}
/* ------------------------------------------ */
NODE_TYPE *pop (STACK_TYPE ** stack) {
NODE_TYPE *node;
STACK_TYPE *top;
if (is_stack_empty (*stack)) {
printf ("ERROR: stack underflow \n");
exit (-1);
}
else {
top = *stack;
node = top->t;
*stack = top->next;
free (top);
return node;
}
}
/* ------------------------------------------ */
void inorder_recursion (NODE_TYPE * node) {
if (node != NULL) {
inorder_recursion (node->left);
printf ("%d ", node->data);
inorder_recursion (node->right);
}
}
/* ------------------------------------------ */
void inorder_stack (NODE_TYPE * root) {
int flag;
STACK_TYPE *stack;
NODE_TYPE *node;
node = root;
stack = NULL;
flag = 0;
while (!flag) {
if (node != NULL) {
push (&stack, node);
node = node->left;
}
else {
if (!is_stack_empty (stack)) {
node = pop (&stack);
printf ("%d ", node->data);
node = node->right;
}
else {
flag = 1;
}
}
}
}
/* ------------------------------------------ */
void tree_display (NODE_TYPE * node, int level) {
int i;
if (node != NULL) {
tree_display (node->right, level + 1);
printf ("\n");
for (i = 0; i < level; i++) {
printf ("__");
}
printf ("%d", node->data);
tree_display (node->left, level + 1);
}
}
/* ------------------------------------------ */
NODE_TYPE *tree_insert (NODE_TYPE * node, int data) {
if (node == NULL) {
if (NULL == (node = malloc (sizeof (NODE_TYPE)))) {
printf ("\nERROR: Can not allocate memory");
exit (-1);
}
node->left = NULL;
node->right = NULL;
node->data = data;
}
else {
if (data < node->data) {
node->left = tree_insert (node->left, data);
}
else if (data > node->data) {
node->right = tree_insert (node->right, data);
}
}
return node;
}
/* ------------------------------------------ */
int main () {
NODE_TYPE *root;
int i;
int data[] = { 40, 30, 70, 10, 60, 90, 20, 80 };
root = NULL;
for (i = 0; i < 8; i++) {
printf ("%2d ", data[i]);
root = tree_insert (root, data[i]);
}
printf ("\n\n");
printf ("*** binary search tree ***\n");
tree_display (root, 0);
printf ("\n\n*** inorder traversal (recursion) ***\n");
inorder_recursion (root);
printf ("\n\n*** inorder traversal (stack) ***\n");
inorder_stack (root);
printf ("\n");
return 0;
}
c11-8.c
/* code: c11-8.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int factorial (int n) {
if (n == 0)
return 1;
return n * factorial (n - 1);
}
/* ------------------------------------------- */
int factorial_tail (int n, int acc) {
if (n == 0)
return acc;
return factorial_tail (n - 1, n * acc);
}
/* ------------------------------------------- */
int main () {
int i;
i = 5;
printf ("factorial_tail(%d) = %d\n", i, factorial_tail (i, 1));
return 0;
}
q11-1.c
/* code: q11-1.c (v1.18.00) */
#include <stdio.h>
void foo (int n) {
if (n < 5) {
printf ("%d ", n);
foo (n + 1);
}
}
int main () {
foo (0);
return 0;
}
q11-2.c
/* code: q11-2.c (v1.18.00) */
#include <stdio.h>
void foo (int n) {
if (n < 5) {
foo (n + 1);
printf ("%d ", n);
}
}
int main () {
foo (0);
return 0;
}
q11-3.c
/* code: q11-3.c (v1.18.00) */
#include <stdio.h>
/* ------------------------------------------- */
int power (int x, int n) {
int m;
if (n == 0)
return 1;
if (n % 2 == 0) {
m = power (x, n / 2);
return m * m;
}
else {
return x * power (x, n - 1);
}
}
/* ------------------------------------------- */
int main () {
int x, n;
x = 5;
n = 3;
printf ("power(%d,%d) = %d\n", x, n, power (x, n));
return 0;
}
q11-4.c
/* code: q11-4.c (v1.18.00) */
#include <stdio.h>
#include <stdlib.h>
#define ARRAY_SIZE 13
/* ------------------------------------------- */
int binary_search (int array[], int num, int key) {
int middle, low, high;
low = 0;
high = num - 1;
while (low <= high) {
middle = (low + high) / 2;
if (key == array[middle]) {
return middle;
}
else if (key < array[middle]) {
high = middle - 1;
}
else {
low = middle + 1;
}
}
return -1;
}
/* ------------------------------------------- */
int binary_search_r (int array[], int num, int key, int low, int high) {
int middle;
if (low > high)
return -1;
middle = (low + high) / 2;
if (array[middle] == key) {
return middle;
}
else if (array[middle] < key) {
return binary_search_r (array, num, key, middle + 1, high);
}
else {
return binary_search_r (array, num, key, low, middle - 1);
}
}
/* ------------------------------------------- */
void print_array (int array[], int n) {
int i;
for (i = 0; i < n; i++) {
printf ("%d ", array[i]);
}
printf ("\n");
}
/* ------------------------------------------- */
int main () {
int index, key;
int array[ARRAY_SIZE] = {
50, 80, 150, 210, 250, 280, 330,
470, 510, 530, 800, 900, 990
};
key = 800;
print_array (array, ARRAY_SIZE);
/* index = binary_search (array, ARRAY_SIZE, key); */
index = binary_search_r (array, ARRAY_SIZE, key, 0, ARRAY_SIZE - 1);
if (index != -1) {
printf ("Found: %d (index:%d)\n", key, index);
}
else {
printf ("Not found: %d\n", key);
}
return 0;
}
EOF