数据结构 5.8 知识点

线性结构：线性表 ，n个类型相同的元素，元素间一对一的关系，n可以为0，即空表
线性表----算法----顺序存储结构实现（顺序表）----链式存储结构实现（单链表）

typedef struct S{
ElemType *elem; //指向存放线性表中数据元素的基地址
int length; //线性表的当前长度
int listsize; //当前分配的存储容量
}SqList,*List;

struct S a等价于SqList a;
struct S *p等价于List p等价于SqList * p;

int main（）
{
// SqList * L;
//InitList(L)//错误，因为L没有确定的值
SqList sqList;
SqList *L=&sqList;
InitList(L);//等价于InitList(&sqList)
}

Status InitList (SqList *L)//构造一个空线性表
{
分配动态内存
长度为0
容量=malloc（sizeof()）；
代码如下：
L->elem=(ElemType )malloc(INITSIZEsizeof(ElemType));
if(L->elem==NULL)
return ERROR;
L->length=0;
L->listsize=INITSIZE;
return OK;
}
int ListLength(SqList L)//求线性表的长度
{

return (L.length);
}
int IsEmpty(SqList L)//判断线性表是否为空
{
return (L.length==0?TRUE:FALSE);
}
status GetElem(SqList L,int i,ElemType *e)//获取线性表第i位置的元素
{
if(i<1||i>L.length)//判断位置是否是小于1或者大于表长
return ERROR;
*e=L.elem[i-1];//用e带回下标为i-1的元素
return OK;
}
int LocateELem(SqList L,ElemType e)//查询数据元素e，返回其位置
{
遍历顺序表，逐个对比
for(i=0;i<L.length;i++)
{
if(L.elem[i]==e)
{
return i+1;
}
}
return -1;
}
Status ListInsert(SqList *L,int i,ElemType e)//在线性表第i位置插入元素e
{

ElemType *p,*q,*new;
if(i<1||i>L->length)
return ERROR;

if(L->listsize<=L->length){
new=(ElemType * )realloc(L->elem,(L>listsize+CREATSIZE)*sizeof(ElemType));//动态分配内存

if(!new) exit(OVERFLOW);

L->elem=new;
L->listsize+=CREATSIZE;//增加新的存储容量
}
q=&(L->elem[i-1]);
for (p=&(L->elem[L->length-1]);p>=q;–p)
{
*(p+1)=*p;//将元素后移
}
*q=e;
L->length++;
return OK;
}
Status ListDelete(SqList *L,int i,ElemType *e)//删除线性表中第i位置的元素
{
if(i<1||i>L->length) return ERROR;
ElemType *p,*q;

p=&(L->elem[i-1]);
*e=*p;

q=&(L->elem[L->length-1]);
for(++p;p<=q;++p)
{
*(p-1)=*p;//将元素前移
}
L->length–;
return OK;
}

---

单链表实现算法
typedef struct Node{
ElemType data; //指向存放线性表中数据元素的基地址，即存放动态数组的首地址
struct Node *next; //线性表的当前长度 即元素的个数

}LinList;

struct Node *head;<===>LinList *head;

int main()
{
LinList list;
LinList *head=&list;
InitList(head);
}
Status InitList (LinList *L)//构造一个空线性表
{
L=(LinkList )malloc(sizeof(LinkList));
L->next=NULL;
return OK;
}
int ListLength(LinList L)//求线性表的长度
{
LinList p=&L;
int i=0;
/ while（p！=NULL）
{
p=p->next;
i++;
}
return i-1;/

while（p->next！=NULL）
{
p=p->next;
i++;
}
return i;

}
int IsEmpty(LinList L)//判断线性表是否为空
{
if(L->next==NULL)
return TRUE;
else return ERROR；
}
status GetElem(SqList L,int i,ElemType *e)//获取线性表第i位置的元素
{
LinList *p=&L;
int j=0;
if(i<1||i>ListLength(L))
return ERROR;

// 定位到i位置
while（j<i）
{
p=p->next;
j++;
}
*e=p->data
return OK;//成功获取
}
int LocateELem(SqList L,ElemType e)//查询数据元素e，返回其位置
{
LinList *p=&L;
int i=0;
while（p->next！=NULL）
{
p=p->next;
i++;
if(p->data==e)
return i;
}
}
Status ListInsert(SqList *L,int i,ElemType e)//在线性表第i位置插入元素e
{
定位到i-1位置的结点

LinList *p=&L，*s;
int j=0;
if(i<1||i>ListLength(L)+1)
return ERROR;
p=p->next;
while（j<i-1）
{
p=p->next;
j++;
}
s=(LinkList *)malloc(sizeof(LinkList));
if(!s)
exit(OVERFLOW);
s->data=e;
s->next=p->next;
p->next=s;
return OK;
}
Status ListDelete(SqList *L,int i,ElemType *e)//删除线性表中第i位置的元素
{
定位到i-1位置的结点

LinList *p=&L,*s;
int j=0;
if(i<1||i>ListLength(L)+1)
return ERROR;
p=p->next;
while（j<i-1）
{
p=p->next;
j++;
}
//循环结束，p指向要删除结点前面的一个结点
s=p->next;
p->next=s->next;
free(s);//释放s所占的空间
return OK;
}

循环单链表：操作和单链表基本一致，只是遍历时的循环条件由p->next!=NULL变成p->next！=head
双向链表:结点中多一个数据域，插入，删除操作，遍历时的循环条件p->next!=NULL
双向循环链表：操作和双向链表基本一致，只是遍历时的循环条件由p->next!=NULL变成p->next！=head

栈的队列
栈：限定仅在表尾进行插入或者删除操作的线性表，表尾端称作栈顶，表头端称作栈底
栈的两种实现方式：顺序栈，链式栈

顺序栈的定义：
typedef struct{
SElemtype *base;//代表栈底指针
SElemtype *top;//代表栈顶指针
int stacksize;//栈当前的最大容量

}Sqstack;

top==base可以作为栈为空的标记，插入新的栈顶元素，top++;