四极管：数据结构2

上面上传的代码部分使用代码文本方式，显示有问题·还是直接上文本吧·

概念少说，直接上代码:代码来源于清华大学严老师的数据结构C语言版，再次只是自己分析和学习。

算法1：将两个或者两个以上的线性表合并为一个线性表

 以下是.cpp文件

#include"define.h" /*头文件及数据类型定义*/

/*ElemType是数据结构书上为了说明问题而用的一个词，他是element type("元素的类型")的简化体，使用过程中这个代表肯能的数据类型，在此定义为int*/

typedef int ElemType;

 

#include"StructDefine.h" /*线性表的动态分配顺序存储结构*/

#include "List.cpp"   /*顺序表示的线性表(存储结构由define.h定义)的基本操作（12个）*/

 

/*判断是否相等的函数，Union()用到*/

Status equal( ElemType c1, ElemType  c2 )

{

       if( c1 == c2 )

       {

              return TURE;

       }    

       else

       {

              return FALSE;

       }

 

}

/*将所有的线性表Lb中但是不在La中数据元素插入到La中*/

void Union( SqList &La, SqList Lb )

{

       ElemType e;

       int La_len,Lb_len;

       int i;

       La_len = ListLength( La );          /*求线性表La的长度*/

       Lb_len = ListLength( Lb );          /*求线性表La的长度*/

      

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

       {

              GetElem( Lb, i, e );             /*取Lb中的第i个数据元素赋值给e*/

              if( !LocateElem( La, e, equal ) )         /*La中不存在和e相同的元素，则插入*/

              {

                     ListInsert(La,++La_len,e); 

              }

       }

}

/*打印显示*/

void print( ElemType &c )

{

       printf( "%d", c);

}

 

/*主函数*/

void main()

{

       Sqlist La,Lb;

       Status i;

       int j;

       i = InitList( La );

       if( i == 1)                            /*创建空表La成功*/

       {

              for( j = 1; j <= 5; j++)           /*在表La中插入5个元素*/

              {

                     i = ListInsert( La,i,j );

              }

       }

       printf( "La = " );                     /*输出表La的内容*/

       ListTraverse( La,print );

       InitList( Lb );                               /*也可不判断是否创建成功*/

       for( j = 1; j <= 5; j++)                    /*在表Lb中插入5个元素*/

       {

              i = ListInsert( Lb, j, 2*j );

       }

       printf( "Lb = " );                 /*输出表Lb的内容*/

       ListTraverse( Lb,printf );

       Union( La,Lb );

       printf("new La = ");                        /*输出新表La的内容*/

       ListTraverse(La,print);

}

 

头文件define.h

#include <string.h>

#include <ctype.h>

#include <malloc.h>   /*molloc等*/

#include <limits>     /*INI_MAX等*/

#include <stdio.h>    /*EOF(=^Z或F6),NULL*/

#include <stdlib.h>   /*atoi()*/

#include <io.h>       /*eof()*/

#include <math.h>     /*floor(), cell(),abs()*/

#include <process.h>  /*exit()*/

#include <iostream.h> /*cout,cin*/

 

/*函数结果状态码*/

#define TRUE                  1

#define FALSE             0

#define OK                1

#define ERROR                0

#define INFEASIBLE    -1

 

/*#define OVERFLOW -2因为在main.h中已定义OVERFLOW的值为3，故去掉此行*/

typedef int Status;       /*Status是函数的类型，其值是函数结果状态码，如OK等*/

typedef int Boolean;      /*Boolean是布尔类型，其值是TRUE或FALSE*/

 

StructDefine.h头文件

 /*线性表的动态分配顺序存储结构*/

#define LIST_INIT_SIZE      10

#define LISTINCRMENT        2

struct Sqlist

{

       ElemType *elem;      /*存储空间的基址*/

       int length;          /*当前长度*/

       int listsize;        /*当前分配的存储内容(以sizeof(ElemType)为单位)*/

};

 

List.cpp

/*顺序表示的线性表(存储结构由StructDefine.h)定义的基本操作（12个）*/

 

/*操作结果：构造一个空的顺序线性表*/

Status InitList( SqList &L )

{

       L.elem = ( ElemType* )malloc(LIST_INT_SIZE * sizeof(ElemType));

       if(!L.elem)

       {

              exit(OVERFLOW); /*存储分配失败*/

       }

       L.length = 0;      /*空表长度为0*/

       L.listsize = LIST_INIT_SIZE;     /*初始存储容量*/

       return OK;

}

/*初始条件：顺序线性表L已存在。操作结果:销毁顺序线性表L*/

Status DestroyList( SqList &L )

{

       free(L.elem);

       L.elem = NULL;

       L.length = 0;

       return OK;

}

/*初始条件：顺序线性表L已存在。操作结果:将L重置为空表*/

Status ClearList( SqList &L )

{

       L.length = 0;

       return OK;

}

/*初始条件：顺序线性表L已存在。操作结果:若L为空表，则返回TRUE,否则返回FALSE*/

Status ListEmpty( SqList L )

{

       if(L.length == 0)

       {

              return TRUE;

      }

       else

       {

              return FALSE;

       }    

}

/*初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数*/

int ListLength(SqList L)

{

       return L.length;

}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)

   操作结果：用e返回L中第i个数据元素的值

*/

 

Status GetElem( SqList L, int i, ElemType &e )

{   

       if( (i < 1) || (i > L.length))

          exit( ERROR );

     e = *( L.elem+i-1 );

     return OK;

}

/* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0)

   操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。

   若这样的数据元素不存在，则返回值为0。

*/

int LocateElem( SqList L,ElemType e,Status( *compare )( ElemType, ElemType ) )

{   

       ElemType *p;

       int i=1;          /* i的初值为第1个元素的位序*/

       p=L.elem;      /* p的初值为第1个元素的存储位置*/

       while( i <= L.length && !compare( *p++,e ) )

       {

              ++i;

       }

       if( i <= L.length )

       {

              return i;

       }

       else

       {

              return 0;

       }

}

/* 初始条件：顺序线性表L已存在

   操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，

   否则操作失败，pre_e无定义

*/

Status PriorElem( SqList L, ElemType cur_e, ElemType &pre_e )

{   

       int i=2;

     ElemType *p=L.elem+1;

     while( i <= L.length && *p! = cur_e)

     {

                 p++;

                 i++;

     }

     if( i > L.length )

       {

                 return INFEASIBLE;

       }

     else

     {

                 pre_e = *--p;

                 return OK;

     }

}

/* 初始条件：顺序线性表L已存在

   操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，

   否则操作失败，next_e无定义

*/

 

Status NextElem( SqList L, ElemType cur_e, ElemType &next_e )

{   

       int i = 1;

     ElemType *p = L.elem;

     while( i < L.length && *p! = cur_e)

     {

                 i++;

                 p++;

     }

     if( i == L.length )

       {

                 return INFEASIBLE;

       }

     else

     {

                 next_e = *++p;

                 return OK;

     }

}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1

   操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1

*/

 

Status ListInsert(SqList &L,int i,ElemType e)

{   

       ElemType *newbase, *q,*p;

     if(i < 1 || i > L.length + 1)            /* i值不合法*/

       {

                 return ERROR;

      }   

       if(L.length >= L.listsize)                     /* 当前存储空间已满,增加分配*/

     {

                 if( !( newbase = ( ElemType * ) realloc ( L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType))) )

                exit( OVERFLOW );                   /* 存储分配失败*/

                 L.elem = newbase;                      /* 新基址*/

                 L.listsize += LISTINCREMENT; /* 增加存储容量*/

     }

     q = L.elem + i - 1;                      /* q为插入位置*/

     for( p = L.elem + L.length - 1; p >= q; --p ) /* 插入位置及之后的元素右移*/

          *(p+1) = *p;

     *q=e;                                 /* 插入e*/

     ++L.length;                         /* 表长增1*/

     return OK;

 }

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)

   操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1

*/

 Status ListDelete(SqList &L,int i,ElemType &e)

 {   

       ElemType *p,*q;

     if( i < 1 || i > L.length )                /* i值不合法*/

       {

                 return ERROR;

       }

     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;

 }

/* 初始条件：顺序线性表L已存在

   操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败

   vi()的形参加'&'，表明可通过调用vi()改变元素的值

*/

Status ListTraverse(SqList L,void(*vi)(ElemType&))

{   

       ElemType *p;

     int i;

     p = L.elem;

     for( i = 1; i <= L.length; i++)

          vi(*p++);

     cout << endl;

     return OK;

 }

 

 

 

转载请注明出处。作者：四极管。广西师范大学 电子工程学院大学生科技创新基地 邮箱： yangxingbo-0311@163.com。