国产午夜精品久久久久九九电影 ,久久99精品国产麻豆蜜芽,久久国产乱子伦免费精品

二叉树的操作

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

二叉树的实验操作�Q?br>题目如下�Q?br>1�Q�设某二叉树的结点类型�ؓ整数�c�d��Q�以二叉链表形式作�ؓ存储�l�构。试�~�程实现�Q?br>(1) 生成一��二叉树.
(2) 用递归��法、非递归��法实现二叉树的遍历�Q?br>(3) 求度分别�?�?�?的结点的数目,分别用递归��法、非递归��法实现�Q?br>(4) 按层�ơ遍历二叉树(提示�Q��用一个队列实玎ͼ��Q?br>*(5) 求二叉树的高�?深度)�Q?br>*(6) 判断是否为完全二叉树�Q�输�?Yes!"/"No!"�Q?br>*(7) 交换每个�l�点的左叛_��树；
*(8) 对交换左叛_��树后的二叉树作中序遍历�?br>

#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]; //循环队列元素�c�d��Z��叉链表结�Ҏ��?br>   int count;
}Queue; //循环队列�l�构定义

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

int PreOrderTraverse(BiTree T) //用递归��法写的遍历函数�Q�按照先序遍历，同时输出�l�点的�?br>{
   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) //用非递归的算法写的遍历函敎ͼ�按照先序遍历�Q�同时输出结点的�?br>{
   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) //求出�ȝ��l�点的个�?br>{
   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的结�?br>{
   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)   //非递归��法�Q�同时利用关�p�L��度�ؓ1的结炏V�?br>{
    int num=get_all_node(T)-2*get_node0_2(T)+1;
    return num;
}
int get_node2(BiTree T) //利用度�ؓ2的结点个��C��度�ؓ0的结点个数的关系得到
{
    int num=get_node0_1(T)-1;
    return num;
}
int get_node2_1(BiTree T)   //非递归��法�Q�同时利用关�p�L��度�ؓ2的结炏V�?br>{
    int num=get_node0_2(T)-1;
    return num;
}
int get_node(BiTree T)
{
    int get;
   printf("误��入你要查扄��l�点的度\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)        //利用非递归��法的实�?br>{
    int get;
    printf("下面是用非递归��法来查询\n");
   printf("误��入你要查扄��l�点的度\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为层�?br>    q=(Queue *)malloc(sizeof(Queue)); //甌��循环队列�I�间
    q->rear=q->front=q->count=0;      //��@环队列初始化为空
    q->data[q->rear]=T;
    q->count++;
    q->rear=(q->rear+1)%queuesize;       //��根�l�点入队
    while (q->count)                   //若队列不为空�Q�做以下操作
        if(q->data[q->front]){            //当队首元素不为空指针�Q�做以下操作
            p=q->data[q->front];           //取队首元�?p
            printf("%d ",p->data);        //打印*p�l�点的数据域信息
            ++flag;
            q->front=(q->front+1)%queuesize;
            q->count--;       //队首元素出队
            if (q->count==queuesize)//若队列�ؓ队满�Q�则打印队满信息�Q�退出程序的执行
                printf("the queue full!\n");
            else{            //若队列不满，��?p�l�点的左孩子指针入队
                q->count++;q->data[q->rear]=p->lchild;
                q->rear=(q->rear+1)%queuesize;
            }                        //enf of if
            if (q->count==queuesize)        //若队列�ؓ队满�Q�则打印队满信息�Q�退出程序的执行
                printf("the queue full!\n");
            else{                      //若队列不满，��?p�l�点的右孩子指针入队
                q->count++;q->data[q->rear]=p->rchild;
                q->rear=(q->rear+1)%queuesize;
            }                              //end of if
        }                                //end of if
        else{                          //当队首元素�ؓ�I�指针，��空指针出队
            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)   //采用递归��法来实现判断是否�ؓ完全二叉�?br>{
      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�l�点的指�?br>    int choice;
    do{
    printf("\n");
    printf("请选择操作�Q�\n");
    printf("1.按照先序的次序生成一颗二叉树\n");
    printf("2.递归��法实现二叉树的先序遍历�Q�输出各�l�点值\n");
    printf("3.用非递归��法实现二叉树的遍历�Q�输出各�l�点值\n");
    printf("4.求度分别�?�?�?的结点的数目�Q�递归��法实现�Q�\n");
    printf("5.求度分别�?�?�?的结点的数目�Q�非递归��法实现�Q�\n");
    printf("6.按层�ơ遍历二叉树\n");
    printf("7.求二叉树的高�?深度)\n");
    printf("8.判断是否为完全二叉树�Q�输出\"Yes!\"或\"No!\"\n");
    printf("9.交换每个�l�点的左叛_��树\n");
    printf("10.对交换左叛_��树后的二叉树作中序遍历\n");
    printf("11.退出\n");
    scanf("%d",&choice);
    switch(choice){
    case 1:
        CreateBiTree(&T);   //创徏二叉�?br>        break;
    case 2:
        PreOrderTraverse(T); //利用递归��法的先序遍历，输出�l�点�?br>        break;
    case 3:
        PreOrderTraverse2(T);//利用非递归��法的先序遍历，输出�l�点�?br>        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

设某�U�性表数据元素的类型�ؓ整型�Q�以链表�l�构存储�U�性表。试�~�程实现�Q?/span>

(1) 输入数据元素�Q�以先进先出形式创徏单链�?/span>

(2) 销毁单链表

(3) �U�性表�|�空

(4) 求线性表长度

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

(6) 删除�W?span lang=EN-US XML:LANG="EN-US">i个元�?/span>

(7) 昄��U�性表中的全部元素

(8) 求最大元素的值和�q�_��?/span>

#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)
{//创徏一个带表头�l�点的大��ؓn个的单链�?br>   int i;
   LinkList p, tail; //声明一定要在前面，否则会出�?br>        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) //依赖于长度，可是却不定，长度函数有问题�?br>{//昄��所有的数据元素
   int i;
   printf("�U�性表的全部数据元素如下：\n");
   for(i=0;i   {
       printf("%d ",L->next->data);
       L=L->next;
   }
   printf("\n");
   return OK;
}

int length_L(LinkList L) //有问�?br>{//求得�U�性表的长�?br>   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)
{//删除指定位置的结�?br>   LinkList p=L,q;
   int j=0;
   while(p->next&&j //��L��W�i-1个结�?br>   {
       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)   //�q�里会遇��C��个问题，如果��头�l�点free掉的话就会出错，
                            //因�ؓ头结点不是自己分配的�Q�而是�pȝ��分配的，在主函数中，所以无法释�?br>{
     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)
{//�U�性表�|�空
   L->next=NULL; //��头�l�点指针域置为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) //注意函数名不要和变量同名�Q�很�Ҏ��出错
{ //求出所有元素的�q�_��?br>    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.输入数据元素�Q�以先进先出形式创徏单链表\n");
        printf("2.销毁单链表\n");
        printf("3.�U�性表�|�空\n");
        printf("4.求线性表长度\n");
        printf("5.在第i个数据元素前插入新的元素\n");
        printf("6. 删除�W�i个元素\n");
        printf("7.昄��U�性表中的全部元素\n");
        printf("8.求最大元素的值和�q�_��值\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("�q�个�U�性链表的长度(含头�l�点)�?d\n",length);
               break;
           case 5:
               printf("请分别输入你要插入数据的元素的位�|?�W�i个元素之�?和�?整型)\n");
               scanf("%d,%d",&i,&e);
                 ListInsert(&L,i,&e);
               break;
           case 6:
               printf("请分别输入你要删除数据的元素的位�|?�W�i个元�?\n");
               scanf("%d",&i);
                 ListDelet(&L,i);
               break;
           case 7:
                   length=length_L(&L);
                   display_all(&L,length);
                   break;
           case 8:
                   printf("�U�性表中的最大元素是%d\n",max_num(&L));
                   printf("�U�性表中所有元素的�q�_��?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�Q?/span>设某�U�性表数据元素的类型�ؓ整型�Q�以��序�l�构存储�U�性表。试�~�程实现�Q?/span>

(1) �U�性表�|�空

(2) 求线性表长度

(3) 数据元素的插入操�?/span>

(4) 数据元素的删除操�?/span>

(5) 昄��U�性表中的全部元素

#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,�q�样才能对它指向的元素改变�?br>{
int i;
L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
if(!L->elem) exit(OVERFLOW);
L->length =10;
L->listsize = LIST_INIT_SIZE; //分配初始的空�?br> 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中的�W�i个位�|�之前插入新的元素e�Q?br>   //i的合法��gؓ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) ; //存储�I�间分配��p�|
       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个元素，�q�用e�q�回其倹{�?br> // i的合法��gؓ1≤i≤ListLength_Sq(L)�?br> int *p, *q;
if (i<1 || i>L->length) return ERROR; // i��g��合法
p = &(L->elem[i-1]);                   // p��删除元素的位�|?br> e = *p;                               // 被删除元素的��D��l�e
q = L->elem+L->length-1;                // 表尾元素的位�|?br> for (++p; p<=q; ++p) *(p-1) = *p;     // 被删除元素之后的元素左移
--L->length;                           // 表长�?
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.�U�性表�|�空\n");
   printf("2.求线性表长度\n");
   printf("3.数据元素的插入操作\n");
   printf("4.数据元素的删除操作\n");
   printf("5.昄��U�性表中的全部元素\n");
   printf("6.退出\n");
   scanf("%d",&get);
   switch(get)
   {
   case 1:
          destroy(&L);//��顺序表�|�空�Q�只需要将光��度置�?br>          break;
   case 2:
          printf("该线性表的长度是%d\n",get_length(&L)); //求取�U�性表的长�?br>          break;
   case 3:
          //在指定的位置上插入指定的数据元素
          printf("误��入你要插入的元素的位�|�（卛_��W�i个元素之前插入）以及插入元素\n");
          scanf("%d,%d",&i,&num);
          ListInsert_Sq(&L,i,num);
          printf("新的�U�性表是\n");
          display_all(&L);
          break;
   case 4:
       //删除指定位置的数据元�?br>          printf("误��入你要删除的元素的位�|�（卛_��除第i个元素）\n");
          scanf("%d",&i);
          ListDelete_Sq(&L,i,e);
          printf("新的�U�性表是\n");
          display_all(&L);
          break;
   case 5:
       //昄��U�性表的所有元�?br>          display_all(&L);
          printf("\n");
          break;
   case 6:
       //退出程�?br>          break;
   }
   }while(get!=6);
    return OK;
}

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

插入排序的思想

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

插入排序的思想�Q?br>1. 现在有两�U�方法，一�U�是��法��D��中的�Q�一�U�是数据�l�构的，但是��M��思想都是一致的�?br>2.对于每一个i�Q�从1开始，即第二个元素�Q�具体是多少不确定）�Q�如果a[i]比a[i-1]��，��是比前面的那个��，则进行相应的操作�Q�否则不变，递增下去�?br>3.每次都将a[i]赋值给key�Q�关键字key�Q�实际上每次都进行比较，先赋值给key�Q�实际上��是保留�q�个敎ͼ�然后��前面的一个数�U�d��到后面，�q�个是首先的操作�?br>4.下面是对于具体的每一个key来定位，每次都要�U�d��Q?#8230;………………………
注意最后要赋��g��厅R�?br>

……………………�_��之处在于赋值和保存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]);
   }
}

通过指针调用的�Ş式来改变原来数组中的��|��q�样��可以了。而每一个数�l�元素都可以用指针加位移量来��定

#include<stdio.h>
void main()
{
    int i,j;
    //a[0]为哨兵，所以它的值随便，但是注意要排序的是后面的几个�Q�而且长度也是后面的几个�?/span>
    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],所以下面就不必担心被冲掉�?/span>
           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]开始输出，�q�样才消除了哨兵�?/span>
    {
        printf("%d ",a[i]);
    }
}

注意真正的排序部分是从a[1]开始的�Q�还有长度length不是数组的长度，而是实际要排序的长度�Q�这里把a[i]冲掉的步骤很好，而且没有影响�Q�因为已�l�保存下来了�?br>
--------------------《数据结�?nbsp;        严蔚敏版�?br>

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 发表评论

数据�l�构-----��单的插入

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

//下面的函数用来实现线性表的插�?br>//两个表无序也可，只是插入��可以�?br>#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的实际长度，剩余�I�间用来填充�?br>   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 发表评论

实现一个简单的�q�制转换

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

//只是利用了堆栈的性质�Q�实际上�Ҏ��不是
//利用堆栈的性质实现��一个十�q�制转换成相应的�q�制表示�?br>#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和你要�{换的�q�制不是同一个�?br>    if(N==2)
        count=convert(a,8,num);
   printf("%d�?d�q�制表示是\n",get,N);
   for(i=count-1 ; i>=0 ; i--) //开始的时候傻×�Q�用的是i<0,肯定都不满��啊，所以完全没有输出�?br>   {
       printf("%d",*(num+i));
   }
   printf("\n");
}

注意16�q�制��׃��可用�Q�原因是��过10的数��p��用字母表�C�，会出错的�?br>

刘畅 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;
}
//二叉排序树上的查��N��归��法
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;
}
//在二叉树中删除一个结�?br>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;
}
//输出二叉排序树的数据地域�?br>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<<"��h��输入十个正整��C��Z��叉排序树的十个结�?"< 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<<"查找��p�|!"< cout<<"误��入你要删除的元素(...输入的元素必��d��二叉排序树中...):";
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 发表评论