图片 8

C语言中的一个关于求正方形个数的算法题目,关于马踏棋盘的递归算法

#includestdio.hintfx[8]={1,2,2,1,-1,-2,-2,-1},fy[8]={2,1,-1,-2,-2,-1,1,2},a[8][8];//Output(卡塔尔国函数举行输出遍历结果voidOutput(卡塔尔国{inti,j;for(i=0;i8;i++,printf(“n”))for(j=0;j8;j++)printf(“%3d”,a[i][j]);}/*Check(卡塔尔(英语:State of Qatar)函数检查xx、yy代表的点是或不是满足条件,满意则赶回1.*条件:在8*8的棋盘边界内,且该点未遍历。*/intcheck(intxx,intyy){if(xx=0xx8yy=0yy8a[xx][yy]==0)return1;return0;}/*x、y表示起源的横坐标和纵坐标,dep为递归的深浅,代表当前马是第多少个马。*Find(卡塔尔函数找出源点的下一个结点,然后以下八个结点为源点,进行递归找出。*当深度到达64时表示遍历完毕,举办输出。*/intFind(intx,inty,intdep){inti,xx,yy;for(i=0;i8;i++){xx=x+fx[i];yy=y+fy[i];if(check(xx,yy)==1)//检查点a[xx][yy]是不是满意条件{a[xx][yy]=dep;if(dep==64卡塔尔{Output(卡塔尔(قطر‎;return1;}if(Find(xx,yy,dep+1卡塔尔国==1卡塔尔国//如若回到的是1,表示遍历完结。return1;else//如果重回的不是1,表示遍历未到位,继续查找。a[xx][yy]=0;}}return0;}voidmain(){/*x和y代表马的坐标。dep为递归的深度,代表当前马是第多少个马*/inti,j,x,y;intdep=1;/*数组a[8][8]意味着棋盘,遍历此前先早先化*/for(i=0;i8;i++)for(j=0;j8;j++)a[i][j]=0;printf(“请输入x,y:n”);scanf(“%d,%d”,x,y);a[x-1][y-1]=1;if(Find(x-1,y-1,2卡塔尔国==1卡塔尔//寻找路线,找到了则赶回1,否则再次来到0。printf(“Success!n”);elseprintf(“Failed!n”);}

那是三个经文的C语言算法标题,标题是交给叁个加以的图样,根据这幅图形里的作标能够求出这幅图形生龙活虎共可有构成多少个长方形。

风流洒脱.课程规划题目及须要

比方说下边那几个图形:

(生龙活虎)课程设计标题

用顺序和二叉链表作存款和储蓄布局达成二叉排序树:

(1)以回车(‘n’卡塔尔国为输入达成标记,输入数列L,生成生龙活虎棵二叉排序树T;

(2)对二叉排序树T作中序遍历,输出结果;

(3)输入元素x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作中序遍历(施行操作2卡塔尔(英语:State of Qatar);不然输出信息“无x”。

 

(二)课程设计须求

在处理难点时,须求从剖析难题的须要动手,按设计抽象数据类型、考虑算法、通过两全实现抽象

数据类型、编写制定上机程序和上机调试等若干步骤完毕难题,最后写出意气风发体化的解析报告。对于稍复杂

的顺序设计,要充裕利用模块化程序设计艺术,自顶向下,稳步细化,在后生可畏体化思路明确的情事下,

伪造所需模块数,各模块产生效能甚至模块之间的数目联系和调用关系。给出首要模块的算法描

述,用流程图或伪代码表示。表达:在安插的进程中,步骤1—步骤4一再是频频实行,
在继续步

骤中开掘难点,往往要求发轫重新解析、设计。

图片 1

二.算法思想

上边是解题思路:首先采纳组合算法,得出那些极端少年老成共能组成多少个有多少个极点构成的四边形,并列出每三个四边形,然后用多个子函数对那四边形进行判断,即使星型就加黄金时代,这样就可以得出少年老成共含有多少个长方形。

(豆蔻年华)二叉排序树的概念

二叉排序树的概念:二叉排序树或许是大器晚成棵空树,
恐怕是后生可畏棵具有如下性质的二叉树:

(1卡塔尔(英语:State of Qatar)各种结点皆有一个看成寻找依据的关键码(key),全部结点的关键码互不相近;

(2卡塔尔若它的左子树非空,则左子树上全体结点的值均低于根结点的值;

(3卡塔尔若它的右子树非空,则右子树上全体结点的值均大于根结点的值;

(4卡塔尔左、右子树本身又各是风流罗曼蒂克棵二叉排序树

实际代码:

(二)二叉排序树的贯彻

#include<stdio.h>
#include<math.h>
/*输入的图样的终点数量,一定要输入正确的终端数量,改进那个值能够拿走分裂的点情形下的
纺锤形数量*/
#define N  13
 
#define B  ((N*(N-1)*(N-2)*(N-3))/(4*3*2))
typedef struct{
  int x;
  int y;
}Point;
typedef struct{
  Point a[4];
}Squre;

1.创立二叉排序树

建二叉树的结点起码应当包括八个域,分别贮存结点的多少data,左子女结点指针leftChild和右子女结点指针rightChild。整个二叉树的链表要有八个表头指针,它指向二叉树的根结点,其成效是当做树的访谈点

从空的二叉排序树起来,经过生机勃勃种类的找寻插入操作之后,生成了风华正茂棵二叉排序树。

依据二叉排序树的概念,创建黄金时代棵二叉排序树的进程是依照待排序种类成分的次第顺序,不断动态变化二叉树的结点,每种插入到二叉树中。若p为根结点指针,b为眼前待插入成分,其经过能够描述为:

若为空树(p=NULL),动态变化一个结点,其数据域为当下待插入成分b,左、右指针域为“空”,p指向该结点。若非空树,相比b与根结点数据data(p)

假设b<data(p卡塔尔国,将b插入左子树中;

即使b≥data(p卡塔尔(قطر‎,将b插入右子树中;

左、右子树的插入方式与二叉排序树的插入格局相像。

不断调用上述的插入进程,直到全体待排序系列均排入后,就产生豆蔻梢头棵二叉排序树。

不问可以见到,构造建设二叉排序树就是每每调用二叉排序树的插入算法。

 
Point dian[N];
Point queue[4];   /*存放矩形坐标*/
Squre tmp;
int k=0;
int  top=0;
void  comb(int s,int n,int m);
int  function(Squre s);

2.二叉排序树的中序遍历

中序遍历二叉树算法的框架是:

若二叉树为空,则空操作;

再不 中序遍历左子树(L);

拜访根结点(V);

中序遍历右子树(哈弗)。

中序遍历二叉树也应用递归函数的点子,先走访左子树,然后访谈根结点,最终访谈右子树.直至全数的结点都被访谈停止

int main(void){
  int i=0;
  
  int num=(int)B;
  printf(“%d”,num);
  for(i=0;i<N;i++){
      printf(“nplease input the %d zuo biao :”,i+1);
      scanf(“%d %d”,&dian[i].x,&dian[i].y);
  }

3.二叉排序树相月素的寻找

在二叉排序树上进行检索,是贰个从根结点带头,沿某三个分段逐层向下实行相比判等的长河。它

能够是二个递归的经过。假如大家想要在二叉排序树中搜求关键码为x的要素,查找进度从根结点

开班。如若根指针为NULL,则查找不成功;不然用给定值x与根结点的关键码进行相比;即便给定

值卓绝根结点的关键码,则查找成功,再次回到寻觅成功的音信,并报告查找到的结点地址。倘使给定

值小于根结点的关键码,则继续递归查找根结点的左子树;不然,递归寻觅根结点的右子树。

  comb(0,N,4);

4.二叉排序树中元素的搜求

对于二叉排序树,删去树上的叁个结点相当于删除有序连串中的四个记下,只要在剔除某些结点之

后依然维持二叉排序树的特色就可以。纵然在二叉排序树上被删除结点为*p(指向结点的指针是

p),其家长结点为*f(结点指针为f),且不失一般性,可设*p是*f的左孩子,若*p结点为叶子结

点,即p和l均为空,只需修正其父母结点指针就可以。若*p结点独有左子树或然只有右子树,只要令

左子树或右子树直接产生其家长结点就可以。若左子树和右子树都不为空,令*p的直接四驱代替*p,

然后从二叉排序树中去除它的直白四驱,就能够。

  printf(“the sum of sibianxing are %dn”,k);
  getch();
  return 0;
}
/*决断是或不是圆柱形,假如重返1,不然再次回到0*/
int function(Squre s){
    int e,b,c,d,k;
    e=pow((s.a[0].x-s.a[1].x),2)+pow((s.a[0].y-s.a[1].y),2);
    b=pow((s.a[0].x-s.a[2].x),2)+pow((s.a[0].y-s.a[2].y),2);
    if(e>b){ /*e作为对角线存在*/
        
c=pow((s.a[2].x-s.a[1].x),2)+pow((s.a[1].y-s.a[2].y),2);
        
d=pow((s.a[3].x-s.a[1].x),2)+pow((s.a[3].y-s.a[1].y),2);
        
k=pow((s.a[0].x-s.a[3].x),2)+pow((s.a[0].y-s.a[3].y),2);
         if((b==c)&&(c==d)&&(d==k)&&(k==b)&&(e==(b+c)))
             return 1;
    }else if(e==b){
        
c=pow((s.a[1].x-s.a[3].x),2)+pow((s.a[1].y-s.a[3].y),2);
        
d=pow((s.a[2].x-s.a[3].x),2)+pow((s.a[2].y-s.a[3].y),2);
        
k=pow((s.a[1].x-s.a[2].x),2)+pow((s.a[1].y-s.a[2].y),2);
         if((e==c)&&(c==d)&&((e+b)==k))
             return 1;
    }else {    /*b作为对角线存在*/
        
c=pow((s.a[2].x-s.a[1].x),2)+pow((s.a[1].y-s.a[2].y),2);
        
d=pow((s.a[3].x-s.a[2].x),2)+pow((s.a[3].y-s.a[2].y),2);
        
k=pow((s.a[0].x-s.a[3].x),2)+pow((s.a[0].y-s.a[3].y),2);
         if((e==c)&&(c==d)&&(d==k)&&(k==e)&&(b==(e+c)))
             return 1;
    }
    return 0;
}
/*结缘算法:用于获取大概构成圆锥形的矩形集合
 m代表选用的个数正是构成数C(m,n卡塔尔,从n中采取m个点
 并回到星型数量*/
void   comb(int s,int n,int m)
{
    int i,j=0;
    if(s>n) return  ;
    if(top==m) {
       for(i=0;i<m;i++){
           tmp.a[i]=queue[i];
    }
     j=function(tmp);
     if(j==1){
       k++;
     }
       return  ;
    }
    queue[top++]=dian[s];
    comb(s+1,n,m);
    top–;
    comb(s+1,n,m);
}

三.算法思想

 

(生龙活虎)程序设计观念

次第首要设计了多个效果与利益:首先是创设二叉排序树,完结后现身职务菜单,以数字代码鲜明,二叉

排序树的中序遍历和寻找,删除步骤,最后成功,结束。

例如…

(二)程序模块

1.二叉链表构造(BST),C

#include

#include

typedef int ElementType;

typedef struct TNode *Position;

typedef Position BinTree;

struct TNode{

ElementType Data;

BinTree Left;

BinTree Right;

};

void PreorderTraversal( BinTree BST );

void InorderTraversal( BinTree BST );

BinTree Insert( BinTree BST, ElementType X);

BinTree Delete( BinTree BST, ElementType X);

Position Find( BinTree BST, ElementType X);

Position FindMin( BinTree BST );

Position FindMax( BinTree BST );

void solve( BinTree BST );

int calculateASL( BinTree BST,double*s,double *j,int i );

int main()

{

BinTree BST, MinP, MaxP, Tmp;

ElementType X;

int number,N, i;

BST = NULL;

scanf(“%d”, &N);

for ( i=0; i

scanf(“%d”, &X);

BST = Insert(BST, X);

}

printf(“Preorder:”); PreorderTraversal(BST);printf(“n”);

/*MinP = FindMin(BST);

MaxP = FindMax(BST);

scanf(“%d”, &N);

for( i=0; i

scanf(“%d”, &X);

Tmp = Find(BST, X);

if (Tmp == NULL) printf(“%d is not foundn”, X);

else {

printf(“%d is foundn”, Tmp->Data);

if (Tmp==MinP) printf(“%d is the smallest keyn”,Tmp->Data);

if (Tmp==MaxP) printf(“%d is the largest keyn”,Tmp->Data);

}

}

scanf(“%d”, &N);

for( i=0; i

scanf(“%d”, &X);

BST = Delete(BST, X);

}*/

printf(“Inorder:”); InorderTraversal(BST);printf(“n”);

double s=0,j=0;

int k=0;

calculateASL(BST,&s,&j,k);

printf(“ASL=%0.4fn”,s/j);

solve(BST);

return 0;

}

void PreorderTraversal( BinTree BST )

{

if( BST ) {

printf(” %d”, BST->Data);

PreorderTraversal( BST->Left );

PreorderTraversal( BST->Right );

}

}

void InorderTraversal( BinTree BST )

{

if( BST ) {

InorderTraversal( BST->Left );

printf(” %d”, BST->Data);

InorderTraversal( BST->Right );

}

}

Position Find( BinTree BST, ElementType X )

{

if( !BST ) return NULL; /*找出未果*/

if( X > BST->Data ) {

return Find(BST->Right,X );/*在右子树中.继续查找*/

}

else if( X < BST->Data ){

return Find( BST->Left,X ); /*在左子树中继续搜寻*/

}

else /* X == BST->Data */

return BST; /*检索成功,再次来到结点的找到结点的地址*/

}

Position FindMin( BinTree BST )

{

if(BST){

while(BST->Left){

BST=BST->Left;

}

}

return BST;

}

Position FindMax( BinTree BST )

{

if(BST ){

while( BST->Right ){

BST = BST->Right;

}/*沿右分支继续搜寻,直到最右叶结点*/

}

return BST;

}

BinTree Insert( BinTree BST, ElementType X)

{

if( !BST ){ /*若原树为空,生成并赶回一个结点的二叉搜索树*/

BST = (BinTree)malloc(sizeof(struct TNode));

BST->Data = X;

BST->Left = NULL;

BST->Right = NULL;

}

else { /*始发找要插入成分的职责*/

if( X < BST->Data )

BST->Left = Insert( BST->Left, X );/*递归插入左子树*/

elseif( X > BST->Data )

BST->Right = Insert( BST->Right,X ); /*递归插入右子树*/

/* else X已经存在,什么都不做*/

}

return BST;

}

BinTree Delete( BinTree BST, ElementType X) {

BinTree head=BST;

BinTree t=Find(BST,X);

if(!t) {

printf(“Not Foundn”);

return BST;

}

BinTree m=FindMax(t->Left);

if(m卡塔尔 {//左子树管理

t->Data=m->Data;

if(t->Left==m)t->Left=m->Left;

else {

t=t->Left;

while(t->Right!=m)t=t->Right;

t->Right=m->Left;

}

}else {

m=FindMin(t->Right);

if(m卡塔尔(قطر‎ {//左子树为空时

t->Data=m->Data;

if(t->Right==m)t->Right=m->Right;

else {

t=t->Right;

while(t->Left!=m)t=t->Left;

t->Left=m->Right;

}

} else { //当其为叶节点时

if(BST==t)return NULL;

while(BST) {

if(BST->Data>=t->Data){

if(BST->Left==t)BST->Left=NULL;

BST=BST->Left;

} else {

if(BST->Right==t)BST->Right=NULL;

BST=BST->Right;

}

}

}

}

// free(t);

return head;

}

void solve( BinTree BST )

{

ElementType X;

Position tmp;

printf(“which element will you delete:”);

scanf(“%d”,&X);

tmp = Find( BST,X );

if(tmp ==NULL)printf(“thereis not X!n”);

else{

BST = Delete( BST, X );

InorderTraversal(BST);

}

}

int calculateASL(BinTree BST,double

*s,double *j,int i) /*计算平均查找长度*/

{

if(BST){

i++;

*s=*s+i;

if(calculateASL(BST->Left,s,j,i)){

(*j)++;

if(calculateASL(BST->Right,s,j,i)){

i–;

return(1);

}

}

}

else return(1);

2.顺序存款和储蓄(BST),C

#include”stdio.h”

#include”malloc.h”

#include”windows.h”

#define endflag 999999

#define N 1000

int b[N];

typedef struct

{

intdata;

intother;

intflag1;

}Link;

void Build(Link a[N])

{

intw,i,j,k;

for(i=0;i<=N;i++){

a[i].flag1=0;

a[i].data=0;

}

printf(“nttt请输入树的根结点:”卡塔尔国;

scanf(“%d”,&a[1].data);

a[1].flag1=1;

printf(“nttt请输入结点个数:”卡塔尔国;

scanf(“%d”,&k);

for(j=1;j<=k;j++){

printf(“nttt请输入结点的数值:”卡塔尔(英语:State of Qatar);

scanf(“%d”,&w);

printf(“nttt第%d位: %d”,j,w);

a[0].data=w;

a[0].flag1=1;

i=1;

if(a[0].data

loop:if(a[2*i].flag1==0){

a[2*i].data=a[0].data;

a[2*i].flag1=a[0].flag1;

}

if(a[2*i].flag1==1){

i=2*i;

if(a[0].data

if(a[0].data>a[i].data)goto loop1;

}

}

if(a[0].data>a[i].data){

loop1:if(a[2*i+1].flag1==0){

a[2*i+1].data=a[0].data;

a[2*i+1].flag1=a[0].flag1;

}

if(a[2*i+1].flag1==1){

i=2*i+1;

if(a[0].data

gotoloop;

if(a[0].data>a[i].data)

gotoloop1;

}

}

}

}

void Sdel(Link a[N])

{

inti,flag=0,q,number=1,j=1;

printf(“nttt请输入需求删除的结点的数值:”卡塔尔;

scanf(“%d”,&q);

for(i=1;i<=N;i++)

if(a[i].data==q){

a[i].data=0;

printf(“nttt已删除%d: “,q);

flag=1;

for(i=1;i<=N;i++){

if(a[i].data!=0){

b[j]=a[i].data;

j++;

number++;

}

}

for(i=1;i<=N;i++){

a[i].flag1=0;

a[i].data=0;

}

a[1].data=b[1];

a[1].flag1=1;

for(j=2;j<=number-1;j++){

a[0].data=b[j];

a[0].flag1=1;

i=1;

if(a[0].data

loop:if(a[2*i].flag1==0){

a[2*i].data=a[0].data;

a[2*i].flag1=a[0].flag1;

}

if(a[2*i].flag1==1){

i=2*i;

if(a[0].data

if(a[0].data>a[i].data)goto loop1;

}

}

if(a[0].data>a[i].data){

loop1:if(a[2*i+1].flag1==0){

a[2*i+1].data=a[0].data;

a[2*i+1].flag1=a[0].flag1;

}

if(a[2*i+1].flag1==1){

i=2*i+1;

if(a[0].data

if(a[0].data>a[i].data)goto loop1;

}

}

}

printf(“nttt展现已经删除结点后的多寡n”);

for(i=1;i

if(a[i].data!=0){

printf(“nttt坐落于二叉排序树的第%d位的数量为: “,i卡塔尔(英语:State of Qatar);

printf(“->%dnn”,a[i].data);

}

}

}

if(flag==0)printf(“nnnttt空中楼阁该结点,不可能去除n”);

}

int main()

{

inti,flag=0,ch=0;

Linka[N];

printf(“n1:营造二叉排序树并中序遍历输出”卡塔尔;

printf(“n2:输入三个要素,删除后重构二叉排序树并中序输出”卡塔尔(قطر‎;

while(ch==ch){

scanf(“%d”,&ch);

switch(ch){

case0:exit(0);

case1:printf(“ttt请输入新闻n”);

Build(a);

printf(“n”);

for(i=1;i

if(a[i].data!=0){

printf(“nttt坐落于二叉排序树的第%d位的数值为:”,i卡塔尔国;

printf(“->%dnn”,a[i].data);

}

}

case2:printf(“输入成分x,查找二叉排序树T,若存在含x的结点,则删除该结点并作中序遍历,不然输出无x:”卡塔尔;

Sdel(a);

break;

default:

printf(“无此结点n”);

break;

}

}

return0;

}

3.二叉链表(AVL),C

#include

#include

#include

#include

using namespace std;

typedef struct TreeNode *AvlTree;

typedef struct TreeNode *Position;

struct TreeNode

{

int Data;

AvlTree Left;

AvlTree Right;

int Height;

};

void PreorderTraversal( AvlTree AVL )

{

if( AVL ) {

printf(“%d “, AVL->Data);

PreorderTraversal( AVL->Left );

PreorderTraversal( AVL->Right);

}

}

void InorderTraversal( AvlTree AVL )

{

if( AVL ) {

InorderTraversal( AVL->Left );

printf(“%d “, AVL->Data);

InorderTraversal( AVL->Right);

}

}

int calculateASL(AvlTree AVL,double

*s,double *j,int i) /*总计平均查找长度*/

{

if(AVL){

i++;

*s=*s+i;

if(calculateASL(AVL->Left,s,j,i)){

(*j)++;

if(calculateASL(AVL->Right,s,j,i)){

i–;

return(1);

}

}

}

else return(1);

}

AvlTree Insert(int x, AvlTree T卡塔尔(英语:State of Qatar);//插入新节点,供给时调治

Position SingleRotateWithLeft(Positiona);//左单旋

Position SingleRotateWithRight(Positionb);//右单旋

Position DoubleRotateWithLeft(Positiona);//左右旋

Position DoubleRotateWithRight(Positionb);//右左旋

int Max(int x1, int x2卡塔尔(英语:State of Qatar);//重返多少个int中十分的大的

int Height(Position P卡塔尔国;//重回叁个节点的惊人

int main()

{

int n, x;

AvlTree T = NULL;

scanf(“%d”, &n);

for (int i = 0; i < n; i++)

{

scanf(“%d”, &x);

T = Insert(x, T);

}

printf(“Preorder:”);

PreorderTraversal(T);printf(“n”);

printf(“Inorder:”);

InorderTraversal(T);printf(“n”);

///printf(“%dn”, T->Data卡塔尔(قطر‎;//打字与印刷根节点的值

double s=0,j=0;

int k=0;

calculateASL(T,&s,&j,k);

printf(“ASL=%0.4fn”,s/j);

return 0;

}

AvlTree Insert(int x, AvlTree T)

{

if (T == NULL)

{

T = (AvlTree)malloc(sizeof(struct TreeNode));

T->Data = x;

T->Left = T->Right = NULL;

T->Height = 0;

}

else if (x < T->Data卡塔尔(قطر‎//向左子树插入

{

T->Left = Insert(x, T->Left);

if (Height(T->Left) – Height(T->Right) == 2)//需调整

{

if (x < T->Left->Data)

T = SingleRotateWithLeft(T);

else

T = DoubleRotateWithLeft(T);

}

}

else if (x > T->Data卡塔尔(英语:State of Qatar)//向右子树插入

{

T->Right = Insert(x, T->Right);

if (Height(T->Right) – Height(T->Left) == 2)//需调整

{

if (x >T->Right->Data)

T = SingleRotateWithRight(T);

else

T = DoubleRotateWithRight(T);

}

}

/*else值为x的节点已经存在树中,无需插入*/

/*履新节点高度*/

T->Height = Max(Height(T->Left), Height(T->Right)) + 1;

return T;

}

Position SingleRotateWithLeft(Position a)

{

Position b = a->Left;

a->Left = b->Right;

b->Right = a;

//更新a, b节点中度

a->Height = Max(Height(a->Left), Height(a->Right)) + 1;

b->Height = Max(Height(b->Left), Height(b->Right)) + 1;

return b;/*新的根节点*/

}

Position SingleRotateWithRight(Position b)

{

Position a = b->Right;

b->Right = a->Left;

a->Left = b;

//更新a,b节点中度

a->Height = Max(Height(a->Left), Height(a->Right)) + 1;

b->Height = Max(Height(b->Left), Height(b->Right)) + 1;

return a;/*新的根节点*/

}

Position DoubleRotateWithLeft(Position a)

{

a->Left = SingleRotateWithRight(a->Left);

return SingleRotateWithLeft(a);

}

Position DoubleRotateWithRight(Position b)

{

b->Right = SingleRotateWithLeft(b->Right);

return SingleRotateWithRight(b);

}

int Max(int x1, int x2)

{

return (x1 > x2) ? x1 : x2;

}

int Height(Position P)

{

if (P == NULL卡塔尔(قطر‎//空节点中度为-1

return -1;

return P->Height;

}

四.算法观念

(意气风发)程序调试

(1)二叉链表存款和储蓄(BST):

图片 2

(2)顺序存储(BST卡塔尔(英语:State of Qatar):

图片 3

图片 4

图片 5

图片 6

图片 7

(3)二叉链表存款和储蓄(AVL)

图片 8

(二)测量试验结果剖析

输入风姿洒脱串数据,进行中序遍历,输入成分x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作

中序遍历(实践操作2卡塔尔;不然输出新闻“无x”。验证结果准确,表明其相符算法设计的要求:(1卡塔尔国精确

性、可读性、强壮性、效用与低积累量供给.要写多少个上流的算法,就亟须思考其时间复杂度(它

代表随难题的规模n的增大,算法实施时间的增进率和f(n)的增加率相通)和空中复杂度。遍历

二叉树的算法中的基本操作是访谈结点,则无论按那一次次序进行遍历,对含n个结点的二叉树,

其时间复杂度为O(n)。所需补助空间为遍历进度中栈的最大体量,即树的纵深log(n卡塔尔(英语:State of Qatar),最坏情状

下为n,则空间复杂度也为O(n)。

发表评论

电子邮件地址不会被公开。 必填项已用*标注