递归求链表最大值

递归求解单链表中的最大值-CSDN博客 

以上是参考

函数写不动了，结果发现原来是头结点没有初始化导致乱码。

递归的看find函数，

Max函数是别人的，

max函数是自己的遗迹代码。

find函数可以独立写起来。但是压缩成Max函数，代码用三目运算符压缩，变量内提可能想不出来。

#include<stdio.h>
#include<stdlib.h>

typedef struct node {
	int e;
	node* next;
} node;
typedef struct list {
	node* head;
	node* rear;
} list;

list* init() {
	list* l = (list*)malloc(sizeof(list));
	l->head = (node*)malloc(sizeof(node));
	l->rear = l->head;
	l->head->next = NULL;
	return l;
}
int push(list* l, int e) {
	node* p = (node*)malloc(sizeof(node));
	p->e = e;
	p->next = l->rear->next;
	l->rear->next = p;
	l->rear = l->rear->next;
	return 1;
}

int pop(list* l, int *e) {
	node* p;
	p = l->head->next;
	*e = p->e;
	l->head->next = p->next;

	free(p);
	return 1;
}

//int max(node* head,int m) {
//	node* p=head->next;
//	if(p==NULL) {
//		return m;
//	} else {
//		return max(p->next,p->e);
//	}
//}
//
//
//int max(node* p) {
//	if(p==NULL) {
//		return m;
//	} else {
//		return max(p->next);
//	}
//}


//int max(node* p, node* p->next) {
//	if(p->next==NULL) {
//		return p->e;
//	} else {
//		printf("%d\n",p->e);
//		return max(p,max(p->next,p->next->next));
//	}
//}

//int find(node* p) {
//	if(p->next==NULL) {
//		return p->e;
//	} else {
//		printf("%d\n",p->e);
//		if(p->next->e>find(p)){
//			return find(p->next);
//		}else{
//			return p->next->e;
//		}
//	}
//}

int Max(node* p) {
	int max;
	if (p->next == NULL)
		return p->e;
	else {
		max = Max(p->next);
		return p->e >= max ? p->e : max;
	}
}

//int find(node* p){
//	if(p->next==NULL){
//		return p->e;
//	}else{
//		int m=find(p->next);
//		return m>p->e?m:p->e;
//	}
//}

int find(node* p, int n) {
	if (p == NULL) {
		return n;
	}
//	if (p->next == NULL) {
//		if (p->e > n) {
//			return p->e;
//		} else {
//			return n;
//		}
//	} 
	else {
//		printf("%d\n",n);
		if (p->e >= n) {
			printf("%d\n", n);
//				printf("%d\n",p->e);
			return find(p->next, p->e);
		} else {
//				printf("%d\n",n);
			return find(p->next, n);
		}
//		或者是下面这样 
		return p->e>n?find(p->next,p->e):find(p->next,n);
	}
}

//int sum(node* p) {
//	if(p->next==NULL) {
//		return p->e;
//	} else {
//		printf("%d\n",p->e);
//		return p->e+sum(p->next);
//	}
//}

//int sum2(node* p) {
//	if(p->next=NULL) {
//		return p->e;
//	} else {
//		printf("%d\n",p->e);
//		return p->e*sum2(p->next);
//	}
//}

//function fn(n) {
//	if (n == 1) {
//		return 1;
//	}
//	return n * fn(n-1)
//}

void show(list* l) {
	node* p = l->head->next;
	while (p) {
		printf("%d\n", p->e);
		p = p->next;
	}
}
int main() {
	int i = 0;
	list* l = init();
	int p = -1;
	for (i = 0; i < 26; i++) {
		p = p * -1;
		push(l, p * i);
	}
//	show(l);

	printf("\n");
	int c = -1;
//	c = find(l->head, 15);
//	带头结点导致空数据 
	c = find(l->head->next, 15);
	
//		c=Max(l->head->next);
	printf("%d\n", c);

//	int d=sum(l->head->next);
//	printf("%d\n",d);


	return 0;
}