C++程序员面试指南第10章

面试题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为非循环单链表）：

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和如下二元树：

/ \

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;
}

C++程序员面试指南第10章

继续阅读

一文看懂字符串的加减乘除

C++ 第十五周报告1--《冒泡法排序》

C语言：初学者必定看懂的注释！！！猴子吃桃问题。猴子第一天摘下若干个桃子，每天都吃了前一天剩下的一半零一个，到第10天早上想再吃的时候，就剩下一个桃子. 求第一天共摘多少个桃子。

测试理论面试题

[转]九大排序算法——C语言实现及详解

C++实现简单顺序表

while 循环、do- while 循环和 for 循环之间的那点事C语言自学之三种循环比较

结构体：typedef与struct的区别

C经典书籍笔记——C陷阱与缺陷②(语法陷阱之优先级)一、错误案列二、优先级规律

线性表之顺序表的实现

面试题解析：你接口测试是怎么做的？

测试面试题整理

软件测试经典面试题（小题汇总）

C++判断素数、求最大公约数代码判断一个数是否为素数求两个数的最大公约数

SequoiaDB巨杉数据库C++驱动概述

hdu7108哈希