面试题1：链表和数组有什么区别
答案：数组和链表有以下几点不同。
(1) 存储形式：数组是一组连续的空间，声明时就要确定长度。链表是一块可不连续的动态空间，长度可变
，每个结点要保存相邻结点指针。
(2) 数据查找：数组的线性查找速度快，查找操作直接使用偏移地址。链表需要按顺序检索结点，效率低。
(3) 数据插入或删除：链表可以快速插入和删除结点，而数组可能需要大量数据移动。
(4) 越界问题：链表不存在越界问题，数组有越界问题。
面试题2：快速查找单链表的中间结点。
答案：
typedef stuct NODE //定义一个结点结构体
{
int a;
struct node *next;
} NODE;
NODE *middle(lnode *head)
{
NODE *fast,*slow,*p; //定义三个结点指针,fast是快指针，slow是慢指针，p是临时指针
if(head == NULL) //判断是否是空链表，是空则退出
{
return NULL;
}
fast=slow=head; //快和慢指针同时指向链表首结点
while(!(p=fast->next)&&!p->next) //循环，直到快指针下个结点或下下个结点为空
{
slow=slow->next; //慢指针走一步
fast=p->next; //快指针走两步
}
return slow; //f返回中间结点
}
面试题3：怎样把一个单链表反序
答案：
（1）反转一个链表。循环算法
List reverse(List n)
{
if(!n) //判断链表是否唯恐，为空即退出
{
return n;
}
list cur = n.next; // 保存头结点的下一个结点
list pre = n; //保存头结点
list tmp;
pre.next = null; //头结点的指针为空，转换后变尾结点
while(NULL != cur.next) //循环直到cur.next为空
{
tmp = cur;
tmp.next = pre;
pre = tmp;
cur = cur.next;
}
return tmp; //f返回头指针
}
（2）反转一个链表。递归算法
List *reverse(List *oldList, List *newHead = NULL)
{
List *next = oldList->next; //记录上次反转后的链表
oldList->next = newHead; //将当前结点插入到反转后链表的开头
newHead = oldList; //递归处理剩余的链表
return (next == NULL)? newHead:reverse(t,newHead);
}
面试题4：根据需求建立一个单向循环链表
设计一个程序，用键盘输入的一些数字创建一个单向循环链表，求出链表长度，打印链表各个元素。之后可以根
据需求把这个循环链表改装成单向链表或带环的单向链表。
答案：
typedef struct node
{
int data;
struct node *next;
}Lnode, *LinkList;
void CreatLinkList(LinkList &L)
{
//建立一个单循环链表L，数据为整数
//数据由键盘随机输入
int i;
LinkList p1;
L = (LinkList)malloc(sizeof(struct node)); //申请新结点
p1 = L;
p1->next = L;
cout<<"please input the data of the node "<<endl;
<<"input 0 to end:";
cin>>i; //读取数值
while(i)
{
LinkList p = (LinkList)malloc(sizeof(struct node)); //申请新结点
if(!p)
{
cout<<"allocation error"<<endl;
exit(1);
}
p->data = i; //初始化新结点
p1->next = p; //插入新结点
p1 = p;
p1->next = L;
cout<<"please input the data of the node"<<endl;
<<"input 0 to end:";
cin>>i;
}
}
void PrintLinkList(LinkList L) //输出单循环链表L的数据元素
{
LinkList temp = L->next;
cout<<"The List Is:"<<endl;
while(temp->next != L->next)
{
cout<<temp->data<<endl;
temp = temp->next;
}
}
int LinkListLength(LinkList L) //计算单循环链表L的数据元素的个数
{
int i = 0;
LinkList temp = L->next;
while(temp->next != L->next) //执行直到链表尾部
{
i++;
temp = temp->next;
}
return i;
}
void LinkListCircle(LinkList &L,int i,int LinkListLength)
{ //将链表环化
LinkList p1,p2;
p1 = p2 = L->next;
for(int m = 0; m < LinkListLength-1; m++)
{
p1 = p1->next;
}
if(i == 0)
{
p1->next = NULL;
return;
}
for(m = 0; m < i-1; m++) //寻找环起始点
{
p2 = p2->next;
}
p1->next = p2;
}
测试函数：
# include <iostream.h>
# include <stdlib.h>
# include <stdio.h>
void main()
{
LinkList L;
CreatLinkList(L); //创建链表
PrintLinkList(L); //打印链表
cout<<"链表长度为："<<LinkListLength(L)<<endl;
int i = 0;
cout<<"请输入从第几个元素开始循环（0为非循环单链表）："<<endl;
cin>>i;
LinkListCircle(L,i,LinkListLength(L)); //链表环化
i = 0;
LinkList p1,p2;
p1 = L->next;
p2 = p1->next->next;
while(i < 25)
{
i++;
cout<<p1->data<<" ";
p1 = p1->next;
p2 = p2->next->next;
}
}
运行结果：
please input the data of the node
input 0 to end:1
please input the data of the node
input 0 to end:2
please input the data of the node
input 0 to end:3
please input the data of the node
input 0 to end:4
please input the data of the node
input 0 to end:5
please input the data of the node
input 0 to end:6
please input the data of the node
input 0 to end:0
The List Is:
1
2
3
4
5
6
链表长度为：6
请输入从第几个元素开始循环（0为非循环单链表）：
3
1 2 3 4 5 6 3 4 5 6 3 4 5 6 3 4 5 6 3 4 5 6 3 4 5
面试题5：检测一个较大的单向链表是否带环
答案：
bool research_cycleLink(LinkList headNode)
{
LinkList p1,p2;
bool result = false; //返回链表是否带有循环
p1 = headNode;
if(p1->next == NULL)
{
printf("只存在一个结点！\n");
}
else if(p1->next->next == NULL)
{
printf("只存在两个结点！\n");
}
else
{
p2 = (p1->next)->next; //p2指向第三个结点
while((p1 != NULL) && (p2 != NULL))
{
if(p1 == p2)
{
result = true; //p2赶上p1则链表带有循环
break;
}
else
{
if(p2->next ==NULL)
{
result = false;
break;
}
p1 = p1->next; //p1向后移一个结点
p2 = (p2->next)->next; //p2向后移两个结点
}
} //end while
}
return result;
}
面试题6：按要求构造一个双向链表
设计一个程序，用键盘输入一些数字创建一个双向链表，计算链表长度，并打印链表中各数据元素。
答案：
//节点结构体
typedef struct dnod
{
int data; //节点数值
struct dnod *next; //前结点指针
struct dnod *pre; //后结点指针
}dnod, *LinkList;
//链表创建函数
void CreatLinkList(LinkList &L) // 创建链表
{
LinkList p,s;
int x, cycle = 1;
p = (LinkList)malloc(sizeof(dnod)); //申请新结点空间
if(p == NULL) //检验是否申请成功
{
printf("Fail to malloc the head node!\n");
return;
}
p->pre = NULL;
p->next = NULL;
L = p;
while(cycle)
{
printf("please input the data of the node\n");
printf("input 0 to end:");
scanf("%d",&x); //读取数值
if(x != 0)
{
s = (LinkList)malloc(sizeof(dnod)); //申请新结点
if(s ==NULL)
{
printf("Fail to malloc a new node!\n");
return;
} //将新结点插入链表
s->data = x;
p->next = s;
s->pre = p;
s->next = NULL;
p = s;
}
else
{
cycle = 0;
}
}
return ;
}
//打印链表数据元素函数
void PrintLinkList(LinkList L)
{ //打印链表内容
if(L->next == NULL) //检验链表是否为空
{
printf("The List L is NULL\n");
return ;
}
LinkList p;
p = L->next;
while(p != NULL)
{
printf("%d",p->data); //输出结点数值
if(p->next ==NULL)
{
break;
}
p = p->next; //当前结点指针后移
}
printf("\n");
}
//计算链表长度函数
int lengthLinkList(LinkList L) //计算链表长度
{
int i = 0;
LinkList p;
p = L->next;
while(p != NULL) //当前结点是否为空
{
i++; //长度加一
if(p->next == NULL)
{
break;
}
p = p->next; //当前结点后移
}
return i;
}
测试程序：
# include <stdio.h>
# include <malloc.h>
void main(void)
{
LinkList L;
CreatLinkList(L); //创建链表
printf("Length of list is : %d\n",LengthLinkList(L));
PrintLinkList(L);
}
运行结果：
please input the data of the node
input 0 to end:1
please input the data of the node
input 0 to end:2
please input the data of the node
input 0 to end:3
please input the data of the node
input 0 to end:4
please input the data of the node
input 0 to end:0
Length of list is : 4
1234
面试题7：编程实现双链表插入新结点
一个已知链表，根据给定的位置、数据实现一个新结点的插入。
答案：
void InsertNode(LinkList &L,int num, int data) //插入新结点
{
int i = 1;
LinkList p1,p2;
p1 = L;
p2 = (LinkList)malloc(sizeof(dnod)); //为新结点申请空间
if(p2 ==NULL) //检验新结点空间是否申请成功
{
printf("Fail to malloc a new node!\n");
return;
}
p2->data = data;
if(num == 0) // 在尾部插入新结点
{
while(p1->next != NULL) //找到尾结点
{
p1 = p1->next;
}
p2->next = p1->next; //插入新结点
p2->pre->next = p1;
p2->pre = p1;
p1->next = p2;
}
else // 在num处插入新结点
{
while(i < num)
{
i++;
if(p1->next == NULL) //找到num处
{
printf("The num you given is to large!\n");
return;
}
p1 = p1->next;
}
p2->next = p1->next;
p2->pre->next = p1; //插入新结点
p2->pre = p1;
p1->next = p2;
}
return ;
}
面试题8： 编程实现双链表删除指定结点
已知一个链表，删除指定位置上的结点
答案：
//双向链表的结点删除函数
void DeleteNode(LinkList &L,int num)
{ //双链表删除结点函数
if(L->next == NULL) //检验链表是否为空
{
printf("The List is NULL!\n");
return;
}
int i = 1;
LinkList = p1,p2;
p1 = L;
if(num == 0) //删除尾结点
{
while(p1->next->next != NULL) // 找到尾结点
{
p1 = p1->next;
}
p2 = p1->next; //删除结点
p1->next = p2->next;
p2->next->pre = p1;
free(p2);
p2 = NULL;
}
else //删除第num号结点
{
while(i < num) //找到第num号结点
{
i++;
if(p1->next == NULL)
{
printf("The num you given is to large!\n");
return;
}
p1 = p1->next;
}
p2 = p1->next; //删除结点
if(p2->next != NULL)
{
p2->next->pre = p1;
}
p1->next = p2->next;
p2->next->pre = p1;
free(p2);
p2 = NULL;
}
return;
}
面试题9：简述队列和栈的异同
栈和队列是两种不同的数据结构，它们之间相互联系又相互区别，请简述两者的异同。
答案：队列和栈都是线性存储结构，但是两者的插入和删除数据的操作不同，队列是“先进先出”，栈是“先进后出”。
面试题10：建立一个链式栈。
建立一个链式栈，实现入栈和出栈功能。
答案：
//栈的结点指针结构体
typedef struct node
{
int data;
node *next;
}node, *LinkStack;
//建立空栈的函数
LinkStack CreateNULLStack(LinkStack &S)
{
S = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL == S)
{
printf("Fail to malloc a new node.\n");
return NULL;
}
S->data = 0;
S->next = NULL; //初始化新结点
return S;
}
//栈结点的插入函数
LinkStack Push(LinkStack &S,int data)
{
if(NULL == S) //判断是否为有效栈
{
printf("There no node in stack!");
return NULL;
}
LinkStack p = NULL;
p = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL == p)
{
printf("Fail to malloc a new node.\n");
return S;
}
if(NULL == S->next) //将新结点压入栈
{
p->next = NULL;
}
else
{
p->next = S->next;
}
p->data = data; //初始化新结点
S->next = p;
return S;
}
//栈结点的删除函数
node Pop(LinkStack &S)
{
node temp;
temp.data = 0;
temp.next = MULL;
if(NULL == S) //检验是否为空栈
{
printf("There no node in stack!");
return temp;
}
temp = *S;
if(S->next == NULL)
{
printf("The stack is NULL,can't pop!");
return temp;
}
LinkStack p = S->next; //栈顶指针下移
S->next = S->next->next;
temp = *p;
free(p); //释放原栈顶结点
p = NULL;
return temp;
}
面试题11：建立一个链式队列
建立一个链式队列，实现入队和出队功能。
答案：
//结点结构体
typedef struct node
{
int data;
node *next;
}node,*LinkQueue;
//队列结构体
typedef struct Queue
{
LinkQueue head;
LinkQueue tail;
int size;
}Queue, *pQueue;
//创建一个空队列函数
pQueue CreateNULLQueue(pQueue &Q)
{
Q =(pQueue)malloc(sizeof(Queue)); //申请一个队列
if(NULL == Q->head)
{
printf("Fail to malloc the head of Queue!\n");
return NULL;
}
Q->head = (LinkQueue)malloc(sizeof(node)); //申请队首节点
if(NULL == Q->head)
{
printf("Fail to malloc the head of Queue!\n");
return NULL;
}
Q->tail = (LinkQueue)malloc(sizeof(node)); //申请队尾结点
if(NULL == Q->tail)
{
printf("Fail to malloc the head of Queue!\n");
return NULL;
}
Q->head->next = Q->tail; //初始化队列
Q->tail->next = NULL;
Q->head->data = 0;
Q->tail->data = 0;
Q->size = 0;
return Q;
}
//队列插入函数
pQueue Push(pQueue &Q,int data)
{
if(NULL == Q) //检验队列
{
printf("There isn't a queue to push!\n");
return NULL;
}
LinkQueue p = NULL;
p = (LinkQueue)malloc(sizeof(node)); // 申请新结点
if(NULL == p)
{
printf("Fail to malloc a new node to push!\n");
return Q;
}
p->data = data; //插入新结点
p->next = Q->head->next;
Q->head->next = p;
Q->size++;
return Q;
}
//队列删除函数
node Pop(pQueue &Q)
{
node temp, *p, *p1;
temp.data = 0;
temp.next = NULL;
if(NULL == Q) //检验队列
{
printf("There isn't a queue to pop!\n");
return temp;
}
if(Q->head->next == Q->tail) //检验队列是否为空
{
printf("There isn't a node to pop!\n");
return temp;
}
p = Q->head;
while(Q->tail != p->next->next) //找到队尾结点的上上个结点
{
p = p->next;
}
p1 = p->next;
p->next = Q->tail; //删除队尾结点的上个结点
temp = *p1;
free(p1);
p1 = p = NULL;
Q->size--;
return temp;
}
测试函数：
# include <stdio.h>
# include <malloc.h>
void main(void)
{
pQueue Q = NULL;
node temp;
CreateNULLQueue(Q); //创建空队列
for (int i = 0; i < 8; i++) //入队
{
Push(Q,i);
printf("push %d ",i);
printf("size of queue is :%d\n",Q->size);
}
printf("\n");
while(Q->head->next != Q->tail) //出队
{
temp = Pop(Q);
printf("pop: %d ",temp.data);
printf("size of queue is :%d\n",Q->size);
}
printf("\n");
}
运行结果：
push 0 size of queue is :1
push 1 size of queue is :2
push 2 size of queue is :3
push 3 size of queue is :4
push 4 size of queue is :5
push 5 size of queue is :6
push 6 size of queue is :7
push 7 size of queue is :8
pop: 0 size of queue is :7
pop: 1 size of queue is :6
pop: 2 size of queue is :5
pop: 3 size of queue is :4
pop: 4 size of queue is :3
pop: 5 size of queue is :2
pop: 6 size of queue is :1
pop: 7 size of queue is :0
面试题12：能否用两个栈实现一个队列的功能？
//节点结构体
typedef struct node
{
int data;
node *next;
}node, *LinkStack;
//创建空栈
LinkStack CreateNULLStack(LinkStack &S)
{
S = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL ==S)
{
printf("Fail to malloc a new node.\n");
return NULL;
}
S->data = 0; //初始化新结点
S->next = NULL;
return S;
}
//栈的插入函数
LinkStack Push(LinkStack &S, int data)
{
if(NULL == S) // 检验栈
{
printf("There no node in stack!");
return NULL;
}
LinkStack p = NULL;
p = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL == p)
{
printf("Fail to malloc a new node.\n");
return S;
}
if(NULL == S->next)
{
p->next = NULL;
}
else
{
p->next = S->next;
}
p->data = data; //初始化新结点
S->next = p; //插入新结点
return S;
}
//出栈函数
node Pop(LinkStack &S)
{
node temp;
temp.data = 0;
temp.next = NULL;
if(NULL == S) //检验栈
{
printf("There no node in stack!");
return temp;
}
temp = *S;
if(S->next == NULL)
{
printf("The stack is NULL,can't pop!");
return temp;
}
LinkStack p = S->next; //结点出栈
S->next = S->next->next;
temp = *p;
free(p);
p = NULL;
return temp;
}
//双栈实现队列的入队函数：
LinkStack StackToQueuePush(LinkStack &S, int data)
{
node n;
LinkStack S1 = NULL;
CreateNULLStack(S1); //创建空栈
while(NULL != S->next) //S出栈入S1
{
n = Pop(S);
Push(S1,n.data);
}
Push(S1,data); //新结点入栈
while(NULL != S1->next) //S1出栈入S
{
n = Pop(S1);
Push(S,n.data);
}
return S;
}
测试函数：
#include <stdio.h>
#include <malloc.h>
void main(void)
{
node n;
LinkStack S1 = NULL;
CreateNULLStack(S1); //创建空栈
for(int i=0; i<8; i++) //入队列式栈
{
StackToQueuePush(S1,i);
printf("%d ",i);
}
printf("\n");
while(NULL != S1->next) //出队列式栈
{
n = Pop(S1);
printf("%d ",n.data);
}
printf("\n");
}
运行结果：
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7
面试题13：建立一个二叉树
编码实现二叉树的创建，二叉树的先序、中序和后序遍历。
答案：
typedef struct BiTNode //定义二叉树节点结构
{
char data; //数据域
struct BiTNode *lchild;//左子指针域
struct BiTNode *rchild;//右子指针域
}BiTNode, *BiTree;
BiTree CreatT(BiTree &b)
{
char ch;
ch = getchar(); //读取数值
if(ch == '#') //判断是否为结束符
{
b = NULL;
}
else
{
b = (BiTree)malloc(sizeof(BiTNode)); //申请新结点
if(NULL == b)
{
printf("overflow err\n");
return NULL;
}
b->data = ch; //初始化新结点
CreatT(b->lchild); //插入当前结点的左指针
CreatT(b->rchild); //插入当前结点的右指针
}
return b;
}
void PreOrder(BiTree T)
{
if(T)
{
printf("%c ",T->data); //访问结点
PreOrder(T->lchild); //遍历左子树
PreOrder(T->rchild); //遍历右子树
}
}
void InOrder(BiTree T)
{
if(T)
{
InOrder(T->lchild); // 遍历左子树
printf("%c ",T->data); //访问结点
InOrder(T->rchild); //遍历右子树
}
}
void PostOrder(BiTree T)
{
if(T)
{
PostOrder(T->lchild); //遍历左子树
PostOrder(T->rchild); //遍历右子树
printf("%c ",T->data); //访问结点
}
}
测试程序：
#include <stdio.h>
#include <malloc.h>
void main()
{
BiTree T;
int flag = 1;
printf("建树将以三个#后回车结束。\n");
printf("例如：1#2#3#4#5#6### \n");
CreatT(T); //初始化队列
printf("递归先序遍历二叉树："); //先序遍历
PreOrder(T);
printf("\n");
printf("递归中序遍历二叉树："); //中序遍历
InOrder(T);
printf("\n");
printf("递归后序遍历二叉树："); //后序遍历
PostOrder(T);
printf("\n");
}
运行结果：
建树将以三个#后回车结束。
例如：1#2#3#4#5#6###
1#2#3#4#5#6###
递归先序遍历二叉树：1 2 3 4 5 6
递归中序遍历二叉树：1 2 3 4 5 6
递归后序遍历二叉树：6 5 4 3 2 1
面试题14；计算一棵二叉树的深度
设计一个算法，实现计算二叉树的深度的功能。
答案：
int depth(BiTree T)
{
if(!T) return 0; //判断当前结点是否为叶子结点
int d1 = depth(T->lchild); //求当前结点的左子树的深度
int d2 = depth(T->rchild); //求当前结点的右子树的深度
return (d1 > d2 ? d1:d2)+1;
}
测试程序：
#include <stdio.h>
#include <malloc.h>
typedef struct BiTNode //定义二叉树节点结构
{
char data; //数据域
struct BiTNode *lchild;//左子指针域
struct BiTNode *rchild;//右子指针域
}BiTNode, *BiTree;
BiTree CreatT(BiTree &b)
{
char ch;
ch = getchar(); //读取数值
if(ch == '#') //判断是否为结束符
{
b = NULL;
}
else
{
b = (BiTree)malloc(sizeof(BiTNode)); //申请新结点
if(NULL == b)
{
printf("overflow err\n");
return NULL;
}
b->data = ch; //初始化新结点
CreatT(b->lchild); //插入当前结点的左指针
CreatT(b->rchild); //插入当前结点的右指针
}
return b;
}
void PreOrder(BiTree T)
{
if(T)
{
printf("%c ",T->data); //访问结点
PreOrder(T->lchild); //遍历左子树
PreOrder(T->rchild); //遍历右子树
}
}
void InOrder(BiTree T)
{
if(T)
{
InOrder(T->lchild); // 遍历左子树
printf("%c ",T->data); //访问结点
InOrder(T->rchild); //遍历右子树
}
}
void PostOrder(BiTree T)
{
if(T)
{
PostOrder(T->lchild); //遍历左子树
PostOrder(T->rchild); //遍历右子树
printf("%c ",T->data); //访问结点
}
}
int depth(BiTree T)
{
if(!T) return 0; //判断当前结点是否为叶子结点
int d1 = depth(T->lchild); //求当前结点的左子树的深度
int d2 = depth(T->rchild); //求当前结点的右子树的深度
return (d1 > d2 ? d1:d2)+1;
}
void main()
{
BiTree T;
int flag = 1, n;
printf("建树将以三个#后回车结束。\n");
printf("例如：1#2#3#4#5#6### \n");
CreatT(T); //初始化队列
printf("递归先序遍历二叉树："); //先序遍历
PreOrder(T);
printf("\n");
printf("递归中序遍历二叉树："); //中序遍历
InOrder(T);
printf("\n");
printf("递归后序遍历二叉树："); //后序遍历
PostOrder(T);
printf("\n");
n = depth(T);
printf("n: %d\n",n);
}
面试题15：在二叉树中找出和为某一值的所有路径
输入一个整数和一棵二元树。从树的根节点开始往下访问，一直到叶节点所经过的所有结点形成一条路径。打印
出和与输入整数相等的所有路径。例如输入整数9和如下二元树：
3
/ \
2 6
/ \
5 4
则打印出两条路径：3，6和3，2，4。
答案：
typedef struct path
{
BiTNode* tree; //节点数据成员
struct path* next; //结点指针成员
}PATH, *pPath;
// 初始化树的结点栈：
void init_path(pPath* L)
{
*L = (pPath)malloc(sizeof(PATH)); //创建空树
(*L)->next = NULL;
}
//树结点入栈函数：
void push_path(pPath H, pBTree T)
{
pPath p = H->next;
pPath q = H;
while (NULL != p)
{
q = p;
p = p->next;
}
p = (pPath)malloc(sizeof(PATH)); //申请新结点
p->next = NULL; //初始化新结点
p->tree = T;
q->next = p; //新结点入栈
}
//树结点打印函数：
void print_path(pPath L)
{
pPath p = L->next;
while(NULL != p) //打印当前栈中所有数据
{
printf("%d, ",p->tree->data);
p = p->next;
}
}
//树结点出栈函数：
void pop_path(pPath H)
{
pPath p = H->next;
pPath q = H;
if(NULL == p) //检验当前栈是否为空
{
printf("Stack is null!\n");
return;
}
p = p->next;
while(NULL != p) //出栈
{
q = q->next;
p = p->next;
}
free(q->next); //释放出栈结点空间
q->next = NULL;
}
//判断结点是否为叶子结点：
int IsLeaf(pBTree T)
{
return (T->lchild == NULL) && (T->rchild == NULL);
}
//查找符合条件的路径：
int find_path(pBTree T, int sum, pPath L)
{
push_path(L,T);
record += T->data;
if((record == sum) && (IsLeaf(T))) //打印符合条件的当前路径
{
print_path(L);
printf("\n");
}
if(T->lchild != NULL) //递归查找当前结点的左子树
{
find_path(T->lchild,sum,L);
}
if(T->rchild != NULL) //递归查找当前结点的右子树
{
find_path(T->rchild,sum,L);
}
record -= T->data;
pop_path(L);
return 0;
}
答案：数组和链表有以下几点不同。
(1) 存储形式：数组是一组连续的空间，声明时就要确定长度。链表是一块可不连续的动态空间，长度可变
，每个结点要保存相邻结点指针。
(2) 数据查找：数组的线性查找速度快，查找操作直接使用偏移地址。链表需要按顺序检索结点，效率低。
(3) 数据插入或删除：链表可以快速插入和删除结点，而数组可能需要大量数据移动。
(4) 越界问题：链表不存在越界问题，数组有越界问题。
面试题2：快速查找单链表的中间结点。
答案：
typedef stuct NODE //定义一个结点结构体
{
int a;
struct node *next;
} NODE;
NODE *middle(lnode *head)
{
NODE *fast,*slow,*p; //定义三个结点指针,fast是快指针，slow是慢指针，p是临时指针
if(head == NULL) //判断是否是空链表，是空则退出
{
return NULL;
}
fast=slow=head; //快和慢指针同时指向链表首结点
while(!(p=fast->next)&&!p->next) //循环，直到快指针下个结点或下下个结点为空
{
slow=slow->next; //慢指针走一步
fast=p->next; //快指针走两步
}
return slow; //f返回中间结点
}
面试题3：怎样把一个单链表反序
答案：
（1）反转一个链表。循环算法
List reverse(List n)
{
if(!n) //判断链表是否唯恐，为空即退出
{
return n;
}
list cur = n.next; // 保存头结点的下一个结点
list pre = n; //保存头结点
list tmp;
pre.next = null; //头结点的指针为空，转换后变尾结点
while(NULL != cur.next) //循环直到cur.next为空
{
tmp = cur;
tmp.next = pre;
pre = tmp;
cur = cur.next;
}
return tmp; //f返回头指针
}
（2）反转一个链表。递归算法
List *reverse(List *oldList, List *newHead = NULL)
{
List *next = oldList->next; //记录上次反转后的链表
oldList->next = newHead; //将当前结点插入到反转后链表的开头
newHead = oldList; //递归处理剩余的链表
return (next == NULL)? newHead:reverse(t,newHead);
}
面试题4：根据需求建立一个单向循环链表
设计一个程序，用键盘输入的一些数字创建一个单向循环链表，求出链表长度，打印链表各个元素。之后可以根
据需求把这个循环链表改装成单向链表或带环的单向链表。
答案：
typedef struct node
{
int data;
struct node *next;
}Lnode, *LinkList;
void CreatLinkList(LinkList &L)
{
//建立一个单循环链表L，数据为整数
//数据由键盘随机输入
int i;
LinkList p1;
L = (LinkList)malloc(sizeof(struct node)); //申请新结点
p1 = L;
p1->next = L;
cout<<"please input the data of the node "<<endl;
<<"input 0 to end:";
cin>>i; //读取数值
while(i)
{
LinkList p = (LinkList)malloc(sizeof(struct node)); //申请新结点
if(!p)
{
cout<<"allocation error"<<endl;
exit(1);
}
p->data = i; //初始化新结点
p1->next = p; //插入新结点
p1 = p;
p1->next = L;
cout<<"please input the data of the node"<<endl;
<<"input 0 to end:";
cin>>i;
}
}
void PrintLinkList(LinkList L) //输出单循环链表L的数据元素
{
LinkList temp = L->next;
cout<<"The List Is:"<<endl;
while(temp->next != L->next)
{
cout<<temp->data<<endl;
temp = temp->next;
}
}
int LinkListLength(LinkList L) //计算单循环链表L的数据元素的个数
{
int i = 0;
LinkList temp = L->next;
while(temp->next != L->next) //执行直到链表尾部
{
i++;
temp = temp->next;
}
return i;
}
void LinkListCircle(LinkList &L,int i,int LinkListLength)
{ //将链表环化
LinkList p1,p2;
p1 = p2 = L->next;
for(int m = 0; m < LinkListLength-1; m++)
{
p1 = p1->next;
}
if(i == 0)
{
p1->next = NULL;
return;
}
for(m = 0; m < i-1; m++) //寻找环起始点
{
p2 = p2->next;
}
p1->next = p2;
}
测试函数：
# include <iostream.h>
# include <stdlib.h>
# include <stdio.h>
void main()
{
LinkList L;
CreatLinkList(L); //创建链表
PrintLinkList(L); //打印链表
cout<<"链表长度为："<<LinkListLength(L)<<endl;
int i = 0;
cout<<"请输入从第几个元素开始循环（0为非循环单链表）："<<endl;
cin>>i;
LinkListCircle(L,i,LinkListLength(L)); //链表环化
i = 0;
LinkList p1,p2;
p1 = L->next;
p2 = p1->next->next;
while(i < 25)
{
i++;
cout<<p1->data<<" ";
p1 = p1->next;
p2 = p2->next->next;
}
}
运行结果：
please input the data of the node
input 0 to end:1
please input the data of the node
input 0 to end:2
please input the data of the node
input 0 to end:3
please input the data of the node
input 0 to end:4
please input the data of the node
input 0 to end:5
please input the data of the node
input 0 to end:6
please input the data of the node
input 0 to end:0
The List Is:
1
2
3
4
5
6
链表长度为：6
请输入从第几个元素开始循环（0为非循环单链表）：
3
1 2 3 4 5 6 3 4 5 6 3 4 5 6 3 4 5 6 3 4 5 6 3 4 5
面试题5：检测一个较大的单向链表是否带环
答案：
bool research_cycleLink(LinkList headNode)
{
LinkList p1,p2;
bool result = false; //返回链表是否带有循环
p1 = headNode;
if(p1->next == NULL)
{
printf("只存在一个结点！\n");
}
else if(p1->next->next == NULL)
{
printf("只存在两个结点！\n");
}
else
{
p2 = (p1->next)->next; //p2指向第三个结点
while((p1 != NULL) && (p2 != NULL))
{
if(p1 == p2)
{
result = true; //p2赶上p1则链表带有循环
break;
}
else
{
if(p2->next ==NULL)
{
result = false;
break;
}
p1 = p1->next; //p1向后移一个结点
p2 = (p2->next)->next; //p2向后移两个结点
}
} //end while
}
return result;
}
面试题6：按要求构造一个双向链表
设计一个程序，用键盘输入一些数字创建一个双向链表，计算链表长度，并打印链表中各数据元素。
答案：
//节点结构体
typedef struct dnod
{
int data; //节点数值
struct dnod *next; //前结点指针
struct dnod *pre; //后结点指针
}dnod, *LinkList;
//链表创建函数
void CreatLinkList(LinkList &L) // 创建链表
{
LinkList p,s;
int x, cycle = 1;
p = (LinkList)malloc(sizeof(dnod)); //申请新结点空间
if(p == NULL) //检验是否申请成功
{
printf("Fail to malloc the head node!\n");
return;
}
p->pre = NULL;
p->next = NULL;
L = p;
while(cycle)
{
printf("please input the data of the node\n");
printf("input 0 to end:");
scanf("%d",&x); //读取数值
if(x != 0)
{
s = (LinkList)malloc(sizeof(dnod)); //申请新结点
if(s ==NULL)
{
printf("Fail to malloc a new node!\n");
return;
} //将新结点插入链表
s->data = x;
p->next = s;
s->pre = p;
s->next = NULL;
p = s;
}
else
{
cycle = 0;
}
}
return ;
}
//打印链表数据元素函数
void PrintLinkList(LinkList L)
{ //打印链表内容
if(L->next == NULL) //检验链表是否为空
{
printf("The List L is NULL\n");
return ;
}
LinkList p;
p = L->next;
while(p != NULL)
{
printf("%d",p->data); //输出结点数值
if(p->next ==NULL)
{
break;
}
p = p->next; //当前结点指针后移
}
printf("\n");
}
//计算链表长度函数
int lengthLinkList(LinkList L) //计算链表长度
{
int i = 0;
LinkList p;
p = L->next;
while(p != NULL) //当前结点是否为空
{
i++; //长度加一
if(p->next == NULL)
{
break;
}
p = p->next; //当前结点后移
}
return i;
}
测试程序：
# include <stdio.h>
# include <malloc.h>
void main(void)
{
LinkList L;
CreatLinkList(L); //创建链表
printf("Length of list is : %d\n",LengthLinkList(L));
PrintLinkList(L);
}
运行结果：
please input the data of the node
input 0 to end:1
please input the data of the node
input 0 to end:2
please input the data of the node
input 0 to end:3
please input the data of the node
input 0 to end:4
please input the data of the node
input 0 to end:0
Length of list is : 4
1234
面试题7：编程实现双链表插入新结点
一个已知链表，根据给定的位置、数据实现一个新结点的插入。
答案：
void InsertNode(LinkList &L,int num, int data) //插入新结点
{
int i = 1;
LinkList p1,p2;
p1 = L;
p2 = (LinkList)malloc(sizeof(dnod)); //为新结点申请空间
if(p2 ==NULL) //检验新结点空间是否申请成功
{
printf("Fail to malloc a new node!\n");
return;
}
p2->data = data;
if(num == 0) // 在尾部插入新结点
{
while(p1->next != NULL) //找到尾结点
{
p1 = p1->next;
}
p2->next = p1->next; //插入新结点
p2->pre->next = p1;
p2->pre = p1;
p1->next = p2;
}
else // 在num处插入新结点
{
while(i < num)
{
i++;
if(p1->next == NULL) //找到num处
{
printf("The num you given is to large!\n");
return;
}
p1 = p1->next;
}
p2->next = p1->next;
p2->pre->next = p1; //插入新结点
p2->pre = p1;
p1->next = p2;
}
return ;
}
面试题8： 编程实现双链表删除指定结点
已知一个链表，删除指定位置上的结点
答案：
//双向链表的结点删除函数
void DeleteNode(LinkList &L,int num)
{ //双链表删除结点函数
if(L->next == NULL) //检验链表是否为空
{
printf("The List is NULL!\n");
return;
}
int i = 1;
LinkList = p1,p2;
p1 = L;
if(num == 0) //删除尾结点
{
while(p1->next->next != NULL) // 找到尾结点
{
p1 = p1->next;
}
p2 = p1->next; //删除结点
p1->next = p2->next;
p2->next->pre = p1;
free(p2);
p2 = NULL;
}
else //删除第num号结点
{
while(i < num) //找到第num号结点
{
i++;
if(p1->next == NULL)
{
printf("The num you given is to large!\n");
return;
}
p1 = p1->next;
}
p2 = p1->next; //删除结点
if(p2->next != NULL)
{
p2->next->pre = p1;
}
p1->next = p2->next;
p2->next->pre = p1;
free(p2);
p2 = NULL;
}
return;
}
面试题9：简述队列和栈的异同
栈和队列是两种不同的数据结构，它们之间相互联系又相互区别，请简述两者的异同。
答案：队列和栈都是线性存储结构，但是两者的插入和删除数据的操作不同，队列是“先进先出”，栈是“先进后出”。
面试题10：建立一个链式栈。
建立一个链式栈，实现入栈和出栈功能。
答案：
//栈的结点指针结构体
typedef struct node
{
int data;
node *next;
}node, *LinkStack;
//建立空栈的函数
LinkStack CreateNULLStack(LinkStack &S)
{
S = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL == S)
{
printf("Fail to malloc a new node.\n");
return NULL;
}
S->data = 0;
S->next = NULL; //初始化新结点
return S;
}
//栈结点的插入函数
LinkStack Push(LinkStack &S,int data)
{
if(NULL == S) //判断是否为有效栈
{
printf("There no node in stack!");
return NULL;
}
LinkStack p = NULL;
p = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL == p)
{
printf("Fail to malloc a new node.\n");
return S;
}
if(NULL == S->next) //将新结点压入栈
{
p->next = NULL;
}
else
{
p->next = S->next;
}
p->data = data; //初始化新结点
S->next = p;
return S;
}
//栈结点的删除函数
node Pop(LinkStack &S)
{
node temp;
temp.data = 0;
temp.next = MULL;
if(NULL == S) //检验是否为空栈
{
printf("There no node in stack!");
return temp;
}
temp = *S;
if(S->next == NULL)
{
printf("The stack is NULL,can't pop!");
return temp;
}
LinkStack p = S->next; //栈顶指针下移
S->next = S->next->next;
temp = *p;
free(p); //释放原栈顶结点
p = NULL;
return temp;
}
面试题11：建立一个链式队列
建立一个链式队列，实现入队和出队功能。
答案：
//结点结构体
typedef struct node
{
int data;
node *next;
}node,*LinkQueue;
//队列结构体
typedef struct Queue
{
LinkQueue head;
LinkQueue tail;
int size;
}Queue, *pQueue;
//创建一个空队列函数
pQueue CreateNULLQueue(pQueue &Q)
{
Q =(pQueue)malloc(sizeof(Queue)); //申请一个队列
if(NULL == Q->head)
{
printf("Fail to malloc the head of Queue!\n");
return NULL;
}
Q->head = (LinkQueue)malloc(sizeof(node)); //申请队首节点
if(NULL == Q->head)
{
printf("Fail to malloc the head of Queue!\n");
return NULL;
}
Q->tail = (LinkQueue)malloc(sizeof(node)); //申请队尾结点
if(NULL == Q->tail)
{
printf("Fail to malloc the head of Queue!\n");
return NULL;
}
Q->head->next = Q->tail; //初始化队列
Q->tail->next = NULL;
Q->head->data = 0;
Q->tail->data = 0;
Q->size = 0;
return Q;
}
//队列插入函数
pQueue Push(pQueue &Q,int data)
{
if(NULL == Q) //检验队列
{
printf("There isn't a queue to push!\n");
return NULL;
}
LinkQueue p = NULL;
p = (LinkQueue)malloc(sizeof(node)); // 申请新结点
if(NULL == p)
{
printf("Fail to malloc a new node to push!\n");
return Q;
}
p->data = data; //插入新结点
p->next = Q->head->next;
Q->head->next = p;
Q->size++;
return Q;
}
//队列删除函数
node Pop(pQueue &Q)
{
node temp, *p, *p1;
temp.data = 0;
temp.next = NULL;
if(NULL == Q) //检验队列
{
printf("There isn't a queue to pop!\n");
return temp;
}
if(Q->head->next == Q->tail) //检验队列是否为空
{
printf("There isn't a node to pop!\n");
return temp;
}
p = Q->head;
while(Q->tail != p->next->next) //找到队尾结点的上上个结点
{
p = p->next;
}
p1 = p->next;
p->next = Q->tail; //删除队尾结点的上个结点
temp = *p1;
free(p1);
p1 = p = NULL;
Q->size--;
return temp;
}
测试函数：
# include <stdio.h>
# include <malloc.h>
void main(void)
{
pQueue Q = NULL;
node temp;
CreateNULLQueue(Q); //创建空队列
for (int i = 0; i < 8; i++) //入队
{
Push(Q,i);
printf("push %d ",i);
printf("size of queue is :%d\n",Q->size);
}
printf("\n");
while(Q->head->next != Q->tail) //出队
{
temp = Pop(Q);
printf("pop: %d ",temp.data);
printf("size of queue is :%d\n",Q->size);
}
printf("\n");
}
运行结果：
push 0 size of queue is :1
push 1 size of queue is :2
push 2 size of queue is :3
push 3 size of queue is :4
push 4 size of queue is :5
push 5 size of queue is :6
push 6 size of queue is :7
push 7 size of queue is :8
pop: 0 size of queue is :7
pop: 1 size of queue is :6
pop: 2 size of queue is :5
pop: 3 size of queue is :4
pop: 4 size of queue is :3
pop: 5 size of queue is :2
pop: 6 size of queue is :1
pop: 7 size of queue is :0
面试题12：能否用两个栈实现一个队列的功能？
//节点结构体
typedef struct node
{
int data;
node *next;
}node, *LinkStack;
//创建空栈
LinkStack CreateNULLStack(LinkStack &S)
{
S = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL ==S)
{
printf("Fail to malloc a new node.\n");
return NULL;
}
S->data = 0; //初始化新结点
S->next = NULL;
return S;
}
//栈的插入函数
LinkStack Push(LinkStack &S, int data)
{
if(NULL == S) // 检验栈
{
printf("There no node in stack!");
return NULL;
}
LinkStack p = NULL;
p = (LinkStack)malloc(sizeof(node)); //申请新结点
if(NULL == p)
{
printf("Fail to malloc a new node.\n");
return S;
}
if(NULL == S->next)
{
p->next = NULL;
}
else
{
p->next = S->next;
}
p->data = data; //初始化新结点
S->next = p; //插入新结点
return S;
}
//出栈函数
node Pop(LinkStack &S)
{
node temp;
temp.data = 0;
temp.next = NULL;
if(NULL == S) //检验栈
{
printf("There no node in stack!");
return temp;
}
temp = *S;
if(S->next == NULL)
{
printf("The stack is NULL,can't pop!");
return temp;
}
LinkStack p = S->next; //结点出栈
S->next = S->next->next;
temp = *p;
free(p);
p = NULL;
return temp;
}
//双栈实现队列的入队函数：
LinkStack StackToQueuePush(LinkStack &S, int data)
{
node n;
LinkStack S1 = NULL;
CreateNULLStack(S1); //创建空栈
while(NULL != S->next) //S出栈入S1
{
n = Pop(S);
Push(S1,n.data);
}
Push(S1,data); //新结点入栈
while(NULL != S1->next) //S1出栈入S
{
n = Pop(S1);
Push(S,n.data);
}
return S;
}
测试函数：
#include <stdio.h>
#include <malloc.h>
void main(void)
{
node n;
LinkStack S1 = NULL;
CreateNULLStack(S1); //创建空栈
for(int i=0; i<8; i++) //入队列式栈
{
StackToQueuePush(S1,i);
printf("%d ",i);
}
printf("\n");
while(NULL != S1->next) //出队列式栈
{
n = Pop(S1);
printf("%d ",n.data);
}
printf("\n");
}
运行结果：
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7
面试题13：建立一个二叉树
编码实现二叉树的创建，二叉树的先序、中序和后序遍历。
答案：
typedef struct BiTNode //定义二叉树节点结构
{
char data; //数据域
struct BiTNode *lchild;//左子指针域
struct BiTNode *rchild;//右子指针域
}BiTNode, *BiTree;
BiTree CreatT(BiTree &b)
{
char ch;
ch = getchar(); //读取数值
if(ch == '#') //判断是否为结束符
{
b = NULL;
}
else
{
b = (BiTree)malloc(sizeof(BiTNode)); //申请新结点
if(NULL == b)
{
printf("overflow err\n");
return NULL;
}
b->data = ch; //初始化新结点
CreatT(b->lchild); //插入当前结点的左指针
CreatT(b->rchild); //插入当前结点的右指针
}
return b;
}
void PreOrder(BiTree T)
{
if(T)
{
printf("%c ",T->data); //访问结点
PreOrder(T->lchild); //遍历左子树
PreOrder(T->rchild); //遍历右子树
}
}
void InOrder(BiTree T)
{
if(T)
{
InOrder(T->lchild); // 遍历左子树
printf("%c ",T->data); //访问结点
InOrder(T->rchild); //遍历右子树
}
}
void PostOrder(BiTree T)
{
if(T)
{
PostOrder(T->lchild); //遍历左子树
PostOrder(T->rchild); //遍历右子树
printf("%c ",T->data); //访问结点
}
}
测试程序：
#include <stdio.h>
#include <malloc.h>
void main()
{
BiTree T;
int flag = 1;
printf("建树将以三个#后回车结束。\n");
printf("例如：1#2#3#4#5#6### \n");
CreatT(T); //初始化队列
printf("递归先序遍历二叉树："); //先序遍历
PreOrder(T);
printf("\n");
printf("递归中序遍历二叉树："); //中序遍历
InOrder(T);
printf("\n");
printf("递归后序遍历二叉树："); //后序遍历
PostOrder(T);
printf("\n");
}
运行结果：
建树将以三个#后回车结束。
例如：1#2#3#4#5#6###
1#2#3#4#5#6###
递归先序遍历二叉树：1 2 3 4 5 6
递归中序遍历二叉树：1 2 3 4 5 6
递归后序遍历二叉树：6 5 4 3 2 1
面试题14；计算一棵二叉树的深度
设计一个算法，实现计算二叉树的深度的功能。
答案：
int depth(BiTree T)
{
if(!T) return 0; //判断当前结点是否为叶子结点
int d1 = depth(T->lchild); //求当前结点的左子树的深度
int d2 = depth(T->rchild); //求当前结点的右子树的深度
return (d1 > d2 ? d1:d2)+1;
}
测试程序：
#include <stdio.h>
#include <malloc.h>
typedef struct BiTNode //定义二叉树节点结构
{
char data; //数据域
struct BiTNode *lchild;//左子指针域
struct BiTNode *rchild;//右子指针域
}BiTNode, *BiTree;
BiTree CreatT(BiTree &b)
{
char ch;
ch = getchar(); //读取数值
if(ch == '#') //判断是否为结束符
{
b = NULL;
}
else
{
b = (BiTree)malloc(sizeof(BiTNode)); //申请新结点
if(NULL == b)
{
printf("overflow err\n");
return NULL;
}
b->data = ch; //初始化新结点
CreatT(b->lchild); //插入当前结点的左指针
CreatT(b->rchild); //插入当前结点的右指针
}
return b;
}
void PreOrder(BiTree T)
{
if(T)
{
printf("%c ",T->data); //访问结点
PreOrder(T->lchild); //遍历左子树
PreOrder(T->rchild); //遍历右子树
}
}
void InOrder(BiTree T)
{
if(T)
{
InOrder(T->lchild); // 遍历左子树
printf("%c ",T->data); //访问结点
InOrder(T->rchild); //遍历右子树
}
}
void PostOrder(BiTree T)
{
if(T)
{
PostOrder(T->lchild); //遍历左子树
PostOrder(T->rchild); //遍历右子树
printf("%c ",T->data); //访问结点
}
}
int depth(BiTree T)
{
if(!T) return 0; //判断当前结点是否为叶子结点
int d1 = depth(T->lchild); //求当前结点的左子树的深度
int d2 = depth(T->rchild); //求当前结点的右子树的深度
return (d1 > d2 ? d1:d2)+1;
}
void main()
{
BiTree T;
int flag = 1, n;
printf("建树将以三个#后回车结束。\n");
printf("例如：1#2#3#4#5#6### \n");
CreatT(T); //初始化队列
printf("递归先序遍历二叉树："); //先序遍历
PreOrder(T);
printf("\n");
printf("递归中序遍历二叉树："); //中序遍历
InOrder(T);
printf("\n");
printf("递归后序遍历二叉树："); //后序遍历
PostOrder(T);
printf("\n");
n = depth(T);
printf("n: %d\n",n);
}
面试题15：在二叉树中找出和为某一值的所有路径
输入一个整数和一棵二元树。从树的根节点开始往下访问，一直到叶节点所经过的所有结点形成一条路径。打印
出和与输入整数相等的所有路径。例如输入整数9和如下二元树：
3
/ \
2 6
/ \
5 4
则打印出两条路径：3，6和3，2，4。
答案：
typedef struct path
{
BiTNode* tree; //节点数据成员
struct path* next; //结点指针成员
}PATH, *pPath;
// 初始化树的结点栈：
void init_path(pPath* L)
{
*L = (pPath)malloc(sizeof(PATH)); //创建空树
(*L)->next = NULL;
}
//树结点入栈函数：
void push_path(pPath H, pBTree T)
{
pPath p = H->next;
pPath q = H;
while (NULL != p)
{
q = p;
p = p->next;
}
p = (pPath)malloc(sizeof(PATH)); //申请新结点
p->next = NULL; //初始化新结点
p->tree = T;
q->next = p; //新结点入栈
}
//树结点打印函数：
void print_path(pPath L)
{
pPath p = L->next;
while(NULL != p) //打印当前栈中所有数据
{
printf("%d, ",p->tree->data);
p = p->next;
}
}
//树结点出栈函数：
void pop_path(pPath H)
{
pPath p = H->next;
pPath q = H;
if(NULL == p) //检验当前栈是否为空
{
printf("Stack is null!\n");
return;
}
p = p->next;
while(NULL != p) //出栈
{
q = q->next;
p = p->next;
}
free(q->next); //释放出栈结点空间
q->next = NULL;
}
//判断结点是否为叶子结点：
int IsLeaf(pBTree T)
{
return (T->lchild == NULL) && (T->rchild == NULL);
}
//查找符合条件的路径：
int find_path(pBTree T, int sum, pPath L)
{
push_path(L,T);
record += T->data;
if((record == sum) && (IsLeaf(T))) //打印符合条件的当前路径
{
print_path(L);
printf("\n");
}
if(T->lchild != NULL) //递归查找当前结点的左子树
{
find_path(T->lchild,sum,L);
}
if(T->rchild != NULL) //递归查找当前结点的右子树
{
find_path(T->rchild,sum,L);
}
record -= T->data;
pop_path(L);
return 0;
}