大话数据结构笔记3-1：线性表

线性表

零个或多个数据元素的有限序列

线性表的抽象数据类型定义

线性表的顺序存储结构

顺序存储结构，指的是用一段地址连续存储单元依次存储线性表的数据元素

/*************************************************************************
	> File Name: list-线性表.c
	> Author: 
	> Mail: 
	> Created Time: 一  4/20 15:44:22 2020
 ************************************************************************/
#include<stdio.h>
#define MAXSIZE 20 //存储空间初始分配量
typedef int EleType; //EleType 根据情况而定 此处 int
typedef struct{
    int length;
    EleType data[MAXSIZE];
}SqlList;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;

// 初始条件  顺序线性表L 已经存在 1<=i<=ListLength(L)获取一个元素
//操作结果   用e 返回L中第i个数据元素的值
Status GetEle(SqlList L, int i, EleType *e){
    if(L.length == 0 || i>L.length)
    return ERROR;
    *e = L.data[i-1];
    return OK;
}
int main(){
    printf("hello world");
}

插入操作

• 插入位置判断，不合理则抛出异常
• 如果线性表长度大于等于数组传唱度，则抛出异常或动态增加容量
• 从最后一个元素开始向前遍历到第i个位置，分别向后移动一个位置
• 将要插入的元素填入 位置 i
• 表长+1

实现代码

// 初始条件  顺序线性表L 已经存在 1<=i<=ListLength(L)获取一个元素
//操作结果   在L中第i个位置之前插入新的数据元素 e， L的长度+1
Status ListInsert(SqlList *L,int i,EleType e){
    int k;
    if(L->length >= MAXSIZE) //已经满了
        return ERROR;
    if(i<1 || i>L->length+1) //i不在范围内
        return ERROR;
    if(i<L->length){ //不是尾部插入
        for(k = L->length-1; k>=i-1;k--){
            L->data[k+1] = L->data[k];
        } 
    }
    L->data[i-1] = e;
    L->length++;
    return OK;
}

删除元素

• 判断位置是否合理，不合理抛出异常
• 取出删除元素
• 从删除元素开始遍历到最后一个元素，每个都前移一个位置
• 表长度-1
  实现代码，时间复杂度 O(n) ，如果是插入或删除尾部元素则 O(1)

// 初始条件  顺序线性表L 已经存在 1<=i<=ListLength(L)获取一个元素
//操作结果   删除L中第i个位置数据元素 e并返回， L的长度-1
Status  ListDel(SqlList *L, int i, EleType *e){
    int k;
    if(L->length == 0)
        return ERROR;
    if(i <1 || i> L->length)
        return ERROR;
    *e = L->data[i-1];
    //如果不是删除最后一个元素
    if(i<L->length){
        for(k = i; k<L->length;k++){
            L->data[k-1] = L->data[k];
        }
    } 

    L->length--;
    return e;
}

顺序存储结构的优缺点

优点

1. 无须为表示表中元素之间的逻辑关系而增加额外的存储空间
2. 可快速存取表中任一位置的元素

缺点

1. 插入和删除元素需要移动大量元素
2. 当线性表长度变化较大时，难以确定存储空间的容量
3. 造成存储空间的 “碎片”

线性表的链式存储结构

对于数据元素An 来说 ，除了存储本身的信息（数据域）外，还会存储一个指示其直接后继的位置信息（指针域）。
这两部分信息组成的数据元素ai的存储映像，称为结点（Node）
n 个结点链接成一个链表，即为线性表的链式存储结构，因为链表的每个结点中只包含一个指针域，所以叫做单链表。
头指针  链表的第一个结点的存储位置，最后一个结点因为没有后继元素，指针域为空

  头结点  有时候我们为了方便的对链表进行操作，会在单链表的第一个结点前附设一个结点，称为头结点。
  头结点的数据域可以不存储任何信息，也可以存储线性表长度，指针域存储指向第一个结点的指针。

单链表的读取

1. 声明一个结点p指向链表的第一个结点，初始化j从1开始
2. 当 j<1时，就遍历链表，让p的指针后移，不断指向下一个结点，j累加1
3. 当链表到末尾p为空 则说明 元素i不存在
4. 否则查找成功 返回p的数据

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int EleType; //EleType 根据情况而定 此处 int
//线性表的单链存储结构
typedef struct Node
{
   EleType data;
   struct Node *next;
} Node;
typedef struct Node  *LinkList;
// 初始条件  顺序线性表L 已经存在 1<=i<=ListLength(L)获取一个元素
//操作结果   用e 返回L中第i个数据元素的值
Status GetEle(LinkList L, int i,EleType *e){
    int j;
    LinkList p; //声明结点p
    p = L->next;  //p指向链表的第一个元素
    j = 1;
    while (p && j<i)
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i)   //不存在元素
        return ERROR;
    *e  = p->data; //取第i个元素的数据
    return OK;
}

单链表的插入

1. 声明一结点p指向链表的第一个结点，初始化j从1开始
2. 当j<1时，就遍历链表，让p的指针向后移动，不断指向向下一结点，j累加1；
3. 若碰到链表末尾p为空，则说明第一个元素不错存在；
4. 否则查找成功，在系统中生成一个空节点s；
5. 将数据元素e赋值给s->data
6. 单链表的插入标准语句 s->next = p->next p->next = s
7. 返回成功
   实现代码

//插入元素
Status ListInsert(LinkList *L, int i, EleType e){
    LinkList p,s;
    int j;
    p = *L;

    while(p && j<i){
        p = p->next;
        ++j;
    }
    //不存在
    if(!p || j>i)
        return ERROR;
    s = (LinkList) malloc(sizeof(Node));//生成新结点
    s->data  = e;
    s->next = p->next;
    p->next= s;

    return OK;
}

单链表删除第i个元素

Status ListDel(LinkList *L, int i, EleType *e){
    LinkList p,s;
    int j;
    p = *L;

    while(p && j<i){
        p = p->next;
        ++j;
    }
    //不存在
    if(!p || j>i)
        return ERROR;
    s = p->next;
    p->next = s->next;
    *e = s->data;
	free(s);
    return OK;
}

整表创建

• 生成一新节点赋值给p
• 随机生成一数字赋值给p的数据域 p->data
• 将p插入到头结点与前一新节点之间

1. 头插法代码

//头插法 创建
void creeateListHead(LinkList *L,int n){
    LinkList p;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;
    for(i =0;i<n;i++){
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100+1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

2. 尾插法代码

//尾插法 创建
void createListTail(LinkList *L,int n){
    LinkList p,r ;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;
    for(i =0;i<n;i++){
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
    }
    r->next = NULL;
}

单链表整表删除

1. 声明一个结点p,q
2. 将第一个结点赋值给p
3. 循环
   • 将下一结点赋值给q
   • 释放p
   • 将q赋值给p

Status ClearList(LinkList *L){
    LinkList p,q;
    p = (*L)->next;

    while(p){
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;

    return OK;
}

对比

顺序存储结构 ：查找操作大于插入、删除 ，即读操作多
单链结构 ： 1、插入删除操作多 2、线性表长度变化较大的时候可以不用考虑存储空间的问题