C++博客-我的编程乐园-文章分类-数据结构和算法分析

改正的二叉树操作

刘畅 — Fri, 27 Nov 2009 13:48:00 GMT

二叉树的实验操作：
题目如下：
1．设某二叉树的结点类型为整数类型，以二叉链表形式作为存储结构。试编程实现：
(1) 生成一棵二叉树.
(2) 用递归算法、非递归算法实现二叉树的遍历；
(3) 求度分别为0、1、2的结点的数目,分别用递归算法、非递归算法实现；
(4) 按层次遍历二叉树(提示：使用一个队列实现）；
*(5) 求二叉树的高度(深度)；
*(6) 判断是否为完全二叉树，输出'Yes!'/'No!'；
*(7) 交换每个结点的左右子树；
*(8) 对交换左右子树后的二叉树作中序遍历。
#include
#include
#include
#include
#define ERROR 0
#define OK 1
#define OVERFLOW -2
#define queuesize 20
typedef struct BiTNode{
   int data;
   struct BiTNode *lchild,*rchild; //左右孩子指针
}BiTNode,*BiTree;
typedef struct Queue{
   int front ,rear ;
     BiTree data[queuesize]; //循环队列元素类型为二叉链表结点指针
   int count;
}Queue; //循环队列结构定义

int CreateBiTree(BiTree * T) { //声明的就是一个BiTree类型的指针,通过修改来对main中的T做修改，然后使其指向根结点
// 按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树，
// 构造二叉链表表示的二叉树T。
int ch;
printf("请输入一个根结点的值（如果为空，则输入0）\n");
scanf("%d",&ch);
if (ch==0) (*T)= NULL;
else {
    if (!(*T = (BiTNode *)malloc(sizeof(BiTNode)))) return ERROR;
    (*T)->data = ch;              // 生成根结点
    CreateBiTree(&(*T)->lchild);   // 构造左子树
    CreateBiTree(&(*T)->rchild);   // 构造右子树
}
return OK;
} // CreateBiTree

int PreOrderTraverse(BiTree T) //用递归算法写的遍历函数，按照先序遍历，同时输出结点的值
{
   if(T!=NULL)
   {
       printf("%d ",T->data);
       PreOrderTraverse(T->lchild);
       PreOrderTraverse(T->rchild);
   }
   return OK;
}

int InorderTraverse(BiTree T)
{
   if(T!=NULL)
   {
       InorderTraverse(T->lchild);
       printf("%d ",T->data);
       InorderTraverse(T->rchild);
   }
   return OK;
}
int PreOrderTraverse2(BiTree T) //用非递归的算法写的遍历函数，按照先序遍历，同时输出结点的值
{
   BiTree p,s[20];
   int top=0;
   p=T;
   while((p!=NULL)||(top>0))
   {
       while(p!=NULL)
       {
           printf("%d ",p->data);
           s[++top]=p;
           p=p->lchild;
       }
       p=s[top--];
       p=p->rchild;
   }
   return OK;
}

int get_all_node(BiTree T) //求出总的结点的个数
{
   BiTree p,s[20];
   int num_node=0;
   int top=0;
   p=T;
   while((p!=NULL)||(top>0))
   {
       while(p!=NULL)
       {
           num_node++;
           s[++top]=p;
           p=p->lchild;
       }
       p=s[top--];
       p=p->rchild;
   }
   return num_node;
}

int get_node0_1(BiTree T)//利用递归算法得到度为0的结点的个数
{
   int num1,num2;
   if(T==NULL)
       return 0;
   else
   {
        if((T->lchild==NULL)&&(T->rchild==NULL))
           return 1;
       else
       {
           num1=get_node0_1(T->lchild);
            num2=get_node0_1(T->rchild);
           return (num1+num2);
       }
   }
}
int get_node0_2(BiTree T) //利用非递归算法，同时采用层次遍历的方法，得到度为0的结点
{
     Queue *q;
     BiTree p=T;
   int num=0;
   q=(Queue *)malloc(sizeof(Queue));
   q->front=0;
   q->rear=0;
   q->data[q->rear]=p;
   q->rear++;
   while(q->front < q->rear)
   {
       p=q->data[q->front];
       q->front++;
       if(p->lchild==NULL && p->rchild==NULL)
       {
           num++;
       }
       if(p->lchild!=NULL)
       {
           q->data[q->rear]=p->lchild;
           q->rear++;
       }
       if(p->rchild!=NULL)
       {
           q->data[q->rear]=p->rchild;
           q->rear++;
       }
   }
   return num;
}

int get_node1(BiTree T) //利用总的关系求出度为1的结点的个数
{
   int num=get_all_node(T)-2*get_node0_1(T)+1;
   return num;
}
int get_node1_1(BiTree T)   //非递归算法，同时利用关系求度为1的结点。
{
   int num=get_all_node(T)-2*get_node0_2(T)+1;
   return num;
}
int get_node2(BiTree T) //利用度为2的结点个数与度为0的结点个数的关系得到
{
   int num=get_node0_1(T)-1;
   return num;
}
int get_node2_1(BiTree T)   //非递归算法，同时利用关系求度为2的结点。
{
   int num=get_node0_2(T)-1;
   return num;
}
int get_node(BiTree T)
{
   int get;
   printf("请输入你要查找的结点的度\n");
   printf("1.查询度为0的所有结点的个数\n");
   printf("2.查询度为1的所有结点的个数\n");
   printf("3.查询度为2的所有结点的个数\n");
   scanf("%d",&get);
   switch(get){
   case 1:
      printf("度为0的所有结点的个数是%d\n",get_node0_1(T));
      break;
   case 2:
       printf("度为1的所有结点的个数是%d\n",get_node1(T));
       break;
   case 3:
       printf("度为2的所有结点的个数是%d\n",get_node2(T));
       break;
   }
   return OK;
}
int get_node_1(BiTree T)        //利用非递归算法的实现
{
   int get;
   printf("下面是用非递归算法来查询\n");
   printf("请输入你要查找的结点的度\n");
   printf("1.查询度为0的所有结点的个数\n");
   printf("2.查询度为1的所有结点的个数\n");
   printf("3.查询度为2的所有结点的个数\n");
   scanf("%d",&get);
   switch(get){
   case 1:
      printf("度为0的所有结点的个数是%d\n",get_node0_2(T));
      break;
   case 2:
       printf("度为1的所有结点的个数是%d\n",get_node1_1(T));
       break;
   case 3:
       printf("度为2的所有结点的个数是%d\n",get_node2_1(T));
       break;
   }
   return OK;
}
int LevelOrder(BiTree T)
{    Queue *q;
     BiTree p;
   int flag=0;                      //定义flag为层号
   q=(Queue *)malloc(sizeof(Queue)); //申请循环队列空间
   q->rear=q->front=q->count=0;      //将循环队列初始化为空
   q->data[q->rear]=T;
   q->count++;
   q->rear=(q->rear+1)%queuesize;       //将根结点入队
   while (q->count)                   //若队列不为空，做以下操作
       if(q->data[q->front]){            //当队首元素不为空指针，做以下操作
           p=q->data[q->front];           //取队首元素*p
           printf("%d ",p->data);        //打印*p结点的数据域信息
           ++flag;
           q->front=(q->front+1)%queuesize;
           q->count--;       //队首元素出队
           if (q->count==queuesize)//若队列为队满，则打印队满信息，退出程序的执行
               printf("the queue full!\n");
           else{            //若队列不满，将*p结点的左孩子指针入队
               q->count++;q->data[q->rear]=p->lchild;
               q->rear=(q->rear+1)%queuesize;
           }                        //enf of if
           if (q->count==queuesize)        //若队列为队满，则打印队满信息，退出程序的执行
               printf("the queue full!\n");
           else{                      //若队列不满，将*p结点的右孩子指针入队
               q->count++;q->data[q->rear]=p->rchild;
               q->rear=(q->rear+1)%queuesize;
           }                              //end of if
       }                                //end of if
       else{                          //当队首元素为空指针，将空指针出队
           q->front=(q->front+1)%queuesize;
           q->count--;
       }
       printf("\n");
       return OK;
}      //end of LevelOrder

int height(BiTree T)
{
   BiTree p=T;
   int a,b;
   if(p==NULL)
       return 0;
   else{
       if((p->lchild==NULL)&&(p->rchild==NULL))
            return 1;
    else{
          a=height(p->rchild);
          b=height(p->lchild);
          if(a>b)   return (a+1);
          else    return (b+1);
          }
   }
}

int judge(BiTree T)   //采用递归算法来实现判断是否为完全二叉树
{
      if(T ==NULL)
          return   0;
      if(T->lchild == NULL && T->rchild== NULL)
          return   1;
      if(T->lchild == NULL && T->rchild != NULL||T->lchild!=NULL &&T->rchild==NULL)
          return   0;
      return   judge(T->lchild) & judge(T->rchild);

}

int exchange(BiTree T)
{
     BiTree p=T;
   int exch;
     if(p==NULL)
         return OK;
   else
   {
       if(p->lchild!=NULL && p->rchild!=NULL)
       {
             exch=p->lchild->data;
           p->lchild->data=p->rchild->data;
           p->rchild->data=exch;
           exchange(p->lchild);
           exchange(p->rchild);
       }
       else
       {
           if(p->lchild==NULL)
               exchange(p->rchild);
           else
               exchange(p->lchild);
       }
       return OK;
   }
}

void main()
{
   BiTree T;         //定义一个指向BiTNode结点的指针
   int choice;
   do{
   printf("\n");
   printf("请选择操作：\n");
   printf("1.按照先序的次序生成一颗二叉树\n");
   printf("2.递归算法实现二叉树的先序遍历，输出各结点值\n");
    printf("3.用非递归算法实现二叉树的遍历，输出各结点值\n");
   printf("4.求度分别为0、1、2的结点的数目（递归算法实现）\n");
   printf("5.求度分别为0、1、2的结点的数目（非递归算法实现）\n");
   printf("6.按层次遍历二叉树\n");
   printf("7.求二叉树的高度(深度)\n");
   printf("8.判断是否为完全二叉树，输出\"Yes!\"或\"No!\"\n");
   printf("9.交换每个结点的左右子树,并用先序遍历的方式输出\n");
   printf("10.对交换左右子树后的二叉树作中序遍历\n");
   printf("11.退出\n");
   scanf("%d",&choice);
   switch(choice){
   case 1:
       CreateBiTree(&T);   //创建二叉树
       break;
    case 2:
       PreOrderTraverse(T); //利用递归算法的先序遍历，输出结点值
       break;
   case 3:
       PreOrderTraverse2(T);//利用非递归算法的先序遍历，输出结点值
       break;
   case 4:
       get_node(T); //利用递归算法得到的各个结点的个数
       break;
   case 5:
       get_node_1(T); //利用非递归算法得到的各个结点的个数
       break;
   case 6:
       LevelOrder(T);
       break;
   case 7:
       printf("二叉树的高度为%d\n",height(T));
       break;
   case 8:
       if(judge(T)==0)
           printf("No\n");
       else
           printf("Yes\n");
       break;
    case 9:
         exchange(T);
       PreOrderTraverse(T);
       break;
   case 10:
         InorderTraverse(T);
       break;
   }
   }while(choice!=11);
}

注记：原来的那个函数5有问题，即利用非递归算法求叶子结点的个数。

刘畅 2009-11-27 21:48 发表评论

二叉树的操作

刘畅 — Fri, 27 Nov 2009 13:36:00 GMT

二叉树的实验操作：
题目如下：
1．设某二叉树的结点类型为整数类型，以二叉链表形式作为存储结构。试编程实现：
(1) 生成一棵二叉树.
(2) 用递归算法、非递归算法实现二叉树的遍历；
(3) 求度分别为0、1、2的结点的数目,分别用递归算法、非递归算法实现；
(4) 按层次遍历二叉树(提示：使用一个队列实现）；
*(5) 求二叉树的高度(深度)；
*(6) 判断是否为完全二叉树，输出"Yes!"/"No!"；
*(7) 交换每个结点的左右子树；
*(8) 对交换左右子树后的二叉树作中序遍历。

#include
#include
#include
#include
#define ERROR 0
#define OK 1
#define OVERFLOW -2
#define queuesize 20
typedef struct BiTNode{
   int data;
   struct BiTNode *lchild,*rchild; //左右孩子指针
}BiTNode,*BiTree;
typedef struct Queue{
   int front ,rear ;
     BiTree data[queuesize]; //循环队列元素类型为二叉链表结点指针
   int count;
}Queue; //循环队列结构定义

int CreateBiTree(BiTree * T) { //声明的就是一个BiTree类型的指针,通过修改来对main中的T做修改，然后使其指向根结点
// 按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树，
// 构造二叉链表表示的二叉树T。
int ch;
printf("请输入一个根结点的值（如果为空，则输入0）\n");
scanf("%d",&ch);
if (ch==0) (*T)= NULL;
else {
    if (!(*T = (BiTNode *)malloc(sizeof(BiTNode)))) return ERROR;
    (*T)->data = ch;              // 生成根结点
    CreateBiTree(&(*T)->lchild);   // 构造左子树
    CreateBiTree(&(*T)->rchild);   // 构造右子树
}
return OK;
} // CreateBiTree

int PreOrderTraverse(BiTree T) //用递归算法写的遍历函数，按照先序遍历，同时输出结点的值
{
   if(T!=NULL)
   {
       printf("%d ",T->data);
       PreOrderTraverse(T->lchild);
       PreOrderTraverse(T->rchild);
   }
   return OK;
}

int InorderTraverse(BiTree T)
{
   if(T!=NULL)
   {
       InorderTraverse(T->lchild);
       printf("%d ",T->data);
       InorderTraverse(T->rchild);
   }
   return OK;
}
int PreOrderTraverse2(BiTree T) //用非递归的算法写的遍历函数，按照先序遍历，同时输出结点的值
{
   BiTree p,s[20];
   int top=0;
   p=T;
   while((p!=NULL)||(top>0))
   {
       while(p!=NULL)
       {
           printf("%d ",p->data);
           s[++top]=p;
           p=p->lchild;
       }
       p=s[top--];
       p=p->rchild;
   }
   return OK;
}

int get_all_node(BiTree T) //求出总的结点的个数
{
   BiTree p,s[20];
   int num_node=0;
   int top=0;
   p=T;
   while((p!=NULL)||(top>0))
   {
       while(p!=NULL)
       {
           num_node++;
           s[++top]=p;
           p=p->lchild;
       }
       p=s[top--];
       p=p->rchild;
   }
   return num_node;
}

int get_node0_1(BiTree T)//利用递归算法得到度为0的结点的个数
{
   int num1,num2;
   if(T==NULL)
       return 0;
   else
   {
        if((T->lchild==NULL)&&(T->rchild==NULL))
           return 1;
       else
       {
           num1=get_node0_1(T->lchild);
            num2=get_node0_1(T->rchild);
           return (num1+num2);
       }
   }
}
int get_node0_2(BiTree T) //利用非递归算法得到度为0的结点
{
   int num=0;
   BiTree p=T,s[20];
   int top=0;      //定义一个栈
   while((p!=NULL)||(top>0))
   {
       while(p!=NULL)
       {
           s[++top]=p;
            p=p->lchild;
       }

        {    p=s[--top];
        if(p->rchild==NULL)
        {
            ++num;
        }
        else
            p=p->rchild;
        }
    }
    return num;

}

int get_node1(BiTree T) //利用总的关系求出度为1的结点的个数
{
    int num=get_all_node(T)-2*get_node0_1(T)+1;
    return num;
}
int get_node1_1(BiTree T)   //非递归算法，同时利用关系求度为1的结点。
{
    int num=get_all_node(T)-2*get_node0_2(T)+1;
    return num;
}
int get_node2(BiTree T) //利用度为2的结点个数与度为0的结点个数的关系得到
{
    int num=get_node0_1(T)-1;
    return num;
}
int get_node2_1(BiTree T)   //非递归算法，同时利用关系求度为2的结点。
{
    int num=get_node0_2(T)-1;
    return num;
}
int get_node(BiTree T)
{
    int get;
   printf("请输入你要查找的结点的度\n");
   printf("1.查询度为0的所有结点的个数\n");
   printf("2.查询度为1的所有结点的个数\n");
   printf("3.查询度为2的所有结点的个数\n");
   scanf("%d",&get);
   switch(get){
   case 1:
    printf("度为0的所有结点的个数是%d\n",get_node0_1(T));
    break;
   case 2:
       printf("度为1的所有结点的个数是%d\n",get_node1(T));
       break;
   case 3:
       printf("度为2的所有结点的个数是%d\n",get_node2(T));
       break;
   }
   return OK;
}
int get_node_1(BiTree T)        //利用非递归算法的实现
{
    int get;
    printf("下面是用非递归算法来查询\n");
   printf("请输入你要查找的结点的度\n");
   printf("1.查询度为0的所有结点的个数\n");
   printf("2.查询度为1的所有结点的个数\n");
   printf("3.查询度为2的所有结点的个数\n");
   scanf("%d",&get);
   switch(get){
   case 1:
    printf("度为0的所有结点的个数是%d\n",get_node0_2(T));
    break;
   case 2:
       printf("度为1的所有结点的个数是%d\n",get_node1_1(T));
       break;
   case 3:
       printf("度为2的所有结点的个数是%d\n",get_node2_1(T));
       break;
   }
   return OK;
}
int LevelOrder(BiTree T)
{    Queue *q;
     BiTree p;
    int flag=0;                      //定义flag为层号
    q=(Queue *)malloc(sizeof(Queue)); //申请循环队列空间
    q->rear=q->front=q->count=0;      //将循环队列初始化为空
    q->data[q->rear]=T;
    q->count++;
    q->rear=(q->rear+1)%queuesize;       //将根结点入队
    while (q->count)                   //若队列不为空，做以下操作
        if(q->data[q->front]){            //当队首元素不为空指针，做以下操作
            p=q->data[q->front];           //取队首元素*p
            printf("%d ",p->data);        //打印*p结点的数据域信息
            ++flag;
            q->front=(q->front+1)%queuesize;
            q->count--;       //队首元素出队
            if (q->count==queuesize)//若队列为队满，则打印队满信息，退出程序的执行
                printf("the queue full!\n");
            else{            //若队列不满，将*p结点的左孩子指针入队
                q->count++;q->data[q->rear]=p->lchild;
                q->rear=(q->rear+1)%queuesize;
            }                        //enf of if
            if (q->count==queuesize)        //若队列为队满，则打印队满信息，退出程序的执行
                printf("the queue full!\n");
            else{                      //若队列不满，将*p结点的右孩子指针入队
                q->count++;q->data[q->rear]=p->rchild;
                q->rear=(q->rear+1)%queuesize;
            }                              //end of if
        }                                //end of if
        else{                          //当队首元素为空指针，将空指针出队
            q->front=(q->front+1)%queuesize;
            q->count--;
        }
        printf("\n");
        return OK;
}      //end of LevelOrder

int height(BiTree T)
{
    BiTree p=T;
    int a,b;
    if(p==NULL)
        return 0;
    else{
       if((p->lchild==NULL)&&(p->rchild==NULL))
            return 1;
    else{
        a=height(p->rchild);
          b=height(p->lchild);
        if(a>b)   return (a+1);
        else    return (b+1);
        }
    }
}

int judge(BiTree T)   //采用递归算法来实现判断是否为完全二叉树
{
      if(T ==NULL)
          return   0;
      if(T->lchild == NULL && T->rchild== NULL)
          return   1;
      if(T->lchild == NULL && T->rchild != NULL||T->lchild!=NULL &&T->rchild==NULL)
          return   0;
      return   judge(T->lchild) & judge(T->rchild);

}

int exchange(BiTree T)
{
     BiTree p=T;
    int exch;
     if(p==NULL)
         return OK;
    else
    {
        if(p->lchild!=NULL && p->rchild!=NULL)
        {
             exch=p->lchild->data;
            p->lchild->data=p->rchild->data;
            p->rchild->data=exch;
            exchange(p->lchild);
            exchange(p->rchild);
        }
        else
        {
            if(p->lchild==NULL)
                exchange(p->rchild);
            else
                exchange(p->lchild);
        }
        return OK;
    }
}

void main()
{
    BiTree T;         //定义一个指向BiTNode结点的指针
    int choice;
    do{
    printf("\n");
    printf("请选择操作：\n");
    printf("1.按照先序的次序生成一颗二叉树\n");
    printf("2.递归算法实现二叉树的先序遍历，输出各结点值\n");
    printf("3.用非递归算法实现二叉树的遍历，输出各结点值\n");
    printf("4.求度分别为0、1、2的结点的数目（递归算法实现）\n");
    printf("5.求度分别为0、1、2的结点的数目（非递归算法实现）\n");
    printf("6.按层次遍历二叉树\n");
    printf("7.求二叉树的高度(深度)\n");
    printf("8.判断是否为完全二叉树，输出\"Yes!\"或\"No!\"\n");
    printf("9.交换每个结点的左右子树\n");
    printf("10.对交换左右子树后的二叉树作中序遍历\n");
    printf("11.退出\n");
    scanf("%d",&choice);
    switch(choice){
    case 1:
        CreateBiTree(&T);   //创建二叉树
        break;
    case 2:
        PreOrderTraverse(T); //利用递归算法的先序遍历，输出结点值
        break;
    case 3:
        PreOrderTraverse2(T);//利用非递归算法的先序遍历，输出结点值
        break;
    case 4:
        get_node(T); //利用递归算法得到的各个结点的个数
        break;
    case 5:
        get_node_1(T); //利用非递归算法得到的各个结点的个数
        break;
    case 6:
        LevelOrder(T);
        break;
    case 7:
        printf("二叉树的高度为%d\n",height(T));
        break;
    case 8:
        if(judge(T)==0)
            printf("No\n");
        else
            printf("Yes\n");
        break;
    case 9:
         exchange(T);
        break;
    case 10:
         InorderTraverse(T);
        break;
    }
    }while(choice!=11);
}

刘畅 2009-11-27 21:36 发表评论

线性表的链式存储结构

刘畅 — Fri, 27 Nov 2009 13:35:00 GMT

设某线性表数据元素的类型为整型，以链表结构存储线性表。试编程实现：

(1) 输入数据元素，以先进先出形式创建单链表

(2) 销毁单链表

(3) 线性表置空

(4) 求线性表长度

(5)在第i个数据元素前插入新的元素

(6) 删除第i个元素

(7) 显示线性表中的全部元素

(8) 求最大元素的值和平均值

#include
#include
#include
#include
#define ERROR     0
#define OK        1
#define OVERFLOW -2
typedef struct LNode{
   int data;
   struct LNode *next;
}LNode,*LinkList;

int Create_List(LinkList L,int length)
{//创建一个带表头结点的大小为n个的单链表
   int i;
   LinkList p, tail; //声明一定要在前面，否则会出错
        tail=L;
   for(i=0;i   {
        p=(LinkList)malloc(sizeof(LNode));
       printf("请输入%d个数据\n",length);
       scanf("%d",&p->data);
       p->next=NULL;
        tail->next=p;
       tail=tail->next;
   }
       return OK;
}

int display_all(LinkList L,int length) //依赖于长度，可是却不定，长度函数有问题。
{//显示所有的数据元素
   int i;
   printf("线性表的全部数据元素如下：\n");
   for(i=0;i   {
       printf("%d ",L->next->data);
       L=L->next;
   }
   printf("\n");
   return OK;
}

int length_L(LinkList L) //有问题
{//求得线性表的长度
   int length=0;
   LinkList p=L;
   while(p!=NULL)
   {
       ++length;
       p=p->next;
   }
   return length;
}

int ListInsert(LinkList L,int i ,int *e)
{//插入元素
   LinkList p=L,s;
   int j=0;
   while(p&&j   {
       p=p->next;
       ++j;
   }
     if(!p||j>i-1) return ERROR;
   s=(LinkList)malloc(sizeof(LNode));
   s->data=*e;
   s->next=p->next;
     p->next=s;
   return OK;
}
int ListDelet(LinkList L, int i)
{//删除指定位置的结点
   LinkList p=L,q;
   int j=0;
   while(p->next&&j //寻找第i-1个结点
   {
       p=p->next;
       ++j;
   }
    if(!(p->next)||j>i-1) return ERROR;
    q=p->next; p->next=q->next;
    free(q);
   return OK;
}
int Destroy_L(LinkList L)   //这里会遇到一个问题，如果将头结点free掉的话就会出错，
                            //因为头结点不是自己分配的，而是系统分配的，在主函数中，所以无法释放
{
     LinkList head=L,p;
   p=head;
   if (head)
       p = head->next ;
   head = head->next ;
   while(head!=NULL)
   {
       p=head;
       head=head->next;
       free(p);
   }
   return OK;
}
int ClearList(LinkList L)
{//线性表置空
   L->next=NULL; //将头结点指针域置为NULL
   return OK;
}
int max_num(LinkList L)
{
   LinkList p=L->next;
   int max=0;
   while(p!=NULL)
   {
       if(max<=p->data)
           max=p->data;
       p=p->next;
   }
   return max;
}

float aver_num(LinkList L) //注意函数名不要和变量同名，很容易出错
{ //求出所有元素的平均值
    LinkList p=L->next;
   float average;
   int sum=0;
   int length=length_L(L);
   while(p!=NULL)
   {
       sum+=p->data;
       p=p->next;
   }
   average=(float)sum/(length-1);
   return average;
}

void main()
{
   int i,get,length,e;
   LNode L;           //创建头结点L
   L.next=NULL;
   do{
       printf("\n");
       printf("1.输入数据元素，以先进先出形式创建单链表\n");
        printf("2.销毁单链表\n");
        printf("3.线性表置空\n");
        printf("4.求线性表长度\n");
        printf("5.在第i个数据元素前插入新的元素\n");
        printf("6. 删除第i个元素\n");
        printf("7.显示线性表中的全部元素\n");
        printf("8.求最大元素的值和平均值\n");
       printf("9.退出\n");
        printf("请输入你选择的操作序号\n");
        scanf("%d",&get);
        switch(get){
             case 1:
                    printf("请输入数据元素的个数\n");
                     scanf("%d",&length);
                    Create_List(&L,length);
                    break;
             case 2:
                     Destroy_L(&L);
                   break;
           case 3:
                     ClearList(&L);
                   break;
           case 4:
               length=length_L(&L);
                 printf("这个线性链表的长度(含头结点)为%d\n",length);
               break;
           case 5:
               printf("请分别输入你要插入数据的元素的位置(第i个元素之前)和值(整型)\n");
               scanf("%d,%d",&i,&e);
                 ListInsert(&L,i,&e);
               break;
           case 6:
               printf("请分别输入你要删除数据的元素的位置(第i个元素)\n");
               scanf("%d",&i);
                 ListDelet(&L,i);
               break;
           case 7:
                   length=length_L(&L);
                   display_all(&L,length);
                   break;
           case 8:
                   printf("线性表中的最大元素是%d\n",max_num(&L));
                   printf("线性表中所有元素的平均值%f\n",aver_num(&L));
                    break;
           case 9:
               break;
       }
   }while(get!=9);

}

刘畅 2009-11-27 21:35 发表评论

顺序表的操作

刘畅 — Fri, 27 Nov 2009 13:35:00 GMT

1．设某线性表数据元素的类型为整型，以顺序结构存储线性表。试编程实现：

(1) 线性表置空

(2) 求线性表长度

(3) 数据元素的插入操作

(4) 数据元素的删除操作

(5) 显示线性表中的全部元素

#include
#include
#include
#include
#define LIST_INIT_SIZE 10
#define LISTINCREMENT 10
#define ERROR     0
#define OK        1
#define OVERFLOW -2

typedef struct{
   int *elem;
   int length;
   int listsize;
   }SqList;

int InitList_Sq(SqList *L) //括号中传递参数是是它的指针L,这样才能对它指向的元素改变。
{
int i;
L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
if(!L->elem) exit(OVERFLOW);
L->length =10;
L->listsize = LIST_INIT_SIZE; //分配初始的空间
for(i=0;ilength;i++)
{
      L->elem[i]=i;
}
return OK;
}//InitList_Sq

int get_length(SqList *L)
{
   return L->length;
}

int destroy(SqList *L)
{
   L->length=0;
   return OK;
}

int ListInsert_Sq(SqList *L,int i, int e)
{ //在顺序表L中的第i个位置之前插入新的元素e；
   //i的合法值为1<=i<=ListLength_Sq(L)+1;
   int *newbase,*q,*p;
   if(i<1||i>L->length+1) return ERROR;
   if(L->length>=L->listsize){// 当前的存储空间已满，增加分配
       newbase = ( int *)realloc(L->elem,( L->listsize +LISTINCREMENT)*sizeof(int));
       if(!newbase) exit(OVERFLOW) ; //存储空间分配失败
       L->elem = newbase;
       L->listsize+=LISTINCREMENT;
   }
   q=&(L->elem[i-1]);
   for(p=&(L->elem[L->length-1]);p>=q;--p) *(p+1)=*p;
                                       //插入位置及之后的元素右移
   *q=e;
   ++L->length;
   return OK;
}//ListInsert_Sq;

int ListDelete_Sq(SqList *L, int i, int e) {
// 在顺序线性表L中删除第i个元素，并用e返回其值。
// i的合法值为1≤i≤ListLength_Sq(L)。
int *p, *q;
if (i<1 || i>L->length) return ERROR; // i值不合法
p = &(L->elem[i-1]);                   // p为被删除元素的位置
e = *p;                               // 被删除元素的值赋给e
q = L->elem+L->length-1;                // 表尾元素的位置
for (++p; p<=q; ++p) *(p-1) = *p;     // 被删除元素之后的元素左移
--L->length;                           // 表长减1
return OK;
} // ListDelete_Sq

int display_all(SqList *L)
{
   int i;
   for(i=0;ilength;i++)
   {
       printf("%d",L->elem[i]);
       printf(" ");
   }
   return OK;
}
int main()
{
   SqList L;
   int get,e=0;
   int i,num;
    InitList_Sq(&L);
   do{
   printf("请输入你要进行的操作序号\n");
   printf("1.线性表置空\n");
   printf("2.求线性表长度\n");
   printf("3.数据元素的插入操作\n");
   printf("4.数据元素的删除操作\n");
   printf("5.显示线性表中的全部元素\n");
   printf("6.退出\n");
   scanf("%d",&get);
   switch(get)
   {
   case 1:
          destroy(&L);//将顺序表置空，只需要将其长度置零
          break;
   case 2:
          printf("该线性表的长度是%d\n",get_length(&L)); //求取线性表的长度
          break;
   case 3:
          //在指定的位置上插入指定的数据元素
          printf("请输入你要插入的元素的位置（即在第i个元素之前插入）以及插入元素\n");
          scanf("%d,%d",&i,&num);
          ListInsert_Sq(&L,i,num);
          printf("新的线性表是\n");
          display_all(&L);
          break;
   case 4:
       //删除指定位置的数据元素
          printf("请输入你要删除的元素的位置（即删除第i个元素）\n");
          scanf("%d",&i);
          ListDelete_Sq(&L,i,e);
          printf("新的线性表是\n");
          display_all(&L);
          break;
   case 5:
       //显示线性表的所有元素
          display_all(&L);
          printf("\n");
          break;
   case 6:
       //退出程序
          break;
   }
   }while(get!=6);
    return OK;
}

刘畅 2009-11-27 21:35 发表评论

插入排序的思想

刘畅 — Fri, 27 Nov 2009 13:30:00 GMT

插入排序的思想：
1. 现在有两种方法，一种是算法导论中的，一种是数据结构的，但是总体思想都是一致的。
2.对于每一个i（从1开始，即第二个元素，具体是多少不确定），如果a[i]比a[i-1]小，就是比前面的那个小，则进行相应的操作，否则不变，递增下去。
3.每次都将a[i]赋值给key，关键字key，实际上每次都进行比较，先赋值给key，实际上就是保留这个数，然后将前面的一个数移动到后面，这个是首先的操作。
4.下面是对于具体的每一个key来定位，每次都要移动，…………………………
注意最后要赋值下去。

……………………精秒之处在于赋值和保存a[i]

刘畅 2009-11-27 21:30 发表评论

插入排序

刘畅 — Fri, 27 Nov 2009 13:29:00 GMT

#include

int Insert_sort(int *p,int length)
{
   int i,j,key;
    for(i=1;i<=(length-1);i++)
   {
       if(*(p+i)<*(p+i-1))
       {
           key=*(p+i);
           *(p+i)=*(p+i-1);
           for(j=i-1;j>=0 &&key<*(p+j);--j)
           {
               *(p+j)=*(p+j-1);
           }
           *(p+j+1)=key;
       }
   }

   return 0;
}

int main()
{
   int a[10]={0,4,1,9,5,7,2,3,6,8};
   int i;
   int *p=&a[0];
   Insert_sort(p,10);
   for(i=0;i<10;i++)
   {
       printf("%d ",a[i]);
   }
}

通过指针调用的形式来改变原来数组中的值，这样就可以了。而每一个数组元素都可以用指针加位移量来确定

#include<stdio.h>
void main()
{
    int i,j;
    //a[0]为哨兵，所以它的值随便，但是注意要排序的是后面的几个，而且长度也是后面的几个。
    int a[11]={0,1,2,4,9,0,3,8,6,7,5};
    //插入排序
    for(i=2;i<=10;++i)
    {
       if(a[i]<a[i-1])
       {
           a[0]=a[i];        //已经保存了a[i],所以下面就不必担心被冲掉。
           a[i]=a[i-1];
           for(j=i-2;a[0]<a[j];--j)
           {
               a[j+1]=a[j];
           }
           a[j+1]=a[0];
       }

    }
    for(i=1;i<11;i++)              //从a[1]开始输出，这样才消除了哨兵。
    {
        printf("%d ",a[i]);
    }
}

注意真正的排序部分是从a[1]开始的，还有长度length不是数组的长度，而是实际要排序的长度，这里把a[i]冲掉的步骤很好，而且没有影响，因为已经保存下来了。

--------------------《数据结构         严蔚敏版》

1#include<stdio.h>
2void main()
3{
4    int a[10]={0,4,1,9,5,7,2,3,6,8};
5    int key,i,j;
6    for(i=1;i<=9;i++)
7    {
8        if(a[i]<a[i-1])
9        {
10            key=a[i];
11            a[i]=a[i-1];
12            for(j=i-1;j>=0 && key<a[j];--j)
13            {
14                a[j]=a[j-1];
15            }
16           a[j+1]=key;
17        }
18    }
19         for(i=0;i<10;i++)
20         {
21             printf("%d ",a[i]);
22         }
23}
24

刘畅 2009-11-27 21:29 发表评论

数据结构-----简单的插入

刘畅 — Fri, 27 Nov 2009 13:28:00 GMT

//下面的函数用来实现线性表的插入
//两个表无序也可，只是插入就可以。
#include
int compare(int e,int *a,int length)
{
   int i;
    for(i=0;i   {
       if(e==*(a+i))
           return 1;
       else
           continue;
   }
   return 0;
}
int main()
{
   int i,j;
   int length_a=10; //定义a的实际长度，剩余空间用来填充。
   int a[20]={0,1,2,3,4,5,6,7,8,9};
   int b[10]={2,4,11,23,34,21,12,8,9,10};
   for(i=0,j=0;i<10;i++)
   {
       if(!compare(b[i],a,10))
       {
           a[10+j]=b[i];
           j++;
       }

        else
            continue;
    }
    for(i=0;i    {
       printf("%d ",a[i]);
    }
    printf("\n");
   return 0;
}

刘畅 2009-11-27 21:28 发表评论

实现一个简单的进制转换

刘畅 — Fri, 27 Nov 2009 13:27:00 GMT

//只是利用了堆栈的性质，实际上根本不是
//利用堆栈的性质实现将一个十进制转换成相应的进制表示。
#include
int convert(int a,int N,int *num)
{
   int count=0;
   while(a!=0)
   {
       *(num+count)=a%N;
       a=a/N;
       count++;
   }
   return count;
}
int main()
{
   int num[10],i,N;
   int a,count,get;
   int *p=&count;
   printf("请输入你要转换的十进制数\n");
   scanf("%d",&a);
   printf("请输入你要选择的进制\n");
   printf("1.二进制\n");
   printf("2.八进制\n");
   scanf("%d",&N);
   get=a;
   if(N==1)
        count=convert(a,2,num);   //输入的N和你要转换的进制不是同一个。
    if(N==2)
        count=convert(a,8,num);
   printf("%d的%d进制表示是\n",get,N);
   for(i=count-1 ; i>=0 ; i--) //开始的时候傻×，用的是i<0,肯定都不满足啊，所以完全没有输出。
   {
       printf("%d",*(num+i));
   }
   printf("\n");
}

注意16进制就不可用，原因是超过10的数就要用字母表示，会出错的。

刘畅 2009-11-27 21:27 发表评论

二叉排序树的各种操作实现

刘畅 — Sun, 15 Nov 2009 03:54:00 GMT

#include
#include
using namespace std;

typedef struct BinaryTree
{
int data;
struct BinaryTree *l;
struct BinaryTree *r;
}*BiTree,BiNode;

class BiSearchT
{
private:
BiTree root;
public:
BiSearchT() :root(NULL) {}
int PreOrderTraverse(BiTree t,int (*Visit)(int e));
int InOrderTraverse(BiTree t,int (*Visit)(int e));
int InsertBST(BiTree *t,int e);
void Delete(BiTree *p);
bool DeleteBST(BiTree *t,int key);
bool SearchBST(BiTree t,int key,BiTree f,BiTree *p);
};
//先序遍历二叉树T
int BiSearchT::PreOrderTraverse(BiTree t,int (*Visit)(int d))
{
if(t)
{
  if(Visit(t->data))
   if(PreOrderTraverse(t->l,Visit))
    if(PreOrderTraverse(t->r,Visit)) return 1;
    return 0;
    }else return 1;
}
//中序遍历二叉树T
int BiSearchT::InOrderTraverse(BiTree t,int (*Visit)(int d))
{
if(t)
{
  if(InOrderTraverse(t->l,Visit))
   if(Visit(t->data))
    if(InOrderTraverse(t->r,Visit)) return 1;
    return 0;
    }else return 1;
}
//二叉排序树上的查找递归算法
bool BiSearchT::SearchBST(BiTree t,int key,BiTree f,BiTree *p)
{
if(!t)
  {*p=f;return false;}
  else if(key==t->data) {*p=t;return true;}
  else if(keydata) SearchBST(t->l,key,t,p);
  else SearchBST(t->r,key,t,p);
}
//插入算法
int BiSearchT::InsertBST(BiTree *t,int e)
{
BiTree p;
BiTree s;
if(!SearchBST(*t,e,NULL,&p))
{
  s=(BiTree)malloc(sizeof(BiNode));
  s->data=e;s->l=s->r=NULL;
  if(!p) *t=s;
  else if(edata) p->l=s;
  else p->r=s;
  return true;
}
else return false;
}
//在二叉树中删除一个结点
void BiSearchT::Delete(BiTree *p)
{
BiTree q,s;
if(!(*p)->r)
{
  q=(*p);
  (*p)=(*p)->l;
  free(q);
}
else if(!(*p)->l)
{
  q=(*p);
  (*p)=(*p)->r;
  free(q);
}
else
{
  q=s=(*p)->l;
  while(s->r) s=s->r;
  s->r=(*p)->r;
  free(*p);
  (*p)=q;
}
}
//二叉排序树的删除
bool BiSearchT::DeleteBST(BiTree *t,int key)
{
if(*t!=NULL)
{
  if(key==(*t)->data) Delete(t);
  else
   if(key<(*t)->data) DeleteBST(&((*t)->l),key);
   else DeleteBST(&((*t)->r),key);
   return true;
}
   else return false;
}
//输出二叉排序树的数据地域值
int printelem(int d)
{
cout< return 1;
}

void main()
{
BiTree sroot=NULL;
BiTree Croot=NULL;
int q,c,d,e,f,g,h,l,m,x;
cout<<"..............................二叉排序树的基本操作.............................."< cout<<"请您输入十个正整数作为二叉排序树的十个结点:"< cin>>q>>c>>d>>e>>f>>g>>h>>l>>m>>x;
int i,j,k,a[10]={q,c,d,e,f,g,h,l,m,x};
int n=7,b[]={10,7,6,9,20,12,22};
BiSearchT my;
for(i=0;i<10;i++)
  my.InsertBST(&sroot,a[i]);
cout<<"二叉排序树创建成功!"<    cout<<"先序遍历二叉排序树:"< my.PreOrderTraverse(sroot,printelem);
cout< cout<<"中序遍历二叉排序树:"< my.InOrderTraverse(sroot,printelem);
cout<    cout<<"请输入你要查找的元素:";
cin>>i;
if(i==q||i==c||i==d||i==e||i==f||i==g||i==h||i==l||i==m||i==x)
  cout<<"查找成功!"< else cout<<"查找失败!"< cout<<"请输入你要删除的元素(...输入的元素必须在二叉排序树中...):";
cin>>j;
my.DeleteBST(&sroot,j);
cout<<"先序遍历二叉排序树:"< my.PreOrderTraverse(sroot,printelem);
cout< cout<<"中序遍历二叉排序树:"<    my.InOrderTraverse(sroot,printelem);
cout<    cout<<"在此基础上请输入你要插入的元素:";
cin>>k;
my.InsertBST(&sroot,k);
    cout<<"先序遍历二叉排序树:"< my.PreOrderTraverse(sroot,printelem);
cout< cout<<"中序遍历二叉排序树:"<    my.InOrderTraverse(sroot,printelem);
cout<}

刘畅 2009-11-15 11:54 发表评论