本文介绍了一种将多个线性表合并成一个线性表的算法实现，通过具体示例展示了如何利用C语言进行线性表操作，包括插入、查找等基本功能。
概念少说，直接上代码:代码来源于清华大学严老师的数据结构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。
扫一扫
1128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
