【无标题】
作者：互联网
#include<bits/stdc++.h>
using namespace std;
#define TRUE 1
#define FALSE 0
#define ERROR 0
#define OVERFLOW -1
#define OK 1
typedef int Status;
typedef int TElemType;
Status CreateBiTree(BiTree &T);
int GetDepthOfBiTree(BiTree T);
int LeafCount(BiTree T);
typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild, *rchild;
}BiTNode, * BiTree;
Status CreateBiTree(BiTree &T){
TElemType e;
scanf("%d",&e);
if(e==0){
T=NULL;
}
else{
T=(BiTNode*)malloc(sizeof(BiTNode));
if(T==NULL)exit(OVERFLOW);
T->data=e;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
}
int GetDepthOfBiTree(BiTree T){
if(T==NULL){
return 0;
}
int ldepth=0,rdepth=0;
else {
ldepth=1+GetDepthOfBiTree(T->lchild);
rdepth=1+GetDepthOfBiTree(T->rchild);
}
if(ldepth>rdepth){
return ldepth;
}
else{
return rdepth;
}
}//getdepth
int main(){
BiTree T;
int depth,numberOfleaves;
CreateBiTree(T);
depth= GetDepthOfBiTree(T);
numberOfLeaves=LeafCount(T);
printf("%d %d\n",depth,numberOfLeaves);
return 0;
}
**
**# ///**二叉树求深度******
int GetDepthOfBiTree ( BiTree T){
int d1=0, d2=0, d;
if(!T)
return 0;
else{
d1=GetDepthOfBiTree(T->lchild)+1;
d2=GetDepthOfBiTree(T->rchild)+1;
}
if(d1>d2)
d=d1;
else
d=d2;
return d;
}
///后序输出第i个结点
void PrintNode(BiTree T){
if(!T){
return 0;
}
PrintNode(T->lchild);
PrintNode(T->rchild);
n--;
if(!n){
printf("%c",T->data);
}
}
///统计二叉树中指定元素节点的个数
int XNodeCountOfBiTree( BiTree T, TElemType x ){
int cnt=0;
if(T==NULL){
cnt = 0;
}
else{
if(T->data==x){
cnt=1+XNodeCountOfBiTree(T->lchild, x)+XNodeCountOfBiTree(T->rchild, x);
}
else{
cnt=XNodeCountOfBiTree(T->lchild, x)+XNodeCountOfBiTree(T->rchild, x);
}
}
return cnt;
}
///二叉树求结点数
int NodeCountOfBiTree(BiTree T){
if(T==NULL){
return 0;
}
else{
return 1+NodeCountOfBiTree(T->lchild)+NodeCountOfBiTree(T->rchild);
}
}
///二叉树求叶子数
int LeafCount(BiTree T){
int cnt=0;
if(T==NULL){
return 0;
}
else{
if( T->lchild==NULL && T->rchild==NULL ){
cnt++;
}
else{
cnt=LeafCount(T->lchild)+LeafCount(T->rchild);
}
}
return cnt;
}
```cpp
typedef int Status;
typedef int ElemType; //假设线性表中的元素均为整型
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
Status ListCreate_L(LinkList &L,int n)
{
LNode *rearPtr,*curPtr; //一个尾指针，一个指向新节点的指针
L=(LNode*)malloc(sizeof (LNode));
if(!L)exit(OVERFLOW);
L->next=NULL; //先建立一个带头结点的单链表
rearPtr=L; //初始时头结点为尾节点,rearPtr指向尾巴节点
for (int i=1;i<=n;i++){ //每次循环都开辟一个新节点，并把新节点拼到尾节点后
curPtr=(LNode*)malloc(sizeof(LNode));//生成新结点
if(!curPtr)exit(OVERFLOW);
scanf("%d",&curPtr->data);//输入元素值
curPtr->next=NULL; //最后一个节点的next赋空
rearPtr->next=curPtr;
rearPtr=curPtr;
}
return OK;
}
//下面是需要实现的函数的声明
int ListLocate_L(LinkList L, ElemType x);
int main()
{
LinkList L;
int n;
int x,k;
scanf("%d",&n); //输入链表中元素个数
if(ListCreate_L(L,n)!= OK) {
printf("表创建失败！！！\n");
return -1;
}
scanf("%d",&x); //输入待查找元素
k=ListLocate_L(L,x);
printf("%d\n",k);
return 0;
}
/* 请在这里填写答案 */
///单链表元素定位
int ListLocate_L( LinkList L, ElemType x ){
LNode *p=L;//创建一个指向头结点的指针
int cnt=1;
while( p->next!=NULL ){
p=p->next;//只要p的下一个结点不为空，就可以更新p
if( p->data==x ){return cnt;}
else{cnt++;}
}
return 0;
}
///删除单链表中最后一个与给定值相等的结点
void ListLocateAndDel_L(LinkList L, ElemType x){
//思路：先定位,用指针px记录最新出现的与x相等的结点的上一个结点，如果后面还有x便继续更新px
//注意：表空？？
LNode *p=L;//创建一个指向头结点的指针
LNode *prior=L;//设置p的前驱指针
LNode *px=L;//设置x结点的前驱节点
while( p->next ){///遍历表中元素，只要表不空就前进，即当前结点的next不空就前进
if(p->next->data==x){///若找到x，则把当前x结点的前驱节点px更新，
px=p;/就是把x所在结点的下一个结点直接连接到x的上一个结点上
}
p=p->next;
}
if(px!=L){//只要最终px更新过，即并非没有更新，并非表中没有x
px->next=px->next->next;
}
}
///带头结点的单链表就地逆置
void ListReverse_L( LinkList &L ){
LNode *p=L->next, *postP; ///设置指针指向新结点
L->next=NULL;
while(p){
postP=p;
p=p->next;
postP->next=L->next;
L->next=postP;
}
}
///两个有序链表序列的合并
/*
//思路：设计创建链表的函数creatList_L,生成两个链表后，
//注意：S1或S2为空，？
// 元素相同
Status creatList_L( LinkList &L ){ //创建链表
LNode *rearPtr, *curPtr; //定义一个尾指针，一个指向当前新结点的指针
L=(LNode*)malloc(sizeof(LNode)); //开辟空间
if(!L) {exit(OVERFLOW);} //检测是否开辟成功
//对开辟好的链表的初始化
L->next=NULL; //把头结点L赋空
rearPtr=L; //初始时头结点就是尾结点，rearPtr指向尾结点
int x; //输入的data
//scanf("%d",&x);
while( scanf("%d",&x)!=EOF && x!=-1 ){ ///每次循环都会开辟一个新结点，并把它拼到尾结点之后
curPtr=(LNode*)malloc(sizeof(LNode)); //每输入一个data便新开辟一个新结点
if(!L) {exit(OVERFLOW);} //检测开辟了么？
curPtr->data=x; //当前输入的值赋给新开辟的结点的数值域
curPtr->next=NULL; //把新结点后面的赋空，方便其作为尾结点时能确保尾结点指针为空
rearPtr->next=curPtr; //把新结点连接到之前的尾结点后面
rearPtr=curPtr; //更新尾结点，把当前结点作为尾结点
}
return OK;
}
//设计把两个链表归并的函数
void mergeList_L( LinkList &La, LinkList &Lb, LinkList &Lc ){///实现两个链表融合成表L_mer
//设置指针pa,pb,pc遍历三个表，比较当前最小元素，小的插入表Lc中pc后的位置
LNode *pa=La->next;
LNode *pb=Lb->next; //让pa，pb分别指向各自头结点的后一个结点
LNode *pc=Lc=La; //让pc指向La的头结点，即把La的头结点作为Lc的头结点，
//La和Lc共用La的头结点
while( pa&&pb ){
if( pa->data < pb->data ){
pc->next=pa;
pc=pa;
pa=pa->next;
}
else{
pc->next=pb;
pc=pb;
pb=pb->next;
}
}
if(pa) pc->next=pa;
if(pb) pc->next=pb;
free(Lb);//释放Lb
}
void printList_L(LinkList L){//输出链表的一个函数
LNode *p=L->next;
if(!p){
printf("NULL");
return;
}
while(p){
if(p->next) printf("%d ",p->data);
else printf("%d",p->data);
p=p->next;
}
}
int main(){
LinkList s1, s2;
LinkList L;
creatList_L(s1);
creatList_L(s2);
mergeList_L(s1,s2,L);
printList_L(L);
return 0;
}
*/
标签：结点,return,LNode,int,无标题,next,NULL 来源： https://blog.csdn.net/monstern3xt/article/details/122021276