数据结构与算法——线性结构——线性表及其表示

-“一，线性结构
1.顺序储存结构直接表示 多项式。
1).使用数组来表示多项式。（用数组下标来表示指数，值来表示系数）
可以表示成：


2).使用结构数组来表示。（把系数和指数看成一个二元组集合）
相加时。比较指数，相同系数相加，不同，大的输出
3).链表储存非零项。
相加时同2）
表示时，有三个域：系数和指数两个数据域以及一个指针域
例如：

可以表示成：

2.线性表：由同类型的数据元素构成的有序序列的线性结构
元素个数称为线性表的长度
没有元素时，称为空表
标的起始位置称为表头，标结束位置称为表尾

抽象数据类型描述：
类型名称：（ 线性表（List ）
数据对象集：是 线性表是 n (≥0) 个元素构成的有序序列( a 1 , a 2 , ……,a n )
操作集：表 线性表L 属于 List ，整数i 表示位置，元素X 属于ElementType ，
线性表基本操作主要有：
1 、List MakeEmpty()： ： 初始化一个空线性表L ；
2 、ElementType FindKth( int K, List L ) ：根据位序K ，返回相应元素 ；
3 、int Find( ElementType X, List L ) ：在线性表L 中查找X 的第一次出现位置；
4 、void Insert( ElementType X, int i, List L) ：在位序i 前插入一个新元素X ；
5 、void Delete( int i, List L ) ：删除指定位序i 的元素；
6 、int Length( List L ) ：返回线性表L 的长度n
线性表的操作：
1.利用数组的连续储存空间顺序存放线性表的各元素
定义：

struct LNode{
    ElementType data[MAXSIZE];
    int Last;    //长度
};
typedef struct LNode *List;
struct LNode L;
List PtrL;

(1).初始化（建立空的数据表）

List MakeEmpty()
{
    List PtrL;
    PtrL=(List)malloc(sizeof(struct LNode));
    PrtL->Last=-1;
    return PtrL;
}

(2).查找：

int Find(ElementType X, List PtrL)
{
    int i=0;
    while(i<=Ptrl->Last && Ptrl->data[i]!=X)
        i++;
    if(i>Ptrl->Last)return 01;
    else return i;
}

(3).插入:

void Insert(ElementType X, itn i, List PrtL)
{
    int j;
    if(PrtL->Last==MAXSIZE-1){
        printf("表已满");
    return;
}
    if(i<1 ||i>PtrL->Last+2){
        printf("位置不合法");
    return;
}
    for(j=PtrL->Last; j>=i-1; j--)
        PrtL->data[j+1]=PtrL->data[j];
    PtrL->data[i-1]=x;
    PtrL->Last++;
    return;
}

(4).删除:

void Delete(int i, List PtrL)
{
    int j;
    if(i<1 || i>PtrL->Last+1){
        printf("第%d个元素不存在",i);
        return;
    }
    for(j=i; j<=PtrL->last; j++)
        PtrL->data[j-1]=PtrL->data[j];
    PtrL->last--;
    return;
}

2.线性表的链式储存
定义：

typedef struct LNode *List;
struct LNode{
    ElementType data;
    List next;
};
struct LNode L;
List PtrL;

(1).求表长：

int Length(List PtrL)
{
    List p=PtrL;
    int j=0;
    while(p){
        p=p->next;
        j++;
    }
    return j;
}

(2).查找：

//按序号查找
List FindKth(int K, List PrtL)
{
    List p=PtrL;
    int i=1;
    while(p!=NULL && i<K){
        p=p->next;
        i++;
    }
    if(i==K) return p;
    else return NULL;
}

//按值查找
List Find (ElementType X, List PtrL)
{
    List p=PtrL;
    while(p!=NULL && p->data!=X)
        p=p->next;
    return p;
}

(3)插入：

List Insert(ElementType X, int i, List PtrL)
{
    List p, s;
    if(i==1){
        s=(List)malloc(sizeof(struct LNode));
        s->data=X;
        s->next=PtrL;
        return s;
    }
    if(p==NULL){
        printf("参数错误");
        return NULL;
    }else{
        s=(List)malloc(sizeof(struct LNode));
        s->data=X;
        s->next=p->next;
        p->next=s;
        retutn PtrL;
    }
}

(5).删除：

List Delete( int i, List PtrL )
{ 
    List p, s;
    if ( i == 1 ) {
        s = PtrL;
        if (PtrL!=NULL) PtrL = PtrL->Next;
            else return NULL;
        free(s);
        return PtrL;
    }
    p = FindKth( i-1, PtrL );
    if ( p == NULL ) {
        printf("第%d个结点不存在", i-1); return NULL;
    } else if ( p->Next == NULL ){
            printf("第%d 个结点不存在", i); return NULL;
        } else {
            s = p->Next;
            p->Next = s->Next; 
            free(s);
            return PtrL;
        }
}

2.广义表：比如二元多项式
线性表的一种推广。
3.多重链表：链表中的节点可能同时隶属于多个链
多重链表中的节点的指针域会有多个
包含两个指针域的链表不一定是多重链表，例如双向链表就不是多重链表：可以用来对数，图，这样的相对复杂的数据结构
比如说对稀疏矩阵的存储：