二叉排序树的实现(c语言)

Posted 2023-04-17

二叉排序树的实现
悬赏分：20 - 解决时间：2007-11-28 18:31
用顺序和二叉链表作存储结构
1．以回车('\n')为输入结束标志,输入数列L，生成一棵二叉排序树T；
2．对二叉排序树T作中序遍历，输出结果；
3．输入元素x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作中序遍历(执行操作；否则输出信息“无x”；
要用c语言,求救啊```````

参考技术A #include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct btnode
char data; /*suppose the data field's type is char*/
struct btnode *lchild; /*left pointer field */
struct btnode *rchild; /*right pointer field */
NODE;
void main()
NODE *root,*q,n;
NODE *create(NODE *p);
void preorder(NODE *root);
void inorder(NODE *root);
void postorder(NODE *root);
int t;
q=&n;
root=create(q);
printf("At the first,we create a tree\n");
printf("Please input nodes of tree\n");
if (root==NULL) printf("It's an empty tree!\n");
else

printf("\n1.The preordetraverse \n");
printf(" 2.The inordertraverse \n");
printf(" 3.The postordertraverse \n");
printf(" Please choose a kind of order\n");
scanf("%d",&t);
switch (t)

case 1: preorder(root); break;
case 2: inorder(root); break;
case 3:postorder(root); break;
default: printf(" The error!");




NODE * create(NODE *p) /*create the structure of binary tree */
char ch;
NODE *t;
scanf("%c",&ch);
if(ch==' ') p=NULL;
else
p->data=ch;
t=(NODE *)malloc(sizeof(NODE));
p->lchild=create(t);
t=(NODE*)malloc(sizeof(NODE));
p->rchild=create(t);

return p;

void preorder(NODE *root) /*travel the tree using preorder */
if (root!=NULL)
printf( " %c", root->data);
preorder(root->lchild);
preorder(root->rchild);

return;

void inorder (NODE *root) /*travel the tree using inorder */
if (root!=NULL)
inorder(root->lchild);
printf(" %c ", root->data);
inorder(root->rchild);

return;

void postorder(NODE *root) /*travel the tree using postorder */
if (root!=NULL)
postorder (root->lchild);
postorder (root->rchild);
printf(" %c ", root->data);

return;
参考技术B 在我写完程序之后，我又在网上找到了一段代码，好像比我的写得好多了，也给你吧，随便你用哪个了。这个代码在最下面。
前面发的是我自己写的代码，也基本能实现你的功能。
VC下通过。
代码自己对齐吧。
#include <stdio.h>

struct node

node(int i):data(i),left(NULL),right(NULL)
int data;
node *left; //左孩子结点
node *right; //右孩子结点
void inorder(node *&root) //中序遍历，符合升序输出

if(root!=NULL)

inorder(root->left);
printf("%d ",root->data);
inorder(root->right);


void insert(node *&ptr,int item) //在查找树中插入元素

if(ptr==NULL)
ptr=new node(item);
else if(item<ptr->data)
insert(ptr->left,item);
else insert(ptr->right,item);

node *find(node *&ptr,int item) //在查找树中查找元素,找到返回所在结点指针，找不到返回空指针。

if(ptr==NULL)
return NULL;
if(ptr->data==item)
return ptr;
else if(item<ptr->data)
find(ptr->left,item);
else find(ptr->right,item);

node *&findy(node *&ptr,int item) //在查找树中查找肯定存在的元素,并返回其引用

if(ptr->data==item)
return ptr;
else if(item<ptr->data)
findy(ptr->left,item);
else findy(ptr->right,item);

void dele(node *&ptr) //删除值为item所在结点

if(ptr->left==NULL&&ptr->right==NULL)
ptr=NULL;
else if(ptr->right==NULL)
ptr=ptr->left;
else
ptr=ptr->right;

;

int main()

int t,i=0,j;
printf("输入数字个数(结点个数):");
scanf("%d",&t);
printf("输入%d个数字，数字之间用空格隔开:",t);
scanf("%d",&j);
node *x=new node(j);
for(;i<t-1;i++)

scanf("%d",&j);
x->insert(x,j);

printf("中序遍历为:");
x->inorder(x); //作中序遍历
printf("\n输入要删除的结点元素值(输入-1程序结束):");
scanf("%d",&j);
while(j!=-1)

node *t=x->find(x,j); //定位结点
if(t!=NULL)

node *&y=x->findy(x,j);
x->dele(y);
printf("中序遍历为:");
x->inorder(x);

else
printf("无%d",j);
printf("\n输入要删除的结点元素值(输入-1程序结束):");
scanf("%d",&j);

return 0;

附测试数据一组。
5
22 33 8 55 44
33
44
33
23
-1
经测试均正确。
有什么不明白可M我或留言。

以下是我在网上找到的代码。
#include<stdio.h>
#include<stdlib.h>

typedef struct Tnode
int data; /*输入的数据*/
struct Tnode *lchild,*rchild; /*结点的左右指针，分别指向结点的左右孩子*/
*node,BSTnode;
searchBST(node t,int key,node f,node *p) /*查找函数*/

if(!t) *p=f;return (0); /*查找不成功*/
else if(key==t->data) *p=t;return (1); /*查找成功*/
else if(key<t->data) searchBST(t->lchild,key,t,p); /*在左子树中继续查找*/
else searchBST(t->rchild,key,t,p); /*在右子树中继续查找*/


insertBST(node *t,int key) /*插入函数*/

node p=NULL,s=NULL;

if(!searchBST(*t,key,NULL,&p)) /*查找不成功*/

s=(node)malloc(sizeof(BSTnode));
s->data=key;
s->lchild=s->rchild=NULL;
if(!p) *t=s; /*被插结点*s为新的根结点*/
else if(key<p->data) p->lchild=s;/*被插结点*s为左孩子*/
else p->rchild=s; /*被插结点*s为右孩子*/
return (1);

else return (0);/*树中已有关键字相同的结点，不再插入*/


inorderTraverse(node *t) /*中序遍历函数*/

if(*t)
if(inorderTraverse(&(*t)->lchild)) /*中序遍历根的左子树*/
printf("%d ",(*t)->data); /*输出根结点*/
if(inorderTraverse(&(*t)->rchild)); /*中序遍历根的右子树*/

return(1) ;


calculateASL(node *t,int *s,int *j,int i) /*计算平均查找长度*/

if(*t)
i++; /*i记录当前结点的在当前树中的深度*/
*s=*s+i; /*s记录已遍历过的点的深度之和*/
if(calculateASL(&(*t)->lchild,s,j,i))/*计算左子树的ASL*/

(*j)++; /*j记录树中结点的数目*/
if(calculateASL(&(*t)->rchild,s,j,i)) /*计算右子树的ASL*/
i--; return(1);

else return(1);


node Delete(node t,int key) /*删除函数*/

node p=t,q=NULL,s,f;
while(p!=NULL) /*查找要删除的点*/

if(p->data==key) break;
q=p;
if(p->data>key) p=p->lchild;
else p=p->rchild;

if(p==NULL) return t; /*查找失败*/
if(p->lchild==NULL) /*p指向当前要删除的结点*/

if(q==NULL) t=p->rchild; /*q指向要删结点的父母*/
else if(q->lchild==p) q->lchild=p->rchild; /*p为q的左孩子*/
else q->rchild=p->rchild;/*p为q的右孩子*/
free(p);

else /*p的左孩子不为空*/
f=p;
s=p->lchild;
while(s->rchild) /*左拐后向右走到底*/

f=s;
s=s->rchild;

if(f==p) f->lchild=s->lchild; /*重接f的左子树*/
else f->rchild=s->lchild; /*重接f的右子树*/
p->data=s->data;
free (s);

return t;

int balanceBST(node t,int *i) /*判断是否为平衡二叉树的函数*/

int dep1,dep2;
if(!t) return(0);
else
dep1=balanceBST(t->lchild,i);
dep2=balanceBST(t->rchild,i);

if((dep1-dep2)>1||(dep1-dep2)<-1) *i=dep1-dep2;/*用i值记录是否存在不平衡现象*/
if(dep1>dep2) return(dep1+1);
else return(dep2+1);

void main()

node T=NULL;
int num;
int s=0,j=0,i=0;
int ch=0;
node p=NULL;
printf("输入一串数，每个数以空格分开，最后一个数为0作结束:");
do
scanf("%d",&num);
if(!num) printf("完成输入!\n");
else insertBST(&T,num);
while(num);
printf("\n\n---主程序菜单---\n"); /*主程序菜单*/
printf("\n 0: 退出" );
printf("\n 1: 中序输出");
printf("\n 2: 树的平均查找长度ASL");
printf("\n 3: 删除元素");
printf("\n 4: 判断是否平衡树");
while(ch==ch)

printf("\n 选择一个功能以继续:");
scanf("%d",&ch);
switch(ch)
case 0: exit(0); /*0－－退出*/
case 1: printf(" 中序遍历输出结果为:\n ");
inorderTraverse(&T); /*1－－中序遍历*/
break;
case 2: s=0;j=0;i=0;
calculateASL(&T,&s,&j,i); /*2－－计算平均查找长度*/
printf(" ASL=%d/%d",s,j);
break;
case 3: printf(" 输入一个数以删除结点:");
scanf("%d",&num); /*3－－删除某个结点*/
if(searchBST(T,num,NULL,&p))

T=Delete(T,num);
printf(" 删除成功!\n ");
inorderTraverse(&T);

else printf(" 无%d",num);
break;
case 4: i=0;
balanceBST(T,&i); /*判断是否为平衡二插树*/
if(i==0) printf(" 是平衡树");
else printf(" 不是!");
break;
default: printf("因你的输入错误，请重新输入\n");
break; /*输入无效字符*/

堆排序（C语言实现）

堆排序）

• 概念
• 算法实现
• 后续

概念

1. 堆排序要结合顺序存储的完全二叉树的特性进行学习。
   对于完全二叉树而言：

• 结点 i 的左孩子是 2i
• 结点 i 的右孩子是 2i+1
• 结点 i 的父节点是 i/2
• 编号 <= n/2的结点都是分支结点

2. n个关键字序列L[1…N]称为堆。
   当且仅当 L(i) >=L(2i) 且 L(i)>=L(2i+1) 可以将该一维数组视为一棵完全二叉树，满足此条件的堆称之为大根堆。大根堆的最大元素存放在根节点，且其任一非根节点的值小于等于其双亲结点值。
   小根堆反之。
3. 堆排序的思路很简单：首先将存放在L[1…N]中的N个元素建成初始堆，由于堆本身的特点（以大根堆为例），堆顶元素就是最大值。输出堆顶元素后，通常将堆底元素送入堆顶，此时根节点已不满足大顶堆的性质，对被破坏，将堆顶元素向下调整使其继续保持大顶堆的性质，再输出堆顶元素。如此重复，直到堆中仅剩一个元素为止。
4. 构建初始堆的方法：先对完全二叉树的最右下边的子树调整，使其成为堆（如果此节点的孩子有比他大的，则将最大的孩子和父节点调换），之后向前依次对各节点（[N/2]-1~1）为根的子树进行筛选，看该节点是否大于其左右孩子的值，若不大于则交换，交换后可能会破坏下一级的堆，于是采用上述方法继续构建下一级的堆，直到以该节点为根的子树构成堆为止。反复利用上述调整堆的方法建堆，直到根节点。
   

算法实现

#include <stdio.h>
#include <windows.h>
#include <stdint.h>
void BuildMaxHeap(int a[],int size);
void HeadAdjust(int a[],int k,int size);
void HeapSort(int a[],int size);
int main()

    int k;
      int num[9]=NULL,8,7,4,6,5,1,2,3; 
    int sortsize=sizeof(num)/sizeof(num[0]);
    HeapSort(num,sortsize-1);
    for(k=1;k<sortsize;k++)
    printf("\\n%d",num[k]);
    system("pause");
    return 0;

void BuildMaxHeap(int a[],int size)

    int i;
    for(i=size/2;i>0;i--)
    HeadAdjust(a,i,size);

void HeadAdjust(int a[],int k,int size)

    int i,j;
    int temporary;
    temporary=a[k];
    for(i=2*k;i<=size;i*=2)
    
        if(i<size&&a[i]<a[i+1])
        i++;
        if(temporary>=a[i])break;
        else
            a[k]=a[i];
            k=i;
        
    
    a[k]=temporary;

void HeapSort(int a[],int size)

    int i;
    int temporary;
    BuildMaxHeap(a,size);
    for(i=size;i>1;i--)
    
        temporary=a[i];
        a[i]=a[1];
        a[1]=temporary;
        HeadAdjust(a,1,i-1);
    

后续

欢迎关注公众号：物联网知识