数据结构之:线性表的顺序表示和实现
2006-06-05 17:27
916 查看
一、线性表的顺序表示
用一组地址连续的存储单元依次存储线性表的数据元素。C语言中的数组即采用顺序存储方式。
假设线性表的每个元素需占用l个存储单元，并以所占的第一个单元的存储地址作为数据元素的存储位置。则存在如下关系：
LOC(ai+1)=LOC(ai)+l
LOC(ai)=LOC(a1)+(i-1)*l
式中LOC(a1)是线性表的第一个数据元素的存储位置，通常称做线性表的起始位置或基地址。常用b表示。
线性表的这种机内表示称做线性表的顺序存储结构或顺序映象。
称顺序存储结构的线性表为顺序表。顺序表的特点是以元素在计算机内物理位置相邻来表示线性表中数据元素之间的逻辑关系。
二、顺序存储结构的线性表类C语言表示：
线性表的动态分配顺序存储结构
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct{
ElemType *elem; //存储空间基址
int length; //当前长度
int listsize; //当前分配的存储容量以一数据元素存储长度为单位
}SqList;
三、顺序存储结构的线性表操作及C语言实现：
顺序表的插入与删除操作：
顺序表的插入算法
status ListInsert(List *L,int i,ElemType e) {
struct STU *p,*q;
if (i<1||i>L->length+1) return ERROR;
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 Before i */
顺序表的合并算法
void MergeList(List *La,List *Lb,List *Lc) {
ElemType *pa,*pb,*pc,*pa_last,*pb_last;
pa=La->elem;pb=Lb->elem;
Lc->listsize = Lc->length = La->length + Lb->length;
pc = Lc->elem =
(ElemType *)malloc(Lc->listsize * sizeof(ElemType));
if(!Lc->elem) exit(OVERFLOW);
pa_last = La->elem + La->length - 1;
pb_last = Lb->elem + Lb->length - 1;
while(pa<=pa_last && pb<=pb_last) {
if(Less_EqualList(pa,pb)) *pc++=*pa++;
else *pc++=*pb++;
}
while(pa<=pa_last) *pc++=*pa++;
while(pb<=pb_last) *pc++=*pb++;
}
顺序表的查找算法
int LocateElem(List *La,ElemType e,int type) {
int i;
switch (type) {
case EQUAL:
for(i=0;i<length;i++)
if(EqualList(&La->elem[i],&e))
return 1;
break;
default:
break;
}
return 0;
}
顺序表的联合算法
void UnionList(List *La, List *Lb) {
int La_len,Lb_len; int i; ElemType e;
La_len=ListLength(La); Lb_len=ListLength(Lb);
for(i=0;i<Lb_len;i++) {
GetElem(*Lb,i,&e);
if(!LocateElem(La,e,EQUAL))
ListInsert(La,++La_len,e);
}
}
三、C语言源程序范例
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#define ERROR 0
#define OK 1
#define EQUAL 1
#define OVERFLOW -1
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
struct STU{
char name[20];
char stuno[10];
int age;
int score;
}stu[50];
typedef struct STU ElemType;
struct LIST
{
ElemType *elem;
int length;
int listsize;
};
typedef struct LIST List;
int init(List *L)
{
L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem) exit(OVERFLOW);
L->length=0;
L->listsize=LIST_INIT_SIZE;
return OK;
}/*init */
int ListLength(List *L)
{
return L->length;
}
void GetElem(List L,int i,ElemType *e)
{
*e=L.elem[i];
}
int EqualList(ElemType *e1,ElemType *e2)
{
if (strcmp(e1->name,e2->name)==0)
return 1;
else
return 0;
}
int Less_EqualList(ElemType *e1,ElemType *e2)
{
if (strcmp(e1->name,e2->name)<=0)
return 1;
else
return 0;
}
/* 顺序表的查找算法 */
int LocateElem(List *La,ElemType e,int type)
{
int i;
switch (type)
{
case EQUAL:
for(i=0;i<La->length;i++)
if(EqualList(&La->elem[i],&e))
return 1;
break;
default:
break;
}
return 0;
}
/* 顺序表的合并算法 */
void MergeList(List *La,List *Lb,List *Lc)
{
ElemType *pa,*pb,*pc,*pa_last,*pb_last;
pa=La->elem;pb=Lb->elem;
Lc->listsize = Lc->length = La->length + Lb->length;
pc = Lc->elem = (ElemType *)malloc(Lc->listsize * sizeof(ElemType));
if(!Lc->elem) exit(OVERFLOW);
pa_last = La->elem + La->length - 1;
pb_last = Lb->elem + Lb->length - 1;
while(pa<=pa_last && pb<=pb_last)
{
if(Less_EqualList(pa,pb)) *pc++=*pa++;
else *pc++=*pb++;
}
while(pa<=pa_last) *pc++=*pa++;
while(pb<=pb_last) *pc++=*pb++;
}
/* 顺序表的联合算法 */
void UnionList(List *La, List *Lb)
{
int La_len,Lb_len;
int i;
ElemType e;
La_len=ListLength(La); Lb_len=ListLength(Lb);
for(i=0;i<Lb_len;i++)
{
GetElem(*Lb,i,&e);
if(!LocateElem(La,e,EQUAL))
ListInsert(La,++La_len,e);
}
}
int printlist(List L)
{
int i;
printf("name stuno age score/n");
for(i=0;i<L.length;i++)
printf("%-10s %s/t%d/t%d/n", L.elem[i].name, L.elem[i].stuno,
L.elem[i].age, L.elem[i].score);
printf("/n");
}
/* 顺序表的插入算法 */
int ListInsert(List *L,int i,struct STU e)
{
struct STU *p,*q;
if (i<1||i>L->length+1) return ERROR;
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 Before i */
main()
{
struct STU e;
List La,Lb,Lc;
clrscr();
printf("/n/n-------------------List Demo is running...----------------/n/n");
printf("First is InsertList function./n");
init(&La);
strcpy(e.name,"stu1");
strcpy(e.stuno,"100001");
e.age=80;
e.score=1000;
ListInsert(&La,1,e);
strcpy(e.name,"stu3");
strcpy(e.stuno,"100002");
e.age=80;
e.score=1000;
ListInsert(&La,2,e);
printlist(La);
printf("List A length now is %d./n/n",La.length);
getch();
strcpy(e.name,"stu5");
strcpy(e.stuno,"100003");
e.age=80;
e.score=1000;
ListInsert(&La,3,e);
printlist(La);
printf("List A length now is %d./n/n",La.length);
getch();
init(&Lb);
strcpy(e.name,"stu2");
strcpy(e.stuno,"100001");
e.age=80;
e.score=1000;
ListInsert(&Lb,1,e);
strcpy(e.name,"stu4");
strcpy(e.stuno,"100002");
e.age=80;
e.score=1000;
ListInsert(&Lb,2,e);
strcpy(e.name,"stu6");
strcpy(e.stuno,"100001");
e.age=80;
e.score=1000;
ListInsert(&Lb,3,e);
printlist(Lb);
printf("List B length now is %d./n/n",Lb.length);
getch();
MergeList(&La,&Lb,&Lc);
printlist(Lc);
getch();
printf("Second is UnionList function./n");
printf("Now union List A and List B...../n");
UnionList(&La,&Lb);
printlist(La);
printf("List A length now is %d./n/n",La.length);
getch();
printf("/n/n/n/n/n/nWelcome to visit http://zmofun.heha.net !/n/n/n/n/n/n/n");
}
数据结构教程:
http://www.cstudyhome.com/datastruct1/index.htm
用一组地址连续的存储单元依次存储线性表的数据元素。C语言中的数组即采用顺序存储方式。
|
| a[9] |
|
LOC(ai+1)=LOC(ai)+l
LOC(ai)=LOC(a1)+(i-1)*l
式中LOC(a1)是线性表的第一个数据元素的存储位置，通常称做线性表的起始位置或基地址。常用b表示。
线性表的这种机内表示称做线性表的顺序存储结构或顺序映象。
称顺序存储结构的线性表为顺序表。顺序表的特点是以元素在计算机内物理位置相邻来表示线性表中数据元素之间的逻辑关系。
二、顺序存储结构的线性表类C语言表示：
线性表的动态分配顺序存储结构
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct{
ElemType *elem; //存储空间基址
int length; //当前长度
int listsize; //当前分配的存储容量以一数据元素存储长度为单位
}SqList;
三、顺序存储结构的线性表操作及C语言实现：
顺序表的插入与删除操作：
| 序号 | 数据元素 | 序号 | 数据元素 | 序号 | 数据元素 | 序号 | 数据元素 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
| <-25 |
|
|
|
| ->24 |
|
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| 插入前n=8;插入后n=9; | 删除前n=8;删除后n=7; |
status ListInsert(List *L,int i,ElemType e) {
struct STU *p,*q;
if (i<1||i>L->length+1) return ERROR;
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 Before i */
顺序表的合并算法
void MergeList(List *La,List *Lb,List *Lc) {
ElemType *pa,*pb,*pc,*pa_last,*pb_last;
pa=La->elem;pb=Lb->elem;
Lc->listsize = Lc->length = La->length + Lb->length;
pc = Lc->elem =
(ElemType *)malloc(Lc->listsize * sizeof(ElemType));
if(!Lc->elem) exit(OVERFLOW);
pa_last = La->elem + La->length - 1;
pb_last = Lb->elem + Lb->length - 1;
while(pa<=pa_last && pb<=pb_last) {
if(Less_EqualList(pa,pb)) *pc++=*pa++;
else *pc++=*pb++;
}
while(pa<=pa_last) *pc++=*pa++;
while(pb<=pb_last) *pc++=*pb++;
}
顺序表的查找算法
int LocateElem(List *La,ElemType e,int type) {
int i;
switch (type) {
case EQUAL:
for(i=0;i<length;i++)
if(EqualList(&La->elem[i],&e))
return 1;
break;
default:
break;
}
return 0;
}
顺序表的联合算法
void UnionList(List *La, List *Lb) {
int La_len,Lb_len; int i; ElemType e;
La_len=ListLength(La); Lb_len=ListLength(Lb);
for(i=0;i<Lb_len;i++) {
GetElem(*Lb,i,&e);
if(!LocateElem(La,e,EQUAL))
ListInsert(La,++La_len,e);
}
}
三、C语言源程序范例
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#define ERROR 0
#define OK 1
#define EQUAL 1
#define OVERFLOW -1
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
struct STU{
char name[20];
char stuno[10];
int age;
int score;
}stu[50];
typedef struct STU ElemType;
struct LIST
{
ElemType *elem;
int length;
int listsize;
};
typedef struct LIST List;
int init(List *L)
{
L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem) exit(OVERFLOW);
L->length=0;
L->listsize=LIST_INIT_SIZE;
return OK;
}/*init */
int ListLength(List *L)
{
return L->length;
}
void GetElem(List L,int i,ElemType *e)
{
*e=L.elem[i];
}
int EqualList(ElemType *e1,ElemType *e2)
{
if (strcmp(e1->name,e2->name)==0)
return 1;
else
return 0;
}
int Less_EqualList(ElemType *e1,ElemType *e2)
{
if (strcmp(e1->name,e2->name)<=0)
return 1;
else
return 0;
}
/* 顺序表的查找算法 */
int LocateElem(List *La,ElemType e,int type)
{
int i;
switch (type)
{
case EQUAL:
for(i=0;i<La->length;i++)
if(EqualList(&La->elem[i],&e))
return 1;
break;
default:
break;
}
return 0;
}
/* 顺序表的合并算法 */
void MergeList(List *La,List *Lb,List *Lc)
{
ElemType *pa,*pb,*pc,*pa_last,*pb_last;
pa=La->elem;pb=Lb->elem;
Lc->listsize = Lc->length = La->length + Lb->length;
pc = Lc->elem = (ElemType *)malloc(Lc->listsize * sizeof(ElemType));
if(!Lc->elem) exit(OVERFLOW);
pa_last = La->elem + La->length - 1;
pb_last = Lb->elem + Lb->length - 1;
while(pa<=pa_last && pb<=pb_last)
{
if(Less_EqualList(pa,pb)) *pc++=*pa++;
else *pc++=*pb++;
}
while(pa<=pa_last) *pc++=*pa++;
while(pb<=pb_last) *pc++=*pb++;
}
/* 顺序表的联合算法 */
void UnionList(List *La, List *Lb)
{
int La_len,Lb_len;
int i;
ElemType e;
La_len=ListLength(La); Lb_len=ListLength(Lb);
for(i=0;i<Lb_len;i++)
{
GetElem(*Lb,i,&e);
if(!LocateElem(La,e,EQUAL))
ListInsert(La,++La_len,e);
}
}
int printlist(List L)
{
int i;
printf("name stuno age score/n");
for(i=0;i<L.length;i++)
printf("%-10s %s/t%d/t%d/n", L.elem[i].name, L.elem[i].stuno,
L.elem[i].age, L.elem[i].score);
printf("/n");
}
/* 顺序表的插入算法 */
int ListInsert(List *L,int i,struct STU e)
{
struct STU *p,*q;
if (i<1||i>L->length+1) return ERROR;
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 Before i */
main()
{
struct STU e;
List La,Lb,Lc;
clrscr();
printf("/n/n-------------------List Demo is running...----------------/n/n");
printf("First is InsertList function./n");
init(&La);
strcpy(e.name,"stu1");
strcpy(e.stuno,"100001");
e.age=80;
e.score=1000;
ListInsert(&La,1,e);
strcpy(e.name,"stu3");
strcpy(e.stuno,"100002");
e.age=80;
e.score=1000;
ListInsert(&La,2,e);
printlist(La);
printf("List A length now is %d./n/n",La.length);
getch();
strcpy(e.name,"stu5");
strcpy(e.stuno,"100003");
e.age=80;
e.score=1000;
ListInsert(&La,3,e);
printlist(La);
printf("List A length now is %d./n/n",La.length);
getch();
init(&Lb);
strcpy(e.name,"stu2");
strcpy(e.stuno,"100001");
e.age=80;
e.score=1000;
ListInsert(&Lb,1,e);
strcpy(e.name,"stu4");
strcpy(e.stuno,"100002");
e.age=80;
e.score=1000;
ListInsert(&Lb,2,e);
strcpy(e.name,"stu6");
strcpy(e.stuno,"100001");
e.age=80;
e.score=1000;
ListInsert(&Lb,3,e);
printlist(Lb);
printf("List B length now is %d./n/n",Lb.length);
getch();
MergeList(&La,&Lb,&Lc);
printlist(Lc);
getch();
printf("Second is UnionList function./n");
printf("Now union List A and List B...../n");
UnionList(&La,&Lb);
printlist(La);
printf("List A length now is %d./n/n",La.length);
getch();
printf("/n/n/n/n/n/nWelcome to visit http://zmofun.heha.net !/n/n/n/n/n/n/n");
}
数据结构教程:
http://www.cstudyhome.com/datastruct1/index.htm
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 数据结构笔记（一）线性表的顺序表示和基本操作及其顺序表实现的集合运算（A-B）U（B-A）实例
- 数据结构教程 第六课 线性表的顺序表示和实现
- 数据结构1：线性表的顺序表示和实现
- 线性表的顺序表示和实现 - 数据结构
- 线性表的顺序表示和实现 - 数据结构
- 数据结构之线性表的顺序表示和实现
- 数据结构(5)：循环队列——队列的顺序表示和实现
- 数据结构二：线性表的顺序结构实现
- 数据结构与算法——线性表的顺序表示
- 【数据结构作业一】写出顺序表的结构体类型定义及查找、插入、删除算法，并以顺序表作存储结构，实现线性表的插入、删除
- 数据结构之线性表的链式表示和实现
- 数据结构2----线性表顺序存储和链式存储的实现(霜之小刀)
- 数据结构之线性表代码实现顺序存储，链式存储，静态链表（选自大话数据结构）
- 数据结构（严蔚敏）C语言实现---线性表的顺序存储
- [C语言][数据结构]基础的线性表的顺序表示和实现
- 数据结构(2)：线性表的链式表示和实现
- 数据结构算法代码实现——线性表的链式表示与实现(单链表)(三 )
- C语言 数据结构 线性表的顺序表示
- 数据结构复习——线性表的顺序存储实现
- 数据结构之线性表顺序实现