数据结构-线性表

数据结构-线性表

• 数据结构-线性表
  - Part1-基础知识
  - Part2-顺序表的基本操作
  - Part3-单链表
  - Part4-双链表
  - Part5-循环链表
  - 循环单链表
  - 循环双链表

Part1-基础知识

1. 线性表定义: 线性表是具有相同数据类型的n(n>0)个数据元素的有限序列，n为表长;

    表示为 L = (a1,a2,a3......an)
   

2. 特点

   • 个数有限
   • 具有逻辑上的先后次序
   • 数据类型都相同，每个元素占用相同大小的存储空间

3. 顺序表的定义: 线性表的顺序存储又称顺序表。是用一组地址连续的存储单元依次存储线性表中的数据元素，使得元素在逻辑和物理上都相邻

4. 描述-数组静态分配

#define MaxSize 50
typedef struct{
    Elemtype data[MaxSize];
    int length;
}SqList;

5. 描述-数组动态分配

#define InitSize 100
typedef struct{
    ElemType *data;
    int MaxSize,length; //最大容量与当前个数
}SqList;

Part2-顺序表的基本操作

1. 插入: 第i个位置插入元素e; 时间复杂度O(n)

bool ListInsert(SqList &L,int i,ElemType e){
    if(i<1 || i>L.length+1) return false; //判断i是否有效
    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;
    L.length ++;
    return true;
}

2. 删除: 删除第i个元素; 时间复杂度O(n)

bool ListInsert(SqList &L,int i,ElemType &e){
    if(i<1 || i>L.length+1) return false; //判断i是否有效
    e = L.data[i-1];
    for(int j = i;j < L.length;j++){    // 第i个元素后移
        L.data[j-1] = L.data[j];
    }
    L.length ++;
    return true;
}

3. 按值查找: 第一个元素为e的元素，并返回位置; 时间复杂度O(n)

int LocateElem(SqList L,ElemType e){
    for(int i = 0;i < L.length; i++){
        if(L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}

Part3-单链表

1. 线性表的链式存储又称单链表，

typedef struct LNode{
    ELemType data;
    struct LNode *next;
}LNode,*LinkList;

2. 通常用头指针标识一个单链表，在单链表第一个节点之前附加一个节点，称为头结点。
3. 头插法建立单链表; 时间复杂度O(n)
   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tBxgvx6d-1601395188994)(]
   )

LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    cin>>x;
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    while(x!=-1){      //输入 -1 结束
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin>>x;
    }
    return L;
}

4. 尾插法建立单链表; 时间复杂度O(n)

LinkList Link_LastInsert(LinkList &L){
    int x;
    L = (LinkList)malloc(sizeof(LNode));
    LNode *s,*r = L;
    cin>>x;
    while(x!=-1){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin>>x;
    }
    r->next = NULL;  //尾指针置空
    return L;
}

5. 按序号查找节点值; 时间复杂度O(n)

LNode *GetElem(LinkList L,int k){
    int i = 0;
    if(k == 0) return L;
    if(k < 1) return NULL;
    LNode *s = L->next;
    while(i<k && s){
        i++;
        s = s->next;
    }
    return s;
}

6. 按值查找; 时间复杂度O(n)

LNode *LocateELem(LinkList L,int value){
    LNode *p = L->next;
        while(p->data != value&&p){
            p = p->next;
        }
    return p;
}

7. 插入节点: 值为x的节点插入到第i的位置，即第i-1个节点

p = GetElem(L,i-1);    //查找插入位置的前驱节点
s->next = p->next;
p->next = s;

8. 删除节点: 将第i个节点删除

p = GetElem(L,i-1);
q = p->next;
p->next = q->next;
free(q);

Part4-双链表

1. 为了克服单链表访问前驱节点的麻烦，引入双链表，双链表中有两个指针prior和next，分别指向前驱和后继
   ![avator]
   )

typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DlinkList;

2. 插入

s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-olcxjeXx-1601395309024)(]
)
3. 删除

p->next = q->next;
q->next->prior = p;
free(q);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zOin99Dy-1601395334108)(]
)

Part5-循环链表

循环单链表

1. 循环单链表与单链表的区别: 表中最后一个节点的指针不是NULL，而改为指向头结点，从而链表形成一个环; 由于表尾节点*r的next域指向L，故表中没有指针域为NULL的域
   

循环双链表

1. 循环双链表中头结点的prior指针还要指向表尾节点