recursion_structur.cpp

#include <iostream>
#include <algorithm>

using namespace std;

struct listNode {
	int data;
	listNode * next;
}; typedef listNode * listPtr;

struct treeNode {
	int data;
	treeNode *left;
	treeNode *right;
}; typedef treeNode * treePtr;


int searchMaxFromList(listNode * ptr){
	if(ptr == NULL) return 0;
	int maxnum = searchMaxFromList(ptr->next);
	return max(maxnum, ptr->data); //maxnum > ptr->data ? maxnum : ptr->data;
}
int searchMaxFromTree(treeNode * ptr){
	if(ptr == NULL) return 0;
	int leftmax = searchMaxFromTree(ptr->left);
	int rightmax = searchMaxFromTree(ptr->right);
	int buf = max(leftmax, rightmax);
	return max(buf, ptr->data);
}


int main(){
	cout<<"start main!"<<endl;

	//List
	listPtr listRoot;
	listNode * l1 = new listNode;
	listNode * l2 = new listNode;
	listNode * l3 = new listNode;
	listNode * l4 = new listNode;
	listNode * l5 = new listNode;
	listNode * l6 = new listNode;
	listNode * l7 = new listNode;
	listNode * l8 = new listNode;

	l1->data =9;
	l2->data =4;
	l3->data =10;
	l4->data =18;
	l5->data =3;
	l6->data =43;
	l7->data =76;
	l8->data =22;

	listRoot = l1;
	l1->next = l2; 
	l2->next = l3; 
	l3->next = l4;
	l4->next = l5;
	l5->next = l6;
	l6->next = l7; 
	l7->next = l8;
	int listMax = searchMaxFromList(listRoot);
	cout<<"listMax:"<<listMax<<endl;

	//Tree
	treePtr root;
	treeNode * t1 = new treeNode;
	treeNode * t2 = new treeNode;
	treeNode * t3 = new treeNode;
	treeNode * t4 = new treeNode;
	treeNode * t5 = new treeNode;
	treeNode * t6 = new treeNode; 
	treeNode * t7 = new treeNode; treeNode * t8 = new treeNode;

	t1->data = 10; 
	t2->data = 4;
	t3->data = 6;
	t4->data = 12;
	t5->data = 9;
	t6->data = 32;
	t7->data = 9;
	t8->data = 22;

	root = t1;
	t1->left = t2; t1->right = t3;
	t2->left = t4; t2->right = t5;
	t3->left = t6; t3->right = t7;
	t4->left = t8;
	int treeMax = searchMaxFromTree(root);
	cout<<"treeMax:"<<treeMax<<endl;

	cout<<"end main!"<<endl;
	return 0;
}