二叉树几道面试题
#include "Stack.h"
#include "Queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int tydata;
typedef struct BStree{
tydata data;
struct BStree *pLeft;
struct BStree *pRight;
}BStree;
BStree *NewBStree(tydata data)
{
BStree *NewNode = (BStree *)malloc(sizeof(BStree));
assert(NewNode);
NewNode->data = data;
NewNode->pLeft = NewNode->pRight = NULL;
return NewNode;
}
int BStreePush(BStree **ppHead, tydata data)
{
BStree *pCur = *ppHead;
BStree *pNewNode = NULL;
BStree *pNext = NULL;
if(*ppHead == NULL)
{
pNewNode = NewBStree(data);
*ppHead = pNewNode;
return -1;
}
if(pCur->data == data)
{
return -1;
}
while( pCur != NULL )
{
pNext = pCur;
if(data < pCur->data)
{
pCur = pCur->pLeft;
if(pCur != NULL && pCur->data == data)
{
return -1;
}
}
else
{
pCur = pCur->pRight;
if(pCur != NULL && pCur->data == data)
{
return -1;
}
}
}
pNewNode = NewBStree(data);
if(data < pNext->data)
pNext->pLeft = pNewNode;
else
pNext->pRight = pNewNode;
return 1;
}
BStree * BStreeFind(BStree* pRoot, int i)
{
if(pRoot == NULL)
return NULL;
if(pRoot->data == i)
return pRoot;
BStree* targrt=NULL;
targrt = BStreeFind(pRoot->pLeft, i);
if(NULL == targrt)
targrt = BStreeFind(pRoot->pRight, i);
return targrt;
}
void BStreeDel(BStree **pHead, tydata data)
{
BStree *parent = *pHead;
BStree *Del = *pHead;
BStree *Cur = *pHead;
assert(pHead);
while(Del)
{
if(Del->data == data)
break;
Cur = Del;
if(Del != NULL && Del->data > data)
{
Del = Del->pLeft;
}
else if(Del != NULL && Del->data < data)
{
Del = Del->pRight;
}
}
if(Del->pRight == NULL)
{
if(Del != *pHead)
{
if(Cur->data > data)
Cur->pLeft = Del->pLeft;
else
Cur->pRight = Del->pLeft;
}
else
{
*pHead = Del->pLeft;
}
free(Del);
}
else if(Del->pLeft == NULL)
{
if(Del != *pHead)
{
if(Cur->data > data)
Cur->pLeft = Del->pRight;
else
Cur->pRight = Del->pRight;
}
else
{
*pHead = Del->pRight;
}
free(Del);
}
else
{
Cur = Del;
Del = Del->pRight;
parent = Cur;
while(Del->pLeft != NULL)
{
parent = Del;
Del = Del->pLeft;
}
Cur->data = Del->data;
if(parent == Cur)
parent->pRight = Del->pRight;
else
parent->pLeft = Del->pRight;
free(Del);
}
}
int BStreePush1(BStree **ppHead,tydata data)
{
if(*ppHead == NULL)
{
*ppHead = NewBStree(data);
return 1;
}
if((*ppHead)->data < data)
{
return BStreePush1(&(*ppHead)->pRight,data);
}
else if((*ppHead)->data > data)
{
return BStreePush1(&(*ppHead)->pLeft,data);
}
return -1;
}
void sequence(BStree *pRoot)
{
Queue queue;
BStree *pTop;
QueueInit(&queue);
QueuePush(&queue, pRoot);
while(!(QueueIsEmpty(&queue)))
{
pTop = (BStree *)QueueFront(&queue);
printf("%d ", pTop->data);
QueuePop(&queue);
if(pTop->pLeft != NULL)
QueuePush(&queue, pTop->pLeft);
if(pTop->pRight != NULL)
QueuePush(&queue, pTop->pRight);
}
printf("\n");
}
BStree* AncestralNode(BStree *pRoot, int i, int j)
{
if(pRoot == NULL)
return NULL;
if(pRoot->data == i || pRoot->data == j)
return pRoot;
BStree *Left, *Right;
Left = AncestralNode(pRoot->pLeft, i, j);
Right = AncestralNode(pRoot->pRight, i, j);
if(Left != NULL && Right != NULL)
return pRoot;
if(Left)
return left;
else
return Right;
}
BStree *AncestralNode(BStree *pRoot, int i, int j)
{
if(pRoot == NULL)
return NULL;
if(pRoot->data == i || pRoot->data == j)
return pRoot;
BStree *ipLeft = BStreeFind(pRoot->pLeft, i);
BStree *ipRight= BStreeFind(pRoot->pRight, i);
BStree *jpLeft = BStreeFind(pRoot->pLeft, j);
BStree *jpRight= BStreeFind(pRoot->pRight, j);
if((ipLeft && jpRight) ||(ipRight && jpLeft) )
return pRoot;
else if(ipLeft && jpLeft)
return AncestralNode(pRoot->pLeft, i, j);
else if(ipRight && jpRight)
return AncestralNode(pRoot->pRight, i, j);
else
return NULL;
}
*/
BStree* arr2[20] = {};
BStree* arr1[20] = {};
void * AncestralNode(BStree *pRoot, int i, int j)
{
int k;
BStree *pCur = pRoot;
BStree *pTop;
Stack stack;
BStree *pLast;
memset(arr1, 0x00, sizeof(arr1));
memset(arr2, 0x00, sizeof(arr2));
StackInit(&stack);
while(pCur || !(StackIsEmpty(&stack)))
{
while(pCur)
{
StackPush(&stack, pCur);
pCur = pCur->pLeft;
}
pTop = StackTop(&stack);
if(pTop->pRight == NULL || pTop->pRight == pLast)
{
if(pTop->data == i)
{
for(k=0; k<(stack.size); k++)
{
arr2[k] = stack.data[k];
}
}
if(pTop->data == j)
{
for(k=0; k<(stack.size); k++)
{
arr1[k] = stack.data[k];
}
}
pLast = pTop;
StackPop(&stack);
continue;
}
pCur = pTop->pRight;
}
}
int IsBalance(BStree *pRoot)
{
if(pRoot == NULL)
return 1;
int left;
int right;
int lefthight = hight(pRoot->pLeft);
int righthight = hight(pRoot->pRight);
int balance = lefthight - righthight;
left = IsBalance(pRoot->pLeft);
if(left == 0)
return 0;
right = IsBalance(pRoot->pRight);
if(right == 0)
return 0;
if(balance==1 || balance==0 || balance==-1)
return 1;
else
return 0;
}
void IsCompletely(BStree *pRoot)
{
Queue queue;
BStree *qu[30] = {0};
int n,m = 0,flag = 0;
BStree *pTop;
memset(qu, 0x00, sizeof(qu));
QueueInit(&queue);
QueuePush(&queue, pRoot);
qu[m++] = pRoot;
while(!(QueueIsEmpty(&queue)))
{
pTop = (BStree *)QueueFront(&queue);
printf("%d ", pTop->data);
QueuePop(&queue);
if(pTop->pLeft != NULL)
QueuePush(&queue, pTop->pLeft),qu[m++] = pTop->pLeft;
else qu[m++] = NULL;
if(pTop->pRight != NULL)
QueuePush(&queue, pTop->pRight),qu[m++] = pTop->pRight;
else qu[m++] = NULL;
}
printf("\n");
for(n=0; n<m; n++)
{
if(qu[n]!=NULL)
{
printf("%p ", qu[n]);
if(flag == 1)
flag = 3;
}
else
{
printf("NULL ");
if(flag == 0)
flag = 1;
}
}
printf("\n");
if(flag == 3)
printf("NO Comletely\n");
else printf("is Completely\n");
}
int MostFarNode(BStree *pRoot)
{
if(pRoot == NULL)
return 0;
int lefthight = hight(pRoot->pLeft);
int righthight = hight(pRoot->pRight);
int leftAndright = lefthight + righthight;
int left = MostFarNode(pRoot->pLeft);
int right = MostFarNode(pRoot->pRight);
if(leftAndright > left && leftAndright > right)
return leftAndright;
else if(left > right && left > leftAndright)
return left;
else
return right;
}
void image(BStree **pHead)
{
if(*pHead == NULL)
return;
BStree *tmp = (*pHead)->pLeft;
(*pHead)->pLeft = (*pHead)->pRight;
(*pHead)->pRight = tmp;
image(&((*pHead)->pLeft));
image(&((*pHead)->pLeft));
}
BStree *bebulid(char **arr1, char *arr2, int left, int right)
{
if((**arr1 == '\0'))
return NULL;
if(left >= right)
return NULL;
int i = left;
char c = **arr1;
BStree *p = NULL;
while(i < right)
{
if(c == arr2[i])
break;
i++;
}
p = (BStree *)malloc(sizeof(BStree));
p->data = **arr1;
(*arr1)++;
p->pLeft = bebulid(arr1, arr2, left, i);
p->pRight = bebulid(arr1, arr2, i+1, right);
return p;
}
void printarr(BStree *pHead)
{
if(pHead == NULL)
return;
printf("%c ",pHead->data);
printarr(pHead->pLeft);
printarr(pHead->pRight);
}
BStree *DoubleListHead = NULL;
BStree *DoubleList(BStree *pHead,BStree **prev)
{
if(pHead == NULL)
return NULL;
DoubleList(pHead->pLeft, prev);
if((*prev) != NULL){
(*prev)->pRight = pHead;
}
pHead->pLeft = *prev;
if(DoubleListHead == NULL)
DoubleListHead = pHead;
(*prev) = pHead;
DoubleList(pHead->pRight, prev);
}
void prinfDoubleList()
{
BStree *pCur = DoubleListHead;
while(pCur)
{
printf("%d ",pCur->data);
pCur = pCur->pRight;
}
printf("\n");
}
void BStree( void )
{
int i;
BStree *pHead = NULL;
BStree *find = NULL;
char* arr3 = "abdcef";
char* arr4 = "dbaecf";
int right = strlen(arr4);
BStree *prev = NULL;
BStree* bulid = NULL;
BStreePush(&pHead,5);
BStreePush(&pHead,3);
BStreePush(&pHead,4);
BStreePush(&pHead,7);
BStreePush(&pHead,9);
BStreePush(&pHead,1);
BStreePush(&pHead,2);
BStreePush(&pHead,6);
BStreePush(&pHead,12);
BStreePush(&pHead,17);
BStreePush(&pHead,10);
BStreePush1(&pHead,8);
Print(pHead);
printf("\n");
find = BStreeFind(pHead, 2);
if(find != NULL) printf("Find it,the num is %d\n",find->data);
else printf("con't find\n");
printf("BStreeOrder\n"),BStreeOrder(pHead);
printf("MiddleOrder\n"),Middleorder(pHead);
printf("PreOrder\n"),Preorder(pHead);
printf("sequence\n"),sequence(pHead);
AncestralNode(pHead, 2, 17);
if(find != NULL) printf("Find it,the Ancestral is %d\n",find->data);
else printf("con't find\n");
printf("arr1:");
for(i=0; arr1[i]!=NULL; i++) {printf("%d ", arr1[i]->data);}
printf("\n"),printf("arr2:");
for(i=0; arr2[i]!=NULL; i++) {printf("%d ", arr2[i]->data);} printf("\n");
i = IsBalance(pHead);
if(i == 1)
printf("yes\n");
else
printf("no\n");
IsCompletely(pHead);
printf("MostFarNode is %d\n", MostFarNode(pHead));
printf("sequence\n"),sequence(pHead);
bulid = bebulid(&arr3, arr4, 0, right);
printarr(bulid);
printf("\n");
DoubleList(pHead, &prev);
prinfDoubleList();
}
#pragma once
#include "Stack.h"
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
typedef char DataType;
struct BinaryTreeNode {
DataType data;
int left;
int right;
struct BinaryTreeNode *pLeft;
struct BinaryTreeNode *pRight;
};
typedef struct BinaryTreeNode BTNode;
BTNode * BuildTree(DataType array[], int size, int *pIndex)
{
BTNode *Node;
if((*pIndex) >= size)
return NULL;
if(array[*(pIndex)] == '#')
{
(*pIndex)++;
return NULL;
}
Node = (BTNode *)malloc(sizeof(BTNode));
Node->data = array[*pIndex];
assert(Node);
(*pIndex)++;
Node->pLeft = BuildTree(array, size, pIndex);
Node->pRight = BuildTree(array, size, pIndex);
return Node;
}
void PrintPreOrder(BTNode *pRoot)
{
if(pRoot == NULL)
return;
printf("%c ",pRoot->data);
PrintPreOrder(pRoot->pLeft);
PrintPreOrder(pRoot->pRight);
}
void PrintMiddleOrder(BTNode *pRoot)
{
if(pRoot == NULL)
return;
PrintMiddleOrder(pRoot->pLeft);
printf("%c ",pRoot->data);
PrintMiddleOrder(pRoot->pRight);
}
void PrintPostOrder(BTNode *pRoot)
{
if(pRoot == NULL)
return;
PrintPostOrder(pRoot->pLeft);
PrintPostOrder(pRoot->pRight);
printf("%c ",pRoot->data);
}
int TreeNodes(BTNode *pRoot)
{
if(pRoot == NULL)
return 0;
return 1+TreeNodes(pRoot->pLeft)+TreeNodes(pRoot->pRight);
}
int TreeHight(BTNode *pRoot)
{
int a,b;
if(pRoot == NULL)
return 0;
a = TreeHight(pRoot->pLeft)+1;
b = TreeHight(pRoot->pRight)+1;
return a>b?a:b;
}
int TreeLeaf(BTNode *pRoot)
{
if(pRoot == NULL)
return 0;
if(pRoot->pLeft==NULL && pRoot->pRight == NULL)
return 1;
return TreeLeaf(pRoot->pLeft) + TreeLeaf(pRoot->pRight);
}
int TreeOfK(BTNode *pRoot, int k)
{
if(pRoot == NULL)
return 0;
if(pRoot != NULL && k == 1)
return 1;
if(pRoot == NULL && k == 1)
return 0;
return TreeOfK(pRoot->pLeft, k-1) + TreeOfK(pRoot->pRight, k-1);
}
void PrintMiddleOder(BTNode *pRoot)
{
BTNode *cur;
BTNode *top;
Stack stack;
StackInit(&stack);
cur = pRoot;
while(cur != NULL || !StackIsEmpty(&stack))
{
while(cur != NULL)
{
StackPush(&stack,cur);
cur = cur->pLeft;
}
top = StackTop(&stack);
printf("%c",top->data);
StackPop(&stack);
cur = top->pRight;
}
printf("\n");
}
void PrintPreOder(BTNode *pRoot)
{
BTNode *cur;
BTNode *top;
Stack stack;
StackInit(&stack);
cur = pRoot;
while(cur != NULL || !StackIsEmpty(&stack))
{
while(cur != NULL)
{
printf("%c",cur->data);
StackPush(&stack,cur);
cur = cur->pLeft;
}
top = StackTop(&stack);
StackPop(&stack);
cur = top->pRight;
}
printf("\n");
}
void PrintPostOder(BTNode *pRoot)
{
BTNode *cur;
BTNode *top;
Stack stack;
BTNode *last;
StackInit(&stack);
cur = pRoot;
while(cur != NULL || !StackIsEmpty(&stack))
{
while(cur != NULL)
{
StackPush(&stack,cur);
cur = cur->pLeft;
}
top = StackTop(&stack);
if(top->pRight == NULL || top->pRight == last)
{
printf("%c",top->data);
last = StackTop(&stack);
StackPop(&stack);
continue;
}
cur = top->pRight;
}
printf("\n");
}
BTNode *IsInTree(BTNode *pRoot,char data)
{
BTNode *root;
if(pRoot == NULL)
return NULL;
if(pRoot->data == data)
return pRoot;
root = IsInTree(pRoot->pLeft,data);
if(root!=NULL && root->data==data)
return root;
return IsInTree(pRoot->pRight,data);
}
BTNode *CommonNode(BTNode *pRoot,char data1,char data2)
{
BTNode *pLeft;
BTNode *pRight;
if(pRoot == NULL)
return NULL;
if(pRoot->data == data1||pRoot->data ==data2)
return pRoot;
pLeft = CommonNode(pRoot->pLeft, data1, data2);
pRight = CommonNode(pRoot->pRight, data1, data2);
if(pLeft && pRight)
return pRoot;
if(pLeft == NULL)
return pRight;
else
return pLeft;
}
int max = 0;
void MaxLen(BTNode *pRoot)
{
int i = 0;
if(pRoot == NULL)
return;
if(pRoot->pLeft == NULL)
pRoot->left = 0;
if(pRoot->pRight == NULL)
pRoot->right = 0;
if(pRoot->pLeft != NULL)
MaxLen(pRoot->pLeft);
if(pRoot->pRight != NULL)
MaxLen(pRoot->pRight);
if(pRoot->pLeft != NULL)
{
if(pRoot->pLeft->left > pRoot->pLeft->right)
i = pRoot->pLeft->left;
else
i = pRoot->pLeft->right;
pRoot->left = i+1;
}
if(pRoot->pRight != NULL)
{
if(pRoot->pRight->left > pRoot->pRight->right)
i = pRoot->pRight->left;
else
i = pRoot->pRight->right;
pRoot->right = i+1;
}
if(pRoot->left + pRoot->right > max)
max = pRoot->left + pRoot->right;
}
void Changed(BTNode *pRoot, BTNode **prev)
{
if(pRoot == NULL)
return;
Changed(pRoot->pLeft, prev);
if((*prev) != NULL)
(*prev)->pRight = pRoot;
pRoot->pLeft = (*prev);
(*prev) = pRoot;
Changed(pRoot->pRight, prev);
}
BTNode *DListForTree(BTNode *pRoot)
{
BTNode *pHead = pRoot;
BTNode *prev = NULL;
Changed(pRoot, &prev);
while(pHead->pLeft!= NULL)
{
pHead = pHead->pLeft;
}
return pHead;
}
void BTNode()
{
BTNode *DList;
BTNode *pRoot;
BTNode *pNode;
BTNode *pComNode;
char array[] = { 'A', 'B', 'D',
'#', '#', '#', 'C', 'E', '#', '#', 'F' };
int index = 0;
int k = 3;
pRoot = BuildTree(array, sizeof(array) / sizeof(char), &index);
PrintPreOrder(pRoot);
printf("\n");
PrintMiddleOrder(pRoot);
printf("\n");
PrintPostOrder(pRoot);
printf("\n");
printf("数的节点个数为 %d\n",TreeNodes(pRoot));
printf("树的高度为%d\n",TreeHight(pRoot));
printf("叶子节点个数为%d\n",TreeLeaf(pRoot));
printf("第K层的节点个数%d\n",TreeOfK(pRoot,k));
printf("前序打印为");
PrintPreOder(pRoot);
printf("中序打印为");
PrintMiddleOder(pRoot);
printf("后序打印为");
PrintPostOder(pRoot);
pNode = IsInTree(pRoot,'F');
if(pNode !=NULL)
printf("该节点存在地址为%p\n",pNode);
pComNode = CommonNode(pRoot, 'C','D');
printf("公共祖先节点为%c", pComNode->data);
MaxLen(pRoot);
printf("两个节点之间最长的距离为%d\n",max);
printf("前序打印为\n");
DList = DListForTree(pRoot);
printf("转为链表后的输出\n");
while(DList)
{
printf("%c", DList->data);
DList = DList->pRight;
}
printf("\n");
}
#pragma once
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#define CAPACITY 6
int k = 0;
typedef void * typedata;
typedef struct Stack
{
typedata *data;
int size;
int capacity;
}Stack;
void StackInit(Stack *stack)
{
stack->capacity = CAPACITY;
stack->size = 0;
stack->data = (typedata *)malloc(sizeof(typedata)*stack->capacity);
assert(stack->data);
}
void IsDilatation(Stack **stack)
{
Stack *st = *stack;
if (st->size == st->capacity)
{
typedata *New = (typedata *)malloc(sizeof(typedata)*(st->capacity) * 2);
free(st->data);
memcpy(New, st->data, sizeof(typedata)*(st->capacity));
st->data = New;
st->capacity *= 2;
}
}
void StackPush(Stack *stack, typedata data)
{
IsDilatation(&stack);
assert(stack);
stack->data[stack->size++] = data;
}
typedata StackTop(Stack *stack)
{
return stack->data[stack->size - 1];
}
void StackPop(Stack* stack)
{
assert(stack->size>0);
stack->size -= 1;
}
int StackIsEmpty(Stack *stack)
{
return (stack->size == 0) ? 1 : 0;
}
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef void * queuedata;
typedef struct QNode
{
queuedata data;
struct QNode *QNext;
}QNode;
typedef struct Queue
{
QNode *pHead;
QNode *pNext;
int size;
}Queue;
void QueueInit(Queue *q)
{
q->pHead = NULL;
q->pNext = NULL;
q->size = 0;
}
void QueueDestory(Queue *q)
{
QNode *pNode, *pNext;
assert(q);
for(pNode = q->pHead; pNode != NULL; pNode = pNext)
{
pNext = pNode->QNext;
free(pNode);
}
q->pHead = q->pNext = NULL;
q->size = 0;
}
void QueuePush(Queue *q, queuedata data)
{
QNode *New = (QNode *)malloc(sizeof(QNode));
assert(q);
assert(New);
New->data = data;
New->QNext = NULL;
q->size++;
if(q->pHead == NULL)
{
q->pHead = q->pNext = New;
return;
}
q->pNext->QNext = New;
q->pNext = New;
}
void QueuePop(Queue *q)
{
QNode *Qdel = q->pHead;
assert(q->pHead);
q->pHead = Qdel->QNext;
free(Qdel);
q->size--;
if(q->size == 0)
{
q->pHead = q->pNext = NULL;
}
}
queuedata QueueFront(Queue *q)
{
if(q->pHead == NULL)
return NULL;
return q->pHead->data;
}
int QueueSize(Queue *q)
{
assert(q);
return q->size;
}
int QueueIsEmpty(Queue *q)
{
return q->size == 0 ? 1 : 0;
}
int main()
{
void BStree();
void void BTNode();
}