seqlist和sqlist区别（SqList是什么类型）

本文目录

• SqList是什么类型
• c高手进来

SqList是什么类型

　　SqList 顺序线性表
　　#include《string.h》
　　#include《ctype.h》
　　#include《malloc.h》 /* malloc()等 */
　　#include《limits.h》 /* INT_MAX等 */
　　#include《stdio.h》 /* EOF(=^Z或F6),NULL */
　　#include《stdlib.h》 /* atoi() */
　　#include《io.h》 /* eof() */
　　#include《math.h》 /* floor(),ceil(),abs() */
　　#include《process.h》 /* exit() */
　　/* 函数结果状态代码 */
　　/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */
　　typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
　　typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
　　
　　Status InitList(SqList *L) /* 算法2.3 */
　　{ /* 操作结果：构造一个空的顺序线性表 */
　　(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
　　if(!(*L).elem)
　　exit(OVERFLOW); /* 存储分配失败 */
　　(*L).length=0; /* 空表长度为0 */
　　(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量 */
　　return OK;
　　}
　　Status CreatList(SqList*L)
　　{/*本算法通过向一个空的顺序表中树突元素啊来建立顺序表*/
　　int i;
　　printf("\n 待输入元素个数n=?");
　　scanf("%d",&L-》length);
　　for(i=0;i《L-》length;i++)
　　{ printf("\n data %d=?",i);
　　scanf("%d",(*L).elem);
　　}
　　}
　　int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
　　{ /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0) */
　　/* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
　　/* 若这样的数据元素不存在，则返回值为0。算法2.6 */
　　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;
　　}
　　
　　
　　Status ListInsert(SqList *L,int i,ElemType e) /* 算法2.4 */
　　{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
　　/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
　　ElemType *newbase,*q,*p;
　　if(i《1||i》(*L).length+1) /* i值不合法 */
　　return ERROR;
　　if((*L).length》=(*L).listsize) /* 当前存储空间已满,增加分配 */
　　{
　　newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
　　if(!newbase)
　　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;
　　}
　　Status ListDelete(SqList *L,int i,ElemType *e) /* 算法2.5 */
　　{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
　　/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
　　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;
　　}
　　Status PrintList(SqList)
　　{ /*依次输入顺序表L中的每个数据元素的值*/
　　ELemType *p;
　　int i;
　　p=L.elem;
　　printf("/n 顺序表L中的元素:\n");
　　for(i=1;i《=L.length;i++)
　　printf("%6d",L.elem);
　　printf("\n");
　　return OK;
　　}
　　
　　main()
　　{
　　int select,x,i;
　　SeqList L;
　　InitList(&L);
　　CreatList(&L);
　　while(1)
　　{ printf(" 请选择要进行的操作：\n");
　　printf("0--------退出\n");
　　printf("1--------查找\n");
　　printf("2--------插入\n");
　　printf("3--------删除\n");
　　printf("4--------输出\n");
　　scanf("%d",&select);
　　switch (select)
　　{
　　case 1:
　　printf("输入要查找的元素值");
　　scanf("%d",&x);
　　i=LocateElem(L,x);
　　if(i==0)printf("要查找的元素不存在\n");
　　else printf("找到的位置为%d\n",i);
　　break;
　　
　　case 2:
　　printf("输入要插入的位置");
　　scanf("%d",&i);
　　printf("输入要插入的元素值");
　　scanf("%d",&x);
　　ListInsert(SqList &L,i,x)
　　break;
　　
　　case 3:
　　printf("输入要删除的元素的位置");
　　scanf("%d",&i);
　　ListDelete(&L,i&x);
　　printf("元素%d已被删除 \n",x);
　　break;
　　
　　case 4:
　　PringList(L)
　　break;
　　case 0:
　　printf("程序结束，再见\n");
　　exit(0);
　　}
　　}

c高手进来

将所给元素x插到第i位置的算法
int insert(SeqList L, DataType x, int i ){
int k;
for(k=L.last;k》=i; k--)
L.data;//第i位置之后的元素依次向后移动
L.data=x; // 将所给元素x插到第i位置
L.last=L.last+1; // 表长加1
}
如果要调用上面的函数需要输入三个参数：要插入到哪个表中（L），插入的数据（x）,插到什么位置（i）
你的问题：类C 中是否是先输入数据然后再输入数据要存储的空间大小????
因为是顺序表，不像链表那样可以动态分配存储空间，你在定义一个顺序表时就必须给定它的大小，如这样定义一个顺序表：
typedef struct
{
datatype data;//数据的存储空间
int last; //表长
}Sqlist，*Seqlist;
问题二：
int Enqueue(SeqQueue *sq, DataType x){
if(sq-》font == (sq-》 rear+1)%maxsize) //判断队列是否已满，一般当队头、队尾指针值相同（sq-》font==sq-》rear），认为队空，为区别队空，sq-》font == (sq-》 rear+1)%maxsize 认为队满，%是模运算（取余数），maxsize是队长度
{
printf("Queue is full");
return 0;
}else{
sq-》rear= (sq-》rear +1)%maxsize; //你是不明白为什么要加%maxsize吧，你设想一下：如果队尾有元素了，你需要继续向后查找队头，即(sq-》rear +1)%maxsize。像栈、队列这些数据结构都是自己定义的，哪里有自己定位这种现象？等你数据结构学的更深入一些你就知道了
sq-》data=x;
return1;
}
问题三：
典型的根据数组下标计算地址的问题
index(aij) = n X (i-1) + j
计算的是二维数组（n X n）第i行，第j列的地址，首地址a=1，每个数组元素所占存储单元为1，即两相邻元素间隔为1
1 2 3 ... j ... n
n+1 n+2 n+3 ... n+j ... 2n
...
...
n*(i-1)+1 n*(i-1)+2 ... n*(i-1)+j ... n*i
至于
LOC (aij) =lOC(a11) + X b
只是首地址变成了lOC(a11)，每个数组元素所占空间不再是1，而是b而已，大同小异，你根据规律很容易得到计算公式了