数据结构详解各种算法

1、
设有两个整型顺序表L1，L2，其元素值递增有序存放，请定义该顺序表的元素类型及表类型,设计以下自定义函数：
（1）录入顺序表中所有元素的值。

（2）将顺序表L1，L2合并为到另外一个顺序表L3中，L3中的元素非递减有序排列。
（3）输出顺序表中元素的值。
主函数通过调用以上函数实现两个表的合并并显示合并结果。

#include
#include
#define MAXLEN 100     
typedef struct
{   
    int data[MAXLEN+1];
    int len;
}SeqList;        
/*录入*/
void input(SeqList*L)
{ 
    int i;
    printf("input the length\n");
    scanf("%d",&L->len);
    printf("input element\n");
    for(i=1;i<=L->len;i++)
     scanf("%d",&L->data[i]);
}
/*合并*/
void merge(SeqList* A , SeqList* B, SeqList *C)
{  
    int i,j,k;
    i=1;j=1;k=1;          
    while(i<=A->len&&j<=B->len)
        if(A->data[i]data[j])
            C->data[k++]=A->data[i++];
        else C->data[k++]=B->data[j++];
    while(i<=A->len)
            C->data[k++]=A->data[i++];
             while(j<=B->len)
                         C->data[k++]=B->data[j++];
              C->len=k-1; 
}         
/*显示*/
void output(SeqList*L)
{
    int i;
    for(i=1;i<=L->len;i++)
        printf("%5d\n",L->data[i]);
}
/*菜单*/
    void menu()
    {
    printf("1-------------表1录入\n");
    printf("2-------------表2录入\n");
    printf("3-------------合并\n");
    printf("4-------------输出合并后的表\n");
    printf("0-------------退出\n");
    }
int main()
{
    SeqList* L1,*L2,*L3;  
    int sel;
    L1=(SeqList*)malloc(sizeof(SeqList));
    L1->len=0; 
    L2=(SeqList*)malloc(sizeof(SeqList));
    L2->len=0; 
    L3=(SeqList*)malloc(sizeof(SeqList));
    L3->len=0; 
    do
    { 
       menu();
       printf("input your select\n");
       scanf("%d",&sel);
       switch(sel)
       {
       case 1:  printf("input list1\n");
             input(L1);     
          break;
       case 2: printf("input list2\n");
            input(L2);
            break;
       case 3:merge(L1,L2,L3);
           break;
       case 4:output(L3);
       }
    }while(sel!=0);
    return 0;
}

2、顺序表：两个表合成一个新表并排序

#include
#include
#define DataType int      //此处假设顺序表的元素基类型为int
#define MAXSIZE 50        //此处假设顺序表的最大元素个数为50
typedef struct List
{
  DataType data[MAXSIZE]; //用一维数组存储顺序表元素
  int size;                //线性表的长度 
}SeqList;

void InitList(SeqList *p)//顺序表的初始化 
{ 
    p->size=0;
} 

int  Locate(SeqList *p, DataType e)
{
    int i=0;
    while(isize&&p->data[i]!=e)
    {
       i++;
    }
    if(i==p->size)
       return 0;
    else
       return(i+1);
}

void InsertList(SeqList *p,int i,DataType e)//插入 
{
    int j;
    if(i<1||i>p->size+1)
        printf("插入位置不正确");
    else
    {   
        p->size++;
        for(j=p->size-1;j>=i;j--)//此处的size已是修改后的新值
           p->data[j]=p->data[j-1];
           p->data[i-1]=e;
    }
}
void  DeleteList(SeqList *p,int i) //其实删除的是下标i-1的元素
{
     int j ;
     if (i<1|| i>p->size)
     printf( "删除位置不正确！！");
       else
     { 
       for(j=i-1;jsize-1;j++)
       p->data[j]=p->data[j+1];
       p->size--;
     }
}
void Display(SeqList *p)//输出顺序表 
{  
   int j;
   if(p->size==0) 
       printf("表为空表！\n");
   else
      for(j=0;jsize;j++)
        printf("%d ",p->data[j]);
}
void Bubble(SeqList *p)//升序冒泡 
{
    int i,j;
    int t;
    for(i=0;isize-1;i++)
      for(j=i+1;jsize;j++)
         if(p->data[j]data[i])
        {
        t=p->data[i];
        p->data[i]=p->data[j];
        p->data[j]=t;
        } 
}
void Bubbles(SeqList *p)//降序冒泡 
{
    int i,j;
    int t;
    for(i=0;isize-1;i++)
      for(j=i+1;jsize;j++)
         if(p->data[j]>p->data[i])
        {
        t=p->data[i];
        p->data[i]=p->data[j];
        p->data[j]=t;
        } 
}
int main()
 {
    SeqList A={{0,2,4,6,7,9},5},B={{0,1,5,7,8},4},C;  //第一个位置不用，然后花括号外面是表长 
    int i,j;
    InitList(&C);
    for(i=1;i<=A.size;i++)
        InsertList(&C,i,A.data[i]);
    for(j=1;j<=B.size;j++)
        if(Locate(&A,B.data[j])==0)
                InsertList(&C,i++,B.data[j]);
    Display(&C);
    printf("表长=%d\n",C.size);
    printf("\n");
    printf("升序排列：");
    Bubble(&C);
    Display(&C);
    printf("\n降序排列：");
    Bubbles(&C);
    Display(&C);            
    return  0;   
}

3顺序表合成：被调函数直接返回新表

#include
typedef struct A
{ 
   int data[10];
   int len;
}SeqList;
SeqList fun(SeqList *p1, SeqList *p2)
{ 
    int i,j;
    SeqList p;
    p.len=p1->len+p2->len;
    for(i=0,j=0;ilen;i++)
      p.data[j++]=p1->data[i];
    for(i=0;ilen;i++)
      p.data[j++]=p2->data[i];
    return p; //值带回，p的空间释放
}
void main()
{ 
    int i;
    SeqList a={{1,2,3},3},b={{5,6,7,8,9},5},p; //p是一个实体对象，有自己空间
    p=fun(&a,&b); //返回值赋值给变量p
    for(i=0;i        printf("%d ",p.data[i]);
}
4、顺序表合成：使用二级指针,带回新表#include
#include
typedef struct
{ 
   int data[10];
   int len;
}SeqList;
void fun(SeqList *p1, SeqList *p2, SeqList **p3)
{ 
   int i,j;
   *p3=(SeqList*)malloc(sizeof(SeqList));
   (*p3)->len=p1->len+p2->len;
    for(i=0,j=0;ilen;i++)
       (*p3)->data[j++]=p1->data[i];
    for(i=0;ilen;i++)
      (*p3)->data[j++]=p2->data[i];
} 
//二级指针p3中存放实参指针的地址，申请的堆空间地地址
//直接写入实参指针变量p中，因而返回后访问堆空间的值是正确的
int main( )
{ 
   int i;
   SeqList a={{1,2,3},3},b={{5,6,7,8,9},5},*p=NULL;
   fun(&a,&b,&p);        //这里使用了指针的指针做实参
   for(i=0;ilen;i++) // 正确显示了返回的合并新表的值
   printf("%d ",p->data[i]);
   return 0;
}

5、顺序表合成：使用静态局部变量，返回其内存地址给主调方

#include
#include
typedef struct A
{ 
   int data[10];
   int len;
}SeqList;
SeqList* fun(SeqList *p1,SeqList *p2)
{ 
   int i,j;
   static SeqList p;
   p.len=p1->len+p2->len;
   for(i=0,j=0;ilen;i++)
       p.data[j++]=p1->data[i];
   for(i=0;ilen;i++)
       p.data[j++]=p2->data[i];
    return &p; //返回函数中静态局部变量申请的空间地址
}
void main()
{ 
   int i;
   SeqList a={{1,2,3},3},b={{5,6,7,8,9},5},*p;
   p=fun(&a,&b); //将返回地址赋值给主调方的指针变量
   for(i=0;ilen;i++) // 正确显示结果
      printf("%d ",p->data[i]);
} //静态申请的空间释放

6、顺序表合成：被调函数返回顺序表指针带回新表地址

#include
#include
typedef struct A
{ 
   int data[10];
   int len;
}SeqList;
 
SeqList* fun(SeqList *p1,SeqList *p2)
{ 
  int i,j;
  SeqList *p;
  p=(SeqList*)malloc(sizeof(SeqList));
  p->len=p1->len+p2->len;
  for(i=0,j=0;ilen;i++)
     p->data[j++]=p1->data[i];
  for(i=0;ilen;i++)
     p->data[j++]=p2->data[i];
  return p; //带回指针变量的值，指针变量p的空间释放
}
int main()
{ 
   int i;
   SeqList a={{1,2,3},3},b={{5,6,7,8,9},5},*p;
   p=fun(&a,&b); //返回的地址给了指针变量p
   for(i=0;ilen;i++) // 正确显示了返回的合并新表的值
      printf("%d ",p->data[i]);
   return 0;
}
7、堆排序

#include
#define MAXSIZE 100 
typedef struct
{
    int key;
}DataType;
typedef struct
{
    DataType list[MAXSIZE];
    int length;
}SeqList;
void HeapAdjust(SeqList *L,int low,int high) 
{ 
    int i, j;
    i=low; 
    j=2*i; 
    L->list[0]=L->list[i]; 
    for(;j<=high;j*=2) 
    { 
     if(jlist[j].keylist[j+1].key)
       j++;
     if(L->list[0].key>=L->list[j].key) 
       break; 
     else 
     { 
       L->list[i]=L->list[j];
       i=j; 
     }
    }
    L->list[i]=L->list[0]; 
}
void HeapCreate(SeqList *L) 
{ 
   int i, n;
   n=L->length;
   for(i=n/2;i>0;i--)
   HeapAdjust(L,i,n);
}
void HeapSort(SeqList *L)
{ 
    int i, n=L->length;
    HeapCreate(L);
    for(i=n;i>1;i--)
    { 
      L->list[0]=L->list[1];
      L->list[1]=L->list[i]; 
      L->list[i]= L->list[0];
      HeapAdjust(L,1,i-1);
    }
}
int main()
{
    SeqList L={{0,18,27,10,8,18,38,4,17,21},10};
    HeapCreate(&L);
    HeapSort(&L);
    int i;
    for(i=1;i<=10;i++)
    {
        printf("%d ",L.list[i].key);
    } 
    return 0;    
} 
8、快速排序#include
#define MAXSIZE 100
typedef struct
{
    int key;
}DataType;
typedef struct
{
    DataType list[MAXSIZE];
    int length;
}SeqList;
int QuickPass(SeqList *L,int low,int high) 
{ 
   int i,j;
   i=low;
   j=high; 
   L->list[0]=L->list[i];
   while(i!=j)
   { 
     while((L->list[j].key>=L->list[0].key)&&(i      j--;
     if(i     { 
       L->list[i]=L->list[j]; 
       i++; 
    }
    while((L->list[i].key<=L->list[0].key)&&(i       i++;
    if(i     { 
      L->list[j]=L->list[i]; 
      j--; 
    }
   }
   L->list[i]=L->list[0]; 
   return i;
}
void QuickSort(SeqList *L,int s,int t) 
{ 
   int i;
   if(s    {
    i=QuickPass(L,s,t);
    QuickSort(L,s,i-1);
    QuickSort(L,i+1,t);
   }
}
int main()
{
    //SeqList L={{0,38,20,46,38,74,91,25,12},9};
    SeqList L={{0,18,27,10,8,19,38,4,17,21},10};
    QuickSort(&L,1,10);
    int i;
    for(i=1;i<=10;i++)
    {
        printf("%d ",L.list[i].key);
    }
    return 0;    
} 

9、直接插入排序

void  ins_sort(int R[ ],int *n，int x)
{  
    int i;
    R[0]=x;        
    i=*n;               
    while( R[0]     { 
        R[i+1]=R[i];         
        i--;
    }                 
    R[i+1]=R[0];   
    (*n)++;
}

2. 写出用直接插入排序进行升序排序的算法。
    void  ins_sort（datatype R[ ],int n）
    {  int i;
        for( i=2;i<=n;i++)
          { R[0]=R[i];        
           j=i-1;               
           while( R[0].key              { R[j+1]=R[j] ;         
                j- -;
    }                 
           R[j+1]=R[0] ;   
           }
      }

10、//给定一组整型值，-1作为结束，写出二叉排序树的生成过程。
    void insert(BiTree t, Bstree * s)   //将s插入到t为根的二叉排序树中
    {  
    if(s->datadata)
    {  
    if (t->lchild==NULL)
        t->lchild=s;
        else     
        insert(t->lchild,s);
    }
    else
    {  
    if (t->rchild==NULL)
        t->rchild=s;
        else
            insert(t->rchild,s);
        }
    }
    Bstree* bstreecreate() /*二叉排序树的生成算法*/
    {  
       int x;
       Bstree *s,*t;
       t=NULL;
       printf("input the elements of bstree,end flag is -1\n");
       scanf("%d",&x);
       while(x!=-1)     
       {  
       s=(BiTNode*)malloc(sizeof(BiTNode));
            s->data=x;
            s->lchild=s->rchild=NULL;
            if (t==NULL)
               t=s;
            else
                insert(t,s);
            scanf("%d",&x);
         }
      return (t);
    }

11、哈希查找#include
#include
#define NULLKEY 0
#define DELKEY -1
typedef struct 
{
    int key;
}Haxi;
int Hash(int k)
{ 
    int i;
    i=k%97;
    return i;
}
int InsertHash(Haxi ht[],int m,int k)
{
    int h0,hi,di;
    h0=Hash(k);
    hi=h0;
    di=1;
    while(ht[hi].key!=NULLKEY&&ht[hi].key!=DELKEY&&ht[hi].key!=k&&di     {
        hi=(h0+di)%m;
        di++;
    }
    if(ht[hi].key!=k&&di     {
        ht[hi].key=k;
        return 1;
    }
    else
    {
        if(ht[hi].key==k)
          printf("元素%d已经存在\n",k);
        else
        printf("哈希表已满\n");
        return 0;  
    }
}
void CreateHash(Haxi ht[],int m)
{
    int endflag=-99999;
    int i,x;
    for(i=0;i     {
        ht[i].key=NULLKEY;
    }
    printf("请输入哈希表中各个元素的值，以endflag=-99999结束：\n");
    scanf("%d",&x);
    while(x!=endflag)
    {
        InsertHash(ht,m,x);
        scanf("%d",&x);
    }
}
int SearchHash(Haxi ht[],int m,int k)
{
    int h0,hi,di;
    h0=Hash(k);
    hi=h0;
    di=1;
    while(ht[hi].key!=NULLKEY&&ht[hi].key!=k&&di     {
        hi=(h0+di)%m;
        di++;
    }
    if(ht[hi].key==k)
        return hi;
    else
        return -1;
}
int DeleteHash(Haxi ht[],int m,int k)
{
    int i;
    i=SearchHash(ht,m,k);
    if(i!=-1)
    {
        ht[i].key=DELKEY;
        return 1;
    }
    else
    return 0;
}
int main()
{
//测试数据:62 30 18 45 21 78 66 32 54 48 -99999
    Haxi ht[100];
    int i,j;
    int huanhang=0;
    CreateHash(ht,100);
    int number;
    int q;
    do
    {
        printf("请输入你想进行的操作:\n1.查看哈希表\n2.查找哈希表中的元素\n3.删除哈希表中的元素\n0.退出\n");
        scanf("%d",&q);
        switch(q)
        {
            case 1:    printf("下面是建立的哈希表：\n\n");
                    for(i=0;i<=99;i++)
                    {
                    printf("%d    ",ht[i].key);
                    huanhang++;
                     if(huanhang%10==0)
                         {
                           printf("\n");
                      }
                    }
                    break;
            case 2: printf("请输入你想查找的元素:\n");
                    scanf("%d",&number);
                    j=SearchHash(ht,100,number);
                    if(j==-1)
                    {
                        printf("查找失败，该元素不存在!\n\n");
                    }else
                    printf("元素%d在第%d个位置上",number,j);  
                    break;
            case 3: printf("请输入你想删除的元素:");
                    int delnumber;
                    int sign;
                    scanf("%d",&delnumber);
                    sign=DeleteHash(ht,100,delnumber);
                    if(sign==1)
                    {
                        printf("删除成功，该元素所在位置置为0\n");
                    }else
                    printf("查找失败！该元素不存在\n");
                    break;
        }
    }while(q);
    return 0;
}

11、v单链表操作

#include  
#include
#define N 0
typedef struct
{
    int sno;
    char name[20];    
}DataType;
typedef  struct   Node
{   DataType  data;
    struct Node *next;
}LNode,*LinkList;
LNode * InitL( )//初始化从无到有
{  LNode  *head=NULL;
    head=(LNode*)malloc(sizeof(LNode));
    if(head!=NULL) 
              head->next=NULL; 
     return  head;
}
LNode* CreatLinkH (LNode  *head, int n)
{   LNode  *s;
    DataType   x;
    int k=0;
    while(k     {   scanf("%d%s",&x.sno,x.name);
        s=(LNode*)malloc(sizeof(LNode));  /*为新结点s申请空间*/
        s->data=x;                 /*给新结点的数据域赋值*/                     
       s->next=head->next;/*将新结点链到首元结点之前*/
       head->next=s;          /*将新结点链到头结点之后*/ 
       k++;
     }
    return head;
}
void display(LNode  *head)//显示带头结点的单链表的所有信息
{    LNode  *p;
    p=head->next;//P指向了第一个数据结点
    while(p!=NULL)//说明 p指向了一个实际的数据结点
    {    printf("%5d%10s\n",p->data.sno,p->data.name);//输出该结点的值
        p=p->next;//p下移到下一个结点
    }
    printf("\n");
}
/*
LNode * SearchL(LNode *head,  DataType  x)//返回找到结点的地址
{   LNode  *p;
 
    p=head->next;                      //从第一个结点开始找
     while(p!=NULL && p->data!=x )     //逐个往后查找
     {      p=p->next;}
      return   p;
}
*/
LNode * Search_i(LNode *head, int i)//返回第i个结点的直接前驱结点
{   LNode  *p;
    int k=0;
    p=head;                      //从第一个结点开始找
     while(p && k      {   k++;   p=p->next;
     }
    if(p==NULL||i<1)
        return NULL;
    return   p;
}
void Insert_i(LNode *head, int i)
{
    LNode *p,*s;
    p=Search_i(head, i);
    if(p)
    {    s=(LNode*)malloc(sizeof(LNode));  /*为新结点s申请空间*/
        scanf("%d%s",&s->data.sno,s->data.name);
                                             
        s->next=p->next;
        p->next=s;  
    }
}
void DeleteL_i(LNode *head, int i)
{
    LNode *p,*s;
    p=Search_i(head, i);
    if(p==NULL)
        printf("查无此值！\n");
    else
      if(p->next!=NULL)
      {    
        s=p->next;
        p->next=s->next;
        free(s);
        }        
}
LNode * SearchL_2(LNode *head,  DataType  x)//返回找到结点的位置号
{   LNode  *p;
    p=head->next;                      //从第一个结点开始找
     while(p!=NULL && p->data.sno!=x.sno )     //逐个往后查找
     {   p=p->next;}
    return  p;     
}
int  count_len(LNode *head)//返回找到结点的位置号
{   LNode  *p;
    int n=0;
     p=head->next;                      //从第一个结点开始找
     while(p!=NULL  )     //逐个往后查找
     { ++n;  p=p->next;}
    return  n;     
}
int main()
{    LNode  *head=NULL,*p;
    DataType  x;
    int i;
    head=InitL();
    head=CreatLinkH(head,N);//头插法建立链表
    display(head);
//    scanf("%d",&x.sno);
//    p=Search_i(head, i);

/*    if(p==NULL)
        printf("查无此值！\n");
    else
        if(p==head)
            printf("是头结点\n");
        else
            printf("%5d%10s\n",p->data.sno,p->data.name);
    Insert_i(head,i);
    display(head);

    DeleteL_i(head,i);
    display(head);
    p=SearchL_2(head, x);
    if(p)
        printf("%5d%10s\n",p->data.sno,p->data.name);
    else
        printf("查无此值！\n");
    */
    printf("长度：%d\n",count_len(head));
    return 0;
}

12双向链表

#include
#include
#include
typedef struct
{ 
    int sno;
    char sex[3];
    char name[20];
}DataType; 
typedef struct DNode
{
    DataType data;
    struct DNode *prior,*next;
}DNode,*DuLinklist;
void CrtlinkR(DNode **head,int n)/*创建长度为n的双向链表*/
{
    int i;
    DNode *p,*rear;
    *head=(DNode *)malloc(sizeof(DNode));
    rear=*head;
    (*head)->prior=NULL;
    printf("input data:\n");
    for(i=1;i<=n;i++)
    {
        p=(DNode*)malloc(sizeof(DNode));
        scanf("%d%s%s",&p->data.sno,p->data.sex,p->data.name);
        rear->next=p;
        p->prior=rear;
        rear=p;
    }
    rear->next=NULL;
}
void serch_i_2(DNode *head,int i)
{
    DNode *p,*s,*t;
    int k=0;
    p=head;
    while(p&&k     {
        k++;p=p->next;
    }
    if(i<3||p==NULL||p->prior==NULL||p->prior->prior==NULL)
        printf("向前无第2个结点\n");
    else
    {
        s=p->prior->prior;
        printf("%5d %5s %10s\n",s->data.sno,s->data.sex,s->data.name);
    }
    if(p==NULL||p->next==NULL||p->next->next==NULL)
        printf("向后无第2个结点\n");
    else
    {
        t=p->next->next;
        printf("%5d %5s %10s\n",t->data.sno,t->data.sex,t->data.name);
    }
}
void dispheady(DNode *head)
{
    DNode *p;
    p=head;
    while(p->next!=NULL)
    {
         printf("%5d %5s %10s\n",p->next->data.sno,p->next->data.sex,p->next->data.name);
         p=p->next;
    }
    printf("\n");
    
}
/*
int dLinkdel(DuLinklist L,int i)
{
    DNode *p,*s;
    int j;
    p=L;
    j=0;
    while(p!=NULL&&j     {
        p=p->next;
        j++;
    
    }
    if(j!=i||i<1)
    {
        printf("删除位置不正确\n");
        return 0;
    }
    s=p ;  
    
    printf("p->data=%d\n",p->data);
    
    p->prior->next=p->next;
    if(p->next!=NULL)
    p->next->prior=p->prior;
    
    free(s);

    return 1;
}
*/
  void fun(DNode *head,DNode **M,DNode **F)
  {
        DNode *p,*rf,*rm,*s;
        CrtlinkR(M,0);
        CrtlinkR(F,0);
        rf=*F;
        rm=*M;
        p=head->next;
        while(p)
        {
            if(strcmp(p->data.sex,"男")==0)
            {
                s=(DNode *)malloc(sizeof(DNode));
                s->data=p->data;
                s->prior=rf;
                s->next=rf->next;
                rf->next=s;
                rf=s;    
            }
            else
            {
                s=(DNode *)malloc(sizeof(DNode));
                s->data=p->data;
                s->prior=rm;
                s->next=rm->next;
                rm->next=s;
                rm=s;
            }
            p=p->next;
        }
  }
void fun_2(DNode *head,DNode **M,DNode **F)//拆男生和女生
  {
        DNode *p,*rf,*rm,*s;
        CrtlinkR(M,0);
        *F=head;
        rf=*F;
        rm=*M;
        p=head->next;
        while(p)
        {
            if(strcmp(p->data.sex,"男")==0)
            {
                s=p;
                p=p->next;
                s->next=rf->next;
                rf->next=s;
                rf=s;        
            }
            else
            {
                s=p;
                p=p->next;
                s->next=rm->next;
                rm->next=s;
                rm=s;
            }            
    }
        rf->next=NULL;
        rm->next=NULL;
  }
int  main()
{
    DNode *head,*Mhead,*Fhead;
    int i,k;
    CrtlinkR(&head,5);  /*新建一个长度为5的双向链表*/
    dispheady(head);    /*显示双向链表*/
    /*
    i=locate(head,2);  //查找数据4所在位置
    printf("%d\n",i);
    k=dLinkdel(head,i);//删除第i个数据
    
    if(k==1)    //删除成功则显示插入后双向链表
    {
        printf("已正确删除了第%d个结点\n",i);
        dispheady(&head);
    }
    else
        printf("位置不正确，不能删除\n");
    scanf("%d",&i);
    serch_i_2(head,i);*/
        fun_2(head,&Mhead,&Fhead);
        dispheady(Mhead);
        dispheady(Fhead);
        dispheady(head);
    return 0;
}

13树

//1. 设计一算法，统计二叉树中度为2的结点总数。
int count(Bstree* bt)
{  
    if(bt==NULL) 
    return 0;         
    if(bt->lchild!=NULL&&bt->rchild!=NULL) 
        return 1;         
    else
        return(count(bt->lchild)+count(bt->rchild));  
}

//3. 设计一算法，统计叶子结点总数。
int countleaf1(Bstree* bt)
{  
    if(bt==NULL) 
        return 0;         
    if(bt->lchild==NULL && bt->rchild==NULL) 
        return 1;        
    else
        return(countleaf1(bt->lchild)+countleaf1(bt->rchild));    
}

//写出在二叉排序树中进行查找的算法。
BiTNode* SearchData(BiTree t, KeyType kx)
/*在二叉排序树t上查找关键码为kx的元素,找到返回其所在及结点的指针，否则返回一个空指针 */
{
    BiTNode* q=t;
        while(q)
        {
        if(kx>q->data.key)
            q=q->rchild;  /* 在右子树中查找 */ 
            else if (kxdata.key) 
                    q=q->lchild; /* 在左子树中查找 */ 
                else return q;   /* 查找成功 */
        }   
    return  NULL;    /* 查找不成功 */
}

中序遍历

typedef struct node
{
    int  data;
    struct node *lchild,*rchild;
}Bstree;
    
void bianli(Bstree* bt)
{  
    if (bt!=NULL)
    {  
        bianli(bt->rchild);
        printf("%5d,",bt->data); 
        bianli(bt->lchild);
    }      
}

二叉树判断完全二叉树源代码typedef struct 
{
    char data[10];
    int front;
    int rear;
}SeqQueue;
/*
void initqueue(SeqQueue *q)
{
    q->front=q->rear=0;
}
int enqueue(SeqQueue *q,char x)
{
    if(q->rear==10)
    {
       printf("队满\n");
    }
    else
    {
        q->data[q->rear]=x;
        q->rear++;
        return 1;
    }
    return 0;
}
int dequeue(SeqQueue *q,char *x)
{
    if(q->front==q->rear)
    {
        printf("队空");
        return 0;
    }
    else
    {
        *x=q->data[q->front];
        q->front++;
        return 1;
    }
    
}
/*
void complete(BiTree root)
{
    SeqQueue p;
    BiTree q=root;
    initqueue(&p);
    if(q!=NULL)
    {
        enqueue(&p,*q);
        while(p.front<p.rear)
        {
            dequeue(&p,q);
            printf("%c",q);
            if(q->lchild!=NULL)
            enqueue(&p,*(q->lchild));
            if(q->rchild!=NULL)
            enqueue(&p,*(q->rchild));
        }
    }
}
*/
/* 
bool Judge_Complete(BiTree T)//判断二叉树是否是完全二叉树
{
BiTree t;
SeqQueue Q;     //创建一个空队列
initqueue(&Q);
enqueue(&Q,T); //将T的头结点入队
t = T;         //给t赋初值T根节点
if(T==NULL)
return false;
while(QueueLength(Q))
{
if(t->lchild==NULL && t->rchild!=NULL)
return false;
if(t->lchild!=NULL && t->rchild!=NULL)//左右孩子都不为空
{
dequeue(&Q,t);//删除该双亲节点
enqueue(&Q,t->lchild); //将左孩子入队
enqueue(&Q,t->rchild); //将右孩子入队
}
if((t->lchild!=NULL && t->rchild==NULL) || (t->lchild==NULL && t->rchild==NULL))
{
dequeue(&Q,t); //从刚才判断的节点的下一个节点一次判断剩下队列中的节点是否左右子树都为空
while(QueueLength(Q))
{
if(t->lchild==NULL && t->rchild==NULL)
dequeue(&Q,t);
else
return false;
}
return true;
}
}
return true;
}
*/
在顺序表中进行二分查找的递归算法int BSearch(S_TBL *tbl,keytype kx，int low,int high)
//在下界为low，上界为high的线性表tbl中折半查找关键字为k的元素
{   int  mid=(low+high)/2;
    if(low>high) return -1;    
    if(k==tbl->data[mid].key) return mid;
    if(k< tbl->data[mid].key) return(BSearch(tbl,k,low,mid-1));
    return(BSearch(tbl,k,mid+1,high));
}

折半查找

#include
#define MAXSIZE 100
#define KeyType int
typedef struct STUDENTS
{
    char name[10]; 
    int grade;    
}stu;

typedef struct  
{
     stu data[MAXSIZE+1];
     int length;
}SeqList;

int Binsearch(SeqList *L,KeyType x)
{ 
    int low,mid,high;
    low=1; 
    high=L->length;
    while(low<=high)
    { 
      mid=(low+high)/2;
      if(L->data[mid].grade==x)
      return mid;
      else
          if(L->data[mid].grade           low=mid+1;
          else
          high=mid-1;
    }
    return 0;
}
int main()
{
    SeqList m={
               {
               {"",0},
               {"张三",60},
               {"李四",70},
               {"王五",80},
               {"老六",90}},
                4};
    int searchgrade;
    int location;
    printf("请输入你想要查找的成绩:\n");
    scanf("%d",&searchgrade);
    location=Binsearch(&m,searchgrade);
    if(location!=0)
    {
    printf("%s",m.data[location].name);
    }
    else{
    printf("查无此人");    
    }
    return 0;         
}

有两个链表表示的集合，设计算法判断是否相等源代码

// 判断两个链表表示的集合是否相等
int Equal(LinkList h1,LinkList h2)
{ LNode *p,*q;
 int t1=0,t2=0; 
 p=h1->next; q=h2->next; 
 while(p) //h1中所有元素是否都在h2
 { if(locateLinkList(h2,p->data))
p=p->next;
 else return 0;
 }
 if(p==NULL) t1=1;
 while(q) //h2中所有元素是否都在h1
 { if(locateLinkList(h1,q->data))
 q=q->next;
 else return 0 ;
 }
 if(q==NULL)
t2=1;
 if(t1==1&&t2==1) return 1 ;
 else return 0;
}

//
// 判断两个有序链表表示的集合是否相等
int Equal(LinkList h1,LinkList h2)
{ LNode *p,*q;
 p=h1->next;q=h2->next;
 while(p&&q) //等长且对应元素一一相等
 { if(p->data!=q->data)
 return 0;
 p=p->next;q=q->next;
 }
 if(p||q)
return 0;
 return 1;
} 

//设计一算法利用单链表中原来的结点将该单链表中元素倒置。即：原来的元素如果为：1，2，3，4，5；倒置后变成5，4，3，2，1。 
void reverse (NodeType * H)
{  
    NodeType *p; 
    p=H-> next;
    H->next=NULL;
    while(p)
    {   
    q=p; 
    p=p->next;
    q->next=H->next;
    H->next=q;   
    }
}

10. 设计一算法，求该链表中值最大的结点并返回该结点的指针，若链表为空，则返回一个
空指针。
    NodeType* maxpNodeType* L)
    {  NodeType* p=L->next,*s;
       if(p!=NULL)
    {   s=p;  //第一个结点初始化为最大的结点
            p=p->next;  //从第二个开始比较
            while(p!=NULL)
            {   if(p->data>s->data)  s=p;  //s指向当前最大的结点
                p=p->next;
    }
    return s；
      ｝
    else
       return  NULL；
    }

3. 设计一算法删除单链表中重复的结点。
    void pur_LinkList(NodeType * H)
    { NodeType *p,*q,*r;                      
       p=H->next;
          if (p==NULL) return；
          while(p->next)
          {  q=p; //找与p重复的结点并删除
             while(q->next)
               if (q->next->data==p->data)
                      { r=q->next;  q->next=r->next; free( r ); }
               else q= q ->next;
             p=p->next;
            }