从递归单链表改到二叉树·下，神之一笔启动新的穷举，在数据封装中发现的递归出口不同条件的探索结果。

 代码实现。

从简单out函数到show函数，实现一个if控制的限定长度的判断

从show到find函数，实现条件终止判断。

从find函数到in函数，实现数据的读入。

从in函数到in族函数如inpro,inprosu等等，实现单变量循环次数控制，到数组实现变量随循环次数控制，在到结构体封装，描述中解决问题，意外描述出循环控制结构体数据读入。

从100循环次数控制，单变量 i ,单变量 i 控制的数组，结构体 i 控制数组。到-1控制终止点。

再来一次神之一笔，复制粘贴，自然而然实现二叉树递归。

 函数跨越在i选择位置从i开始，到list结构体i开始，不能自主控制i的位置，退出出口意识逐渐形成，退出出口变成NULL，而非数组长度到此为止。意外发现了二叉树的实现。如此，二叉树开发完成。

 

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

typedef struct node {
	int e;
	node* next;
} node;

//递归是啥
void out(int i) {
	if (i < 10) {
		printf("%d\n", i);
		i++;
		out(i);
	}
}

//最原始的代码，小于10且10以内不会因为空指针崩溃自动退出
void show(node* a, int i) {
	if (i < 10 && a != NULL) {
		printf("%d %d\n", a->e, i);
		show(a->next, i + 1);
	}
}


//等价说明
void showss(node* a, int i) {
	if (i < 10 ) {
		if ( a != NULL) {
			printf("%d %d\n", a->e, i);
			showss(a->next, i + 1);
		}
	}
}


//基于show2的延伸  a!=NULL的替换
//一句话意识不匹配就一直套用下去
int find2(node* a, int e, int i) {
	if (a->e != e) {
		i++;
		find2(a->next, e, i);
	} else {
		return i;
	}
}

//find2改写之前的样子
int find(node* a, int e, int i) {
	if (a->e == e) {
		return i;
	} else {
		i++;
		find(a->next, e, i);
	}
}

//和in形式相同，意义相同
void in(node* a, int e, int i) {
	printf("%d %d\n", e, i);
	if (i < 10) {
		if (a == NULL) {
			a = (node*)malloc(sizeof(node));
			a->e = e;
			a->next = NULL;
		} else {
			i++;
			in(a->next, e, i);
		}

	}
}



typedef struct list {
	int v[100];
	int top;
} list;


//接上交换位置
void inprosu7(node* a, list* ak) {
	printf("%d %d\n", ak->v[ak->top], ak->top);
	if (ak->top < 100) {
		a->next = (node*)malloc(sizeof(node));
		a->next->e = ak->v[ak->top];
		ak->top++;
//		a->next->next = NULL;
		inprosu7(a->next, ak);
	} else {
		a = NULL;
	}
}

//支线来源1从in的改写 
void seek(node* a, int e, int i) {
	if (i < 10) {
		if (a == NULL) {
			a = (node*)malloc(sizeof(node));
			a->e = e;
			a->next = NULL;
		} else {
			i++;
			seek(a, e, i);
		}
	}

}


//变量数组，意义变化成数据随递归变换 
void seekpro(node* a, int p[], int i) {
	if (p[i] > -1) {
		if (a == NULL) {
			a = (node*)malloc(sizeof(node));
			a->e = p[i];
			a->next = NULL;
		} else {
			seekpro(a, p, i);
		}
	}
}

//复制粘贴，循环一笔 
void seekpros(node* a, int p[], int i) {
	if (p[i] > -1) {
		if (a == NULL) {
			a = (node*)malloc(sizeof(node));
			a->e = p[i];
			a->next = NULL;
			i++;
			seekpros(a, p, i);
		} else {
			seekpros(a, p, i);
		}
	}
}


//把p和i绑在一块 打包成结构体，注释的一行是基于in函数改写的，两部分代码掺和盖起来的
void inprosu7(node* a, list* ak) {
	printf("%d %d\n", ak->v[ak->top], ak->top);
	if (ak->top < 100) {
		a->next = (node*)malloc(sizeof(node));
		a->next->e = ak->v[ak->top];
		ak->top++;
//		a->next->next = NULL;
		inprosu7(a->next, ak);
	} else {
		a = NULL;
	}
}


//从上限100变成100处放-1控制，但是发现中断递归的其他原因 ，标志位信息
void inprosu778(node* a, list* ak) {
	printf("%d %d\n", ak->v[ak->top], ak->top);
	if (ak->top != -1) {
		a->next = (node*)malloc(sizeof(node));
		a->next->e = ak->v[ak->top];
		ak->top++;
//		a->next->next = NULL;
		inprosu778(a->next, ak);
	} else {
		a = NULL;
	}
}


typedef struct node {
	int e;
	node* next;
	node* next2; 
} node;


void inprosu7789(node* a, list* ak) {
	printf("%d %d\n", ak->v[ak->top], ak->top);
	if (ak->top != -1) {
		a->next = (node*)malloc(sizeof(node));
		a->next->e = ak->v[ak->top];
		ak->top++;
//		a->next->next = NULL;
		inprosu7789(a->next, ak);
		inprosu7789(a->next2, ak);
	} else {
		a = NULL;
	}
}

typedef struct tree {
	int e;
	node* lchild;
	node* rchild; 
} tree;


void inprosu7789(tree* a, list* ak) {
	printf("%d %d\n", ak->v[ak->top], ak->top);
	if (ak->top != -1) {
		a->next = (node*)malloc(sizeof(node));
		a->next->e = ak->v[ak->top];
		ak->top++;
//		a->next->next = NULL;
		inprosu7789(a->lchild, ak);
		inprosu7789(a->rchild, ak);
	} else {
		a = NULL;
	}
}


typedef struct tree {
	int e;
	tree* lchild;
	tree* rchild; 
} tree;



void inprosu7789_2(tree* a, list* ak) {
	printf("%d %d\n", ak->v[ak->top], ak->top);
	if (ak->top != -1) {
		a = (tree*)malloc(sizeof(tree));
		a->e = ak->v[ak->top];
		ak->top++;
//		a->next->next = NULL;
		inprosu7789_2(a->lchild, ak);
		inprosu7789_2(a->rchild, ak);
	} else {
		a = NULL;
	}
}





int main() {
	node* t = NULL;
	if (t == NULL) {
		printf("error\n");
	}

//必须要设置如NULL,才能关停
	t = (node*)malloc(sizeof(node));
	t->e = -1;
	t->next = NULL;
	inpro(t, 2, 1);
	inpro(t, 3, 1);
	printf("\n");
	show(t, 1);
//	showpro(t,1);


	return 0;
}