极语言6-1 线性表和它的操作源码

//线性顺序表

包含 "习语言系统.接口"

包含 "习语言视窗.接口"

定义 宏_初始存储空间 1000 //线性表存储空间的初始分配量

定义 宏_分配增量 100 //线性表存储空间的分配增量

定义 OK 1

定义 宏_出错 0

定义 宏_溢出 -2

类型定义 整数类型 元素类型;
类型定义 结构类型
{

元素类型 *表数据;//线性表首地址  
整数类型 表长度;//当前的长度  
元素类型 表存储容量;//当前分配的存储容量，以元素类型为单位  

} 线性顺序表;

无返回值 重新分配空间(线性顺序表 *表)//空间不够时重新分配空间的函数
{

元素类型 *临时基址;//分配一个临时基址  
临时基址 = (元素类型 *) 内存重新申请(表->表数据,(表->表存储容量 + 宏_分配增量) * 类型长度(元素类型));  
如果(!临时基址) 退出(宏_出错);  
表->表数据 = 临时基址;  
表->表存储容量 += 宏_分配增量;  

}

//初始化一个空的线性表
整数类型 初始化线性顺序表(线性顺序表 *表)
{

表->表数据 = (元素类型*) 内存申请(宏_初始存储空间 *类型长度(元素类型));  
如果(!表->表数据) 退出(宏_出错);
表->表长度 = 0;//初始表为空表  
表->表存储容量 = 宏_初始存储空间;//初始表的存储容量
返回 OK;  

}
//求表中元素的个数
整数类型 求表元素个数(线性顺序表 *表)
{

返回 表->表长度;  

}

//遍历顺序表
无返回值 遍历顺序表(线性顺序表 *表)
{

整数类型 计数;  

步进循环(计数 = 0; 计数 < 表->表长度; 计数++)

{  
   图形格式输出("%整 ",表->表数据[计数]);  
}  
图形格式输出("%行");  
返回;  

}
//向表头插入元素
无返回值 表头插入(线性顺序表 *表,元素类型 元素)
{

整数类型 计数;  
如果(表->表长度 >= 表->表存储容量)  
    重新分配空间(表);  
步进循环(计数 = 表->表长度-1; 计数 >= 0; 计数--)  
    表->表数据[计数+1] = 表->表数据[计数];  
表->表数据[0] = 元素;  
表->表长度++;  
返回;  

}

//向表尾插入元素
无返回值 表尾插入(线性顺序表 *表,元素类型 元素)
{

如果(表->表长度 >= 表->表存储容量)  
     重新分配空间(表);   
表->表数据[表->表长度] = 元素;  
表->表长度++;  
返回;  

}
//在表中第pos个位置之前插入新元素e
整数类型 表中插入(线性顺序表 *表,元素类型 元素,整数类型 位置)
{

整数类型 计数;  
如果(位置 < 1 || 位置 > 表->表长度+1) 
返回 宏_出错;  
如果(表->表长度 >= 表->表存储容量)//存储空间不够，要分配新的空间  
    重新分配空间(表);   
步进循环(计数 = 表->表长度-1; 计数 >= 位置-1; 计数--)  
    表->表数据[计数+1] = 表->表数据[计数];  
表->表数据[位置 - 1] = 元素;  
表->表长度++;  
返回 OK;  

}

//查找给出元素的位置，若存在，给出位置(从1开始算)；若不存在，返回-1
无返回值 查找(线性顺序表 *表,元素类型 元素)
{

整数类型 计数; 
步进循环(计数 = 0; 计数 < 表->表长度; 计数++)  
{  
    如果(表->表数据[计数] == 元素)  
    {  
        图形格式输出("找到，%整在第%整个位置%行",元素,计数+1);  
        返回;  
    }  
}  
图形格式输出("没找到%行");  
返回;  

}
//删除第pos个元素，并返回其值
元素类型 删除元素(线性顺序表 *表,整数类型 位置)
{

整数类型 计数;   
元素类型 临时变量;  
如果(位置 < 1 || 位置 > 表->表长度)  
{  
    图形格式输出("位置值越界%行");  
    退出(1);  
}  
临时变量 = 表->表数据[位置-1];  
步进循环(计数 = 位置; 计数 < 表->表长度; 计数++)  
表->表数据[计数-1] = 表->表数据[计数];  
表->表长度--;  
返回 临时变量;  

}

//判断线性表是否为空，为空返回1，不为空返回0
整数类型 判断是否为空(线性顺序表 *表)
{

如果(表->表长度 == 0)  
    返回 1;  
否则  
    返回 0;  

}

//顺序表的逆置
无返回值 顺序表逆置(线性顺序表 *表)
{

整数类型 低位 = 0, 高位 = 表->表长度-1;  
元素类型 临时变量;  
整数类型 计数;  
步进循环(计数 = 0; 计数 < 表->表长度 / 2; 计数++)  
{  
   临时变量 = 表->表数据[低位];  
   表->表数据[低位++] = 表->表数据[高位];  
   表->表数据[高位--] = 临时变量;  
}  

}

无返回值 表合并(线性顺序表 表a,线性顺序表 表b,线性顺序表 *表c)
{

表c->表存储容量 = 表c->表长度 = 表a->表长度 + 表b->表长度;  
表c->表数据 = (元素类型 *) 内存申请(类型长度(元素类型));  
如果(!表c->表数据) 退出(宏_出错);  
整数类型 i = 0, j = 0, k = 0;  
当(i < 表a->表长度 && j < 表b->表长度)  
{  
    如果(表a->表数据[i] <= 表b->表数据[j])  
    {  
        表c->表数据[k++] = 表a->表数据[i++];  
    }  
    否则  
    {  
        表c->表数据[k++] = 表b->表数据[j++];  
    }  
}  
当(i<表a->表长度)  
{  
    表c->表数据[k++] = 表a->表数据[i++];  
}  
当(j < 表b->表长度)  
{  
    表c->表数据[k++] = 表b->表数据[j++];  
}  

}
整数类型 主函数()
{

视窗开始2(1366,768,"窗口",显示器属性_可变尺寸);
线性顺序表 表1;  
初始化线性顺序表(&表1);  
整数类型 长度;  
图形格式输入("%整",&长度);  
整数类型 计数;  
元素类型 临时变量;  
步进循环(计数 = 0; 计数 < 长度; 计数++)  
{  
    图形格式输入("%整",&临时变量);  
    表尾插入(&表1,临时变量);  
}  
图形格式输出("创建好的线性表表a=");  
遍历顺序表(&表1);//创建好的顺序表 
整数类型 位置;  
图形格式输入("%整%整",&临时变量,&位置);  
表中插入(&表1,临时变量,位置);  
图形格式输出("插入一个元素后的线性表La=");  
遍历顺序表(&表1);//插入一个数字后的线性表  
图形格式输入("%整",&位置);  
删除元素(&表1,位置);  
图形格式输出("删除一个元素后的线性表表a=");  
遍历顺序表(&表1);  
图形格式输入("%整",&临时变量);  
查找(&表1,临时变量);//查找元素  
图形格式输出("逆置后的线性表表a=");  
顺序表逆置(&表1);  
遍历顺序表(&表1);  
线性顺序表 表2;  
初始化线性顺序表(&表2);  
图形格式输入("%整",&长度);  
步进循环(计数 = 0; 计数 < 长度; 计数++)  
{  
    图形格式输入("%整",&临时变量);  
    表尾插入(&表2,临时变量);  
}  

线性顺序表 表3;  
表合并(&表1,&表2,&表3);  
图形格式输出("合并表a和表b后的线性表=");  
遍历顺序表(&表3);  
返回 0;  

}

/*
//线性顺序表

include <stdio.h>

include <stdlib.h>

define LIST_INIT_SIZE 1000 //线性表存储空间的初始分配量

define LISTINCRESEMENT 100 //线性表存储空间的分配增量

define OK 1

define ERROR 0

define OVERFLOW -2

typedef int elemType;//元素类型
typedef struct
{

elemType *List;//线性表首地址  
int length;//当前的长度  
int listsize;//当前分配的存储容量，以elemType为单位  

} SqList;

void AgainMalloc(SqList *L)//空间不够时重新分配空间的函数
{

elemType *newbase;//分配一个临时基址  
newbase=(elemType *)realloc(L->List,(L->listsize+LISTINCRESEMENT)*sizeof(elemType));  
if(!newbase) exit(OVERFLOW);  
L->List=newbase;  
L->listsize+=LISTINCRESEMENT;  

}

//初始化一个空的线性表
int InitList_Sq(SqList *L)
{

L->List=(elemType *)malloc(LIST_INIT_SIZE*sizeof(elemType));  
if(!L->List)exit(OVERFLOW);//overflow  
L->length=0;//初始表为空表  
L->listsize=LIST_INIT_SIZE;//初始表的存储容量，为LIST_INIT_SIZE个elemType单位  
return OK;  

}
//求表中元素的个数
int ListLength(SqList *L)
{

return L->length;  

}

//遍历顺序表
void TraverseList(SqList *L)
{

int i;  
for(i=0; i<L->length; i++)  
{  
    printf("%d ",L->List[i]);  
}  
printf("\n");  
return;  

}
//向表头插入元素
void InsertFirst(SqList *L,elemType e)
{

int i;  
if(L->length>=L->listsize)  
    AgainMalloc(L);  
for(i=L->length-1; i>=0; i--)  
    L->List[i+1]=L->List[i];  
L->List[0]=e;  
L->length++;  
return;  

}

//向表尾插入元素
void InsertLast(SqList *L,elemType e)
{

if(L->length>=L->listsize)  
    AgainMalloc(L);  
L->List[L->length]=e;  
L->length++;  
return;  

}
//在表中第pos个位置之前插入新元素e
int Insert_Sq(SqList *L,elemType e,int pos)
{

int i;  
if(pos<1||pos>L->length+1) return ERROR;  
if(L->length>=L->listsize)//存储空间不够，要分配新的空间  
    AgainMalloc(L);  
for(i=L->length-1; i>=pos-1; i--)  
    L->List[i+1]=L->List[i];  
L->List[pos-1]=e;  
L->length++;  
return OK;  

}
//查找给出元素的位置，若存在，给出位置(从1开始算)；若不存在，返回-1
void Search(SqList *L,elemType e)
{

int i;  
for(i=0; i<L->length; i++)  
{  
    if(L->List[i]==e)  
    {  
        printf("找到，%d在第%d个位置\n",e,i+1);  
        return;  
    }  
}  
printf("没找到\n");  
return;  

}
//删除第pos个元素，并返回其值
elemType DeleteElem(SqList *L,int pos)
{

int i;  
elemType temp;  
if(pos<1||pos>L->length)  
{  
    printf("pos值越界\n");  
    exit(1);  
}  
temp=L->List[pos-1];  
for(i=pos; i<L->length; i++)  
    L->List[i-1]=L->List[i];  
L->length--;  
return temp;  

}
//判断线性表是否为空，为空返回1，不为空返回0
int isEmpty(SqList *L)
{

if(L->length==0)  
    return 1;  
else  
    return 0;  

}

//顺序表的逆置
void Inverse(SqList *L)
{

int low=0,high=L->length-1;  
elemType temp;  
int i;  
for(i=0; i<L->length/2; i++)  
{  
    temp=L->List[low];  
    L->List[low++]=L->List[high];  
    L->List[high--]=temp;  
}  

}

void MergeList(SqList La,SqList Lb,SqList *Lc)
{

//elemType *pa=La->List;elemType *pb=Lb->List;  
Lc->listsize=Lc->length=La->length+Lb->length;  
Lc->List=(elemType *)malloc(sizeof(elemType));  
if(!Lc->List) exit(OVERFLOW);  
int i=0,j=0,k=0;  
while(i<La->length&&j<Lb->length)  
{  
    if(La->List[i]<=Lb->List[j])  
    {  
        Lc->List[k++]=La->List[i++];  
    }  
    else  
    {  
        Lc->List[k++]=Lb->List[j++];  
    }  
}  
while(i<La->length)  
{  
    Lc->List[k++]=La->List[i++];  
}  
while(j<Lb->length)  
{  
    Lc->List[k++]=Lb->List[j++];  
}  

}
int main()
{

SqList list1;  
InitList_Sq(&list1);  
int length;  
scanf("%d",&length);  
int i;  
elemType temp;  
for(i=0; i<length; i++)  
{  
    scanf("%d",&temp);  
    InsertLast(&list1,temp);  
}  
printf("创建好的线性表La=");  
TraverseList(&list1);//创建好的顺序表  
int pos;  
scanf("%d%d",&temp,&pos);  
Insert_Sq(&list1,temp,pos);  
printf("插入一个元素后的线性表La=");  
TraverseList(&list1);//插入一个数字后的线性表  
scanf("%d",&pos);  
DeleteElem(&list1,pos);  
printf("删除一个元素后的线性表La=");  
TraverseList(&list1);  
scanf("%d",&temp);  
Search(&list1,temp);//查找元素  
printf("逆置后的线性表La=");  
Inverse(&list1);  
TraverseList(&list1);  
SqList list2;  
InitList_Sq(&list2);  
scanf("%d",&length);  
for(i=0; i<length; i++)  
{  
    scanf("%d",&temp);  
    InsertLast(&list2,temp);  
}  

SqList list3;  
MergeList(&list1,&list2,&list3);  
printf("合并La和Lb后的线性表=");  
TraverseList(&list3);  
return 0;  

}
*/