02数据结构——线性表

1.线性表的顺序表示

1.1顺序表的定义

(Ⅰ)顺序表静态分配

#define MaxSize 50             //定义顺序表的最大长度
typedef struct{
    ElemType data[MaxSize];    //顺序表的元素
    int length;                //顺序表的当前长度
}SqList;                       //顺序表的类型定义

(Ⅱ)顺序表动态分配

#define InitSize 100           //表长度的初始定义
typedef struct{
    ElemType *data;            //指示动态分配数组的指针
    int MaxSize,length;        //数组的最大容量和当前个数
}SeqList;                      //动态分配数组顺序表的类型定义

(Ⅰ)插入操作

bool ListInsert(SqList &L,int i,ElemType e){
    if(i<1||i>L.length+1)              //判断i的范围是否有效
        return false;
    if(L.length>=MaxSize)              //当前存储空间已满，不能插入
        return false;                  
    for(int j=L.length;j>=i;j--)       //将第i个元素及之后的元素后移
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;                     //在位置i处放入e
    L.length++;                        //线性表长度加1
    return true;
} 

(Ⅱ)删除操作

bool ListDelete(SqList &L,int i,ElemType &e){
    if(i<1||i>L.length)            //判断i的范围是否有效
        return false;
    e=L.data[i-1];                 //将被删除的元素赋值给e
    for(int j=i;j<L.length;j++)    //将第i个位置后的元素前移
        L.data[j-1]=L.data[j];
    L.length--;                    //线性表长度减1
    return true;
}

 (Ⅲ)按值查找（顺序查找）

int LocateElem(SqList L,ElemType e){
    int i;
    for(i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;        //下标为i的元素值等于e,返回其位序i+1
    return 0;                  //推出循环,说明查找失败
}

---

2.线性表的链式表示

2.1单链表

(Ⅰ)单链表中结点类型

typedef struct LNode{             //定义单链表结点类型
    ElemType data;                //数据域
    struct LNode *next;           //指针域
}LNode,*LinkList;

 (Ⅰ)采用头插法建立单链表

LinkList List_HeadInsert(LinkList &L){        //逆向建立单链表
    LNode *s; int x;
    L=(LinkList)malloc(sizeof(LNode));        //创建头结点
    L->next=NULL;                             //初始为空链表
    scanf("%d",&x);                           //输入结点的值
    while(x!=9999){                           //输入9999表示结束
        s=(LNode*)malloc(sizeof(Lnode));      //创建新结点
        s->data=x;
        s->next=L->next;
        L->next=s;                            //将新结点插入表中,L为头指针
        scanf("%d",&x);
    }
    return L;
}

 (Ⅱ)采用尾插法建立单链表

LinkList List_TailInsert(LinkList &L){    //正向建立单链表
    int x;                        //设元素类型为整型
    L=(LinkList)malloc(sizeof(LNode));
    LNode *s,*r=L;                //r为表尾指针
    scanf("%d",&x);               //输入结点的值
    while(x!=9999){               //输入9999表示结束
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;                     //r指向新的表尾结点
        scanf("%d",&x);
    }
    r->next=NULL;                //为结点指针置空
    return L;
}

(Ⅲ)按序号查找结点

LNode *GetElem(LinkList L,int i){
    if(i<1)
        return false;        //若i无效,则返回NULL
    int j=1;                 //计数,初始为1
    LNode *p=L->next;        //第1个结点指针赋给p
    while(p!=NULL&&j<i){     //从第一个结点开始找,查找第i个结点
        p=p->next;
        j++;    
    }
    return p;                //返回第i个结点的指针,若i大于表长,则返回NULL
}

 (Ⅳ)按值查找表结点

LNode *LocateElem(LinkList L,ElemType e){
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)    //从第一个结点开始查找data域为e的结点
        p=p->next;
    return p;                     //找到后返回该结点的指针,否则返回NULL
}

 (Ⅴ)插入结点操作

//将新结点插入到单链表的第i个位置上
p=GetElem(L,i-1);        //查找插入位置的前驱结点
s->next=p->next;         //将之前p的后继现在当s的后继
p->next=s;               //将p的后继指向s

//扩展：对某一结点进行前插操作
p=GetElem(L,i-1)            //查找插入位置的前驱结点
s->next=p->next;            //修改指针域,不能颠倒
p->next=s;
temp=p->data;               //把p的数据赋给中间变量temp
p->data=s->data;            //把s的数据赋给p
s->data=temp;               //中间变量的数据赋给s,即完成了p和s的数据交换

(Ⅵ)删除结点操作

//删除结点操作是将单链表的第i个结点删除
p=GetElem(L,i-1)        //查找删除位置的前驱结点
q=p->next;              //令q指向被删除的结点
p->next=q->next;        //将*q结点从链中“断开”
free(q);                //释放结点的存储空间

//扩展：删除结点*p,删除结点*p的操作可用删除*p的后继结点操作实现
q=p->next;            //令q指向*p的后继结点
p->data=p->next->data;    //用后继结点的数据域覆盖
p->next=q->next;        //将*q结点从链中“断开”
free(q);                //释放后继结点的存储空间

(Ⅶ)求表长操作

//带头结点单链表求表的长度
int Length(LinkList L){
	LinkList p = L->next;        //p指向第一个结点
	int count=0;                //设定计数器count,初值为0
	while(p){                    //遍历单链表,统计结点数
        count++;
		p=p->next;
		
	}
	return count;              //返回表长
}

---

2.2双链表

(Ⅰ)双链表结点类型

typedef struct DNode{             //定义双链表结点类型
    ElemType data;                //数据域
    struct DNode *prior,*next;    //前驱和后继指针
}DNode,*DLinklist;

(Ⅱ)双链表的插入操作 

s->next=p->next;        //将结点*s插入到结点*p之后
p->next->prior=s;
s->prior=p;
p->next=s;

(Ⅲ)双链表的删除操作

p->next=q->next;            //图2.11中步骤①
q->next->prior=p;           //图2.11中步骤②
free(q);                    //释放结点空间

---

2.3循环链表

2.3.1循环单链表

2.3.2循环双链表

---

2.4静态链表 

 (Ⅰ)静态链表结构类型

#define MaxSize 50            //静态链表的最大长度
typedef struct{               //静态链表结构类型的定义
    ElemType data;            //存储数据元素
    int next;                //下一个元素的数组下标
}SLinkList[MaxSize];