数据结构笔记-绪论、线性表

第一章  绪论

• 理解基本概念和术语 

数据：数据是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并被计算机程序所处理的符号的总称，数字，字符，图形，声音等

数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理，也称之为元素，结点，顶点记录。（补充：一个数据元素可由若干个数据项组成。数据项是数据的不可分割的最小单位。）

数据对象：数据对象是具有相同特性的数据元素的结合，是一个数据的子集

数据结构：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

　　（1）数据的逻辑结构：数据的逻辑结构是指数据元素之间存在的固有逻辑关系，常称为数据结构。数据的逻辑结构是从数据元素之间存在的逻辑关系上描述数据与数据的存储无关，是独立于计算机的：

1. 集合：数据中的数据元素之间除了“同属于一个集合“的关系以外，没有其他关系。
2. 线性结构：结构中的数据元素之间存在“一对一“的关系。
3. 树形结构：结构中的数据元素之间存在“一对多“的关系。
4. 图状结构（网状结构）：结构中的数据元素存在“多对多”的关系。

　　（2）数据的存储结构（物理结构）：数据元素及其关系在计算机内的表示称为数据的存储结构。想要计算机处理数据，就必须把数据的逻辑结构映射为数据的存储结构：

1. 顺序存储结构：把逻辑上相邻的数据元素存储在物理位置也相邻的存储单元中，借助元素在存储器中的相对位置来表示数据之间的逻辑关系。
2. 链式存储结构：借助指针表达数据元素之间的逻辑关系。不要求逻辑上相邻的数据元素物理位置上也相邻。
3. （补充）索引存储方式 （关键字，地址）
4. （补充）哈希存储方式 关键字通过函数计算

数据类型：一个值的集合和定义在这个值集上的一组操作的总称。（eg.C语言的整型变量）

抽象数据类型（ADT）：是指一个数学模型和定义在此数学模型上的一组操作。（eg.整数）仅取决于逻辑特性，与计算机内部如何实现无关，不论内部结构如何变化，只要数学特性不变，都不影响外部使用

算法：是对特定问题求解步骤的描述，是指令的有限序列。

算法的5个特性：

1.  输入：有零个或多个输入
2.  输出：有一个或多个输出
3.  有穷性：要求序列中的指令是有限的；每条指令的执行包含有限的工作量；整个指令序列的执行在有限的时间内结束。（程序与算法的区别在于，程序不需要有有穷性）
4.  确定性：算法中的每一个步骤都必须是确定的，算法只有唯一的一条执行路径。
5.  可行性：算法中的每一个步骤都应当能被有效的执行，并得到确定的结果。

算法设计的要求：

1. 正确性、
2. 健壮性（能处理合法数据，也能对不合法的数据作出反应，不会产生莫名其妙的输出结果）
3. 可读性（要求算法易于理解，便于分析）
4. 效率与低存储量需求

时间复杂度分析：  1.常量阶：算法的时间复杂度与问题规模n无关系T(n)=O(1)

                  2.线性阶：算法的时间复杂度与问题规模n成线性关系T(n)=O(n)

                  3.平方阶和立方阶：一般为循环的嵌套，循环体最后条件为i++

时间复杂度的大小比较：

O(1)<O(log₂n)<O(n)<O(nlog₂n)<O(n²)< O(n³)<O(2ⁿ)<O(n!)<O(n^k)

常数阶 < 对数阶 < 线性阶 < 线性对数阶 < 平方阶 < 立方阶 < 指数阶 < n的阶乘 < k次方阶

空间复杂度：程序运行所占存储量也是问题规模的函数，我们以空间复杂度衡量：S(n)=O(f(n))

第二章  线性表（线性表是n个数据元素的有限序列。）

• 顺序表的表示和实现

顺序表：线性表的顺序表示是指用一组地址连续的存储单元，依次存储线性表中的数据元素。只要确定了存储线性表的起始位置（基地址），线性表中任一数据元素都可随机存取。

优点：可以直接实现元素的定位，即可以随机存取其中的任意元素

缺点：插入与删除运算的效率很低，在插入操作和删除操作时需移动大量数据。顺序存储结构的线性表的存储空间需要扩充。

/**
 * SqList.cpp
 * 顺序表的基本使用
 * XiaMii 2020.2.10
*/
#include <stdio.h>
#include <stdlib.h>

#define LIST_INIT_SIZE 5  //存储空间的初始分配量
#define LISTINCREMENT 10    //存储空间的分配增量

typedef int elemtype;   //元素类型
typedef struct
{
    elemtype *elem;     //存储空间基址
    int length;     //当前长度
    int size;       //当前分配的存储容量
}SqList;

/**
 * 构造一个新的顺序表
 **/
int InitList_Sq(SqList &L){
    L.elem = (elemtype *)malloc(LIST_INIT_SIZE * sizeof(elemtype));//分配存储空间
    if(!L.elem){return -1;}     //存储分配失败
    L.length = 0;       //长度为0
    L.size = LIST_INIT_SIZE;        //初始存储容量
    return 0;
}
/**
 * 插入顺序表
 **/
int InsertList(SqList &L,elemtype e,int i){
    if (i<1 || i>L.length + 1){return (-1);}//插入位置不合法
    if (L.length >= L.size){//存储空间已满
        elemtype *newbase;//新基址
        newbase = (elemtype *)realloc(L.elem,(L.size + LISTINCREMENT)*sizeof(elemtype));//重新分配存储空间
        if(!newbase){return -1;}//存储分配失败
        L.elem = newbase;
        L.size += LISTINCREMENT;
    }
    elemtype *q,*p;//p为表尾位置
    q = &(L.elem[i-1]);//插入位置
    for (p = &(L.elem[L.length -1]); p>=q; p--){
        *(p+1) = *p;//插入位置及之后的元素后移
    }
    *q = e;//插入e
    ++L.length;//表长加一
    return 0;
}
/**
 *  删除顺序表
 **/
int DeleteList(SqList &L,int i,elemtype &e){
    if(L.length == 0){return -1;}//为空表
    if(i<1 || i>L.length){return -1;}//删除位置不合法
    elemtype *q,*p;
    q = &(L.elem[i-1]);//删除位置
    p = &L.elem[L.length-1];//表尾位置
    e = *q;
    for (++q; p >= q; q++)//被删除元素之后的元素前移
    {
        *(q-1) = *q;
    }
    L.length--;//表长减一
    return 0;
}
/**
 *  按序号查找元素
 **/
int GetElem(SqList &L,int i,elemtype &e){
    if(i<1 || i>L.length){return -1;}
    e = L.elem[i-1];
    return 0;
}
/**
 *  按内容查找元素，返回值为序号
 **/
int GetElem(SqList &L,elemtype e){
    for (int i = 0; i < L.length; i++)
    {
        if(L.elem[i]==e){return (i+1);}
    }
    return -1;
}
/**
 *  主函数
 **/
int main(){
    SqList L;
    elemtype temp,temp2;
    elemtype *tempdata;
    if(-1==InitList_Sq(L)){
        printf("InitList_Sq error!
");
    }
    printf("please input 10 number:
");
    for (int i = 0; i < 10; i++)
    {
        scanf("%d",&temp);
        InsertList(L,temp,i+1);
    }
    DeleteList(L,3,temp2);
    printf("%d

",temp2);
     for (int j = 1; j < L.length+1; j++)
    {
        GetElem(L,j,temp2);
        printf("%d
",temp2);
    }
    system("pause");
    return 0;
}

• 单链表的表示和实现

（1）      链表结点结构

用一组地址任意的存储单元存储线性表中的数据元素，用指针表示逻辑关系逻辑相邻的两元素的存储空间可以是不连续的。

以元素(数据元素的映象) + 指针(指示后继元素存储位置) =  结点 (表示数据元素  或  数据元素的存储映象)

以线性表中第一个数据元素的存储地址作为线性表的地址，称作线性表的头指针，有时为了操作方便，在第一个结点之前虚加一个“头结点”，以指向头结点的指针为链表的头指针。

优点：是一种动态结构，整个存储空间为多个链表共用。不需预先分配空间

缺点：指针占用额外存储空间。不能随机存取，查找速度慢

               

/**
 * LinkList.cpp
 * 单链表的基本使用和应用
 * XiaMii 2020.2.10
*/
#include <stdio.h>
#include <stdlib.h>

typedef int Datatype;
typedef struct LNode
{
    Datatype Data;
    LNode * Next;
}*LinkList;
//LNode为链表的结点类型
//LinkList为指向结点的指针类型（LinkList L;表示L指向头结点(==LNode * L;)）

/**
 * 建立头结点
*/
void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));
    if(L==NULL){return;}
    L->Next = NULL;
}
/**
 * 通过序号查找
*/
int GetElem(LinkList L,int i,Datatype &e){
    LNode* temp = L->Next;
    int j = 1;
    while (temp && j<i)
    {
        temp = temp->Next;
        j ++;
    }
    if (j>i||!temp){return -1;}
    e = temp->Data;
    return 0;
}
/**
 * 通过内容查找
*/
LNode* GetElem(LinkList L,Datatype e){
    LNode * temp = L->Next;
    while (temp)
    {
        if (e != temp->Data)
        {
            temp = temp->Next;
        }
        else
        {
            return temp;
        }
    }
    return 0;
}
/**
 * 通过内容定位
*/
int GetLocate(LinkList L,Datatype e){
    LNode * temp = L->Next;
    int i = 1;
    while (temp)
    {
        if (e != temp->Data)
        {
            temp = temp->Next;
            i++;
        }
        else
        {
            return i;
        }
    }
    return 0;
}
/**
 * 在单链表L第i个位置之前插入新元素e
*/
int InsertList(LinkList &L,int i,Datatype e){
    LNode * temp = L;//指向头结点
    int j = 0;//计数
    while (temp && j<i-1)//向后移到第i-1个结点
    {
        temp = temp->Next;
        j++;
    }
    if (!temp||j>i-1){return -1;}
    LNode * NewLNode = (LNode *)malloc(sizeof(LNode));//生成新结点
    NewLNode->Data = e;
    NewLNode->Next = temp->Next;//插入
    temp->Next = NewLNode;
    return 0;
}
/**
 * 在带头结点的单链表L中删除第i个元素，通过e返回其值
*/
int DeleteList(LinkList &L,int i,Datatype &e){
    LNode * temp = L;//指向头结点
    int j = 0;//计数
    while (temp && j<i-1)//向后移到第i-1个结点
    {
        temp = temp->Next;
        j++;
    }
    if (!temp->Next || j>i-1){return -1;}
    LNode * deleteNode = temp->Next;
    e = deleteNode->Data;
    temp->Next = deleteNode->Next;
    deleteNode = NULL;
    return 0;
}
/**
 * 逆序输入n个元素的值，建立带头结点的单链表L
*/
void CreateList(LinkList &L,int n){
    L = (LinkList)malloc(sizeof(LNode));
    L->Next = NULL;
    LinkList p;
    for (int i = n; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->Data);
        p->Next = L->Next;
        L->Next = p;//插入到表头
    }
}
/**
 * 顺序输入n个元素的值（尾插法），建立带头结点的单链表L
*/
void CreateList_index(LinkList &L,int n){
    L = (LinkList)malloc(sizeof(LNode));
    L->Next = NULL;
    LinkList p,q;
    q = L;
    for (int i = 0; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->Data);
        q->Next = p;
        q = p;//q一直向后移
    }
    q->Next = NULL;
}
/**
 * 求表长
*/
int ListLength(LinkList L){
    int i = 0;
    while (L->Next)
    {
        L = L->Next;
        i++;
    }
    return i;
}
/**
 * 销毁链表
*/
int DestroyList(LinkList &L){
    LinkList p = L;
    LinkList q;
    while (p)
    {
        q = p;
        p = p->Next;
        q = NULL;
    }
    return 0;
}
/**
 * 如果在表A中出现的元素在表B也出现，则将表A中元素删除
*/
int DelElem(LinkList A,LinkList B){
    int i = 0;
    Datatype e;
    LinkList p = B->Next;
    while (p)
    {
        i = GetLocate(A,p->Data);
        if(i==0){
            p = p->Next;
        }
        else
        {
            DeleteList(A,i,e);
            if (e != p->Data)
            {
                return -1;
            }
        }
    }
    return 0;
}

int main(){
    LinkList A,B;
    printf("input 10 numbers for List A:
");
    CreateList_index(A,10);
    printf("input 5 number for List B:
");
    CreateList_index(B,5);
    DelElem(A,B);
    printf("A-B=
");
    int n = ListLength(A);
    for (int i = 0; i < n; i++)
    {
        A = A->Next;
        printf("    %d
",A->Data);
    }
    DestroyList(A);
    DestroyList(B);
    system("pause");
    return 0;
}

• 循环双向链表的表示和实现

循环链表解决了一个很麻烦的问题：如何从中一个结点出发，访问到链表的全部结点，单向循环链表和单链表的差别仅在于，判别链表中最后一个结点的条件不再是“后继是否为空”，而是“后继是否为头结点”。

为了克服单向性这一缺点，设计出了双向链表。双向链表是在单链表的每个结点中，再设一个指向其前驱结点的指针，所以在双向链表中的结点都有两个指针域，一个指向直接后继，另一个指向直接前驱。

双向链表是单链表中扩展出来的结构，所以它的很多操作是和单链表是相同的，比如求长度、查找元素、查找元素位置等，这些操作都只要渺及一个方向的指针即可，另一指针多了也不能提供什么帮助。但是双向链表在插入和删除时，需要更改两个指针变量。

插入操作的步骤顺序是先搞定s的前驱和后继，再搞定后结点的前驱，最后解决前结点的后继。

 
         

/**
 * xLinkList.cpp
 * 双向循环链表、静态链表的基本使用和应用
 * XiaMii 2020.2.16
*/
#include <stdio.h>
#include <stdlib.h>

typedef int Datatype;

//双向循环链表
typedef struct DCLNode
{
    Datatype Data; // 数据域
    DCLNode * Next; // 指向后继的指针域
    DCLNode * Prior;// 指向前驱的指针域
}*DCLinkList;
/**
 * 建立头结点
*/
void InitList(DCLinkList &L){
    L = (DCLNode *)malloc(sizeof(DCLNode));
    if(L==NULL){return;}
    L->Next = L; //最后一个结点指向头结点
    L->Prior = L;
}
/**
 * 判断是否为空表
*/
bool IsEmpty(DCLinkList &L){
    if(L->Next==L){
        printf("DCLinkList为空表
");
        return true;
    }
    return false;
}
/**
 * 求表长
*/
int ListLength(DCLinkList L){
    DCLNode * temp = L;
    int i = 0;
    while (temp->Next != L)
    {
        temp = temp->Next;
        i++;
    }
    return i;
}
/**
 * 在双向循环链表L第i个位置之前插入新元素e
*/
int InsertDCList(DCLinkList &L,int i,Datatype e){
    DCLNode *p,*s;
    int j = 1;  //计数
    p = L->Next;    //指向第一个结点
    while (p != L){
        if (j<i){
            p = p->Next;    //p为第i个结点
            j++;
        }
        else{
            break;
        }
    }
    if (j>i){return -1;}//插入位置不合理
    s = (DCLNode *)malloc(sizeof(DCLNode));//s为待插入的结点
    if(!s){return -1;}
    s->Data = e;
    s->Prior = p->Prior;//先解决s的前后继
    s->Next = p;
    p->Prior->Next = s;//再解决p的前结点
    p->Prior = s;//最后解决p的前驱
    return 0;
}
/**
 * 在带头结点的单链表L中删除第i个元素，通过e返回其值
*/
int DeleteDCList(DCLinkList &L,int i,Datatype &e){
    DCLNode *p = L->Next;
    int j=1;
    while (p != L && j<i)
    {
        p = p->Next;//p为准备删除的结点
        j++;
    }
    if (j!=i){return -1;}//删除位置不合理
    p->Next->Prior = p->Prior;//修改后继结点的Prior
    p->Prior->Next = p->Next;//修改前驱结点的Next，使得p指向的结点从链表断开
    e = p->Data;
    p = NULL;
    return 0;
}
/**
 * 主函数
*/
int main(){
    DCLinkList A;
    InitList(A);
    int a[10]={1,2,3,4,5,6,7,8,9,0};
    for (int i = 0; i < 10; i++)
    {
        InsertDCList(A,i+1,a[i]);
    }
    Datatype e;
    DeleteDCList(A,3,e);
    int n = ListLength(A);
    for (int i = 0; i < n; i++)
    {
        A = A->Next;
        printf("    %d
",A->Data);
    }
    system("pause");
    return 0;
}

• 静态链表的表示和实现

/**
 * xLinkList.cpp
 * 双向循环链表、静态链表的基本使用和应用
 * XiaMii 2020.2.16
*/
#include <stdio.h>
#include <stdlib.h>

typedef int Datatype;

/************************************************
 * 静态链表
 ***********************************************/
#define ListSize 1000
//结点类型
typedef struct SLNode
{
    Datatype data;  //数据域
    int cur;    //指针域，指示后继结点在数组的位置
};
//静态链表类型
typedef struct SLinkList
{
    SLNode List[ListSize];
    int av; //av指向静态链表中一个未使用的位置，是备用链表的指针
};
/**
 * 初始化静态链表
*/
int InitSList(SLinkList &L){
    int i;
    for (i = 0; i < ListSize; i++)
    {
        L.List[i].cur = i+1;//将静态链表的游标指向下一个结点
    }
    L.List[ListSize-1].cur = 0;//将链表最后一个结点的游标置为0
    L.av = 1;
}
/**
 * 分配结点
*/
int AssignNode(SLinkList &L){
    int i;
    i = L.av;//从备用链表中取下一个结点空间
    L.av = L.List[i].cur;//分配给要插入链表中的元素
    return i;//返回要插入结点的位置
}
/**
 * 回收结点
*/
void FreeNode(SLinkList &L,int pos){
    L.List[pos].cur = L.av;//将空闲的结点回收
    L.av = pos;//备用链表指向回收的位置
}
/**
 * 在静态链表L第i个位置之前插入新元素e
*/
int InsertSList(SLinkList &L,int i,Datatype e){
    int k,j;//k为新结点位置，j为用于移动到对应位置的结点位置
    k = L.av;//为新结点分配一个空间
    L.av = L.List[k].cur;//修改备用指针
    L.List[k].data = e;//赋值
    j = L.List[0].cur;
    for (int x = 1; x < i-1; x++)
    {
        j = L.List[j].cur;//j为第i-1个结点
    }
    L.List[k].cur = L.List[j].cur;
    L.List[j].cur = k;
    return 0;
}
/**
 * 在静态链表L中删除第i个元素，通过e返回其值
*/
int DeleteSList(SLinkList &L,int i,Datatype &e){
    int j,k;//k为准备删除的结点位置，j为用于移动到对应位置的结点位置
    j = L.List[0].cur;
    for (int x = 1; x < i-1; x++)
    {
        j = L.List[j].cur;//j为第i-1个结点位置
    }
    k = L.List[j].cur;//k为准备删除的结点位置（即i）
    L.List[j].cur = L.List[k].cur;//将i-1与i+1连起来
    L.List[k].cur = L.av;//把i结点与当前的备用链表连起来
    e = L.List[k].data;//e返回删除的值
    L.av = k;//k变成最新的备用链表
    return 0;
}
/**
 * 主函数
*/
int main(){
    SLinkList A;
    InitSList(A);
    Datatype b[10]={11,22,33,44,55,66,77,88,99,99},e;
    int j = 0;
    for (int i = 0; i < 10; i++)
    {
        InsertSList(A,i+1,b[i]);
    }
    DeleteSList(A,3,e);
    printf(" %d
",e);
    for (int i = 0; i < 15; i++)
    {
        j = A.List[j].cur;
        printf("%d
",A.List[j].data);
    }
    system("pause");
    return 0;
}

• 单链表与顺序表的比较

　　对于一个具有n个节点的单链表 ,在已知所指结点后插入一个新结点的时间复杂度是(O（1）)；在给定值为x的结点后插入一个新结点的时间复杂度是（O(n)）。

　　在长度为N的顺序表中，插入一个新元素平均需要移动表中(N/2)个元素，删除一个元素平均需要移动(（N-1）/2)个元素。

　　若线性表的主要操作是在最后一个元素之后插入一个元素或删除最后一个元素，则采用顺序表存储结构最节省运算时间。

　　线性表可用顺序表或链表存储。试问：两种存储表示各有哪些主要优缺点?

　　顺序表的存储效率高，存取速度快。但它的空间大小一经定义，在程序整个运行期间不会发生改变，因此，不易扩充。同时，由于在插入或删除时，为保持原有次序，平均需要移动一半(或近一半)元素，修改效率不高。

　　链接存储表示的存储空间一般在程序的运行过程中动态分配和释放，且只要存储器中还有空间，就不会产生存储溢出的问题。同时在插入和删除时不需要保持数据元素原来的物理顺序，只需要保持原来的逻辑顺序，因此不必移动数据，只需修改它们的链接指针，修改效率较高。但存取表中的数据元素时，只能循链顺序访问，因此存取效率不高。

　　若表的总数基本稳定，且很少进行插入和删除，但要求以最快的速度存取表中的元素，这时，应采用哪种存储表示？为什么？

　　应采用顺序存储表示。因为顺序存储表示的存取速度快，但修改效率低。若表的总数基本稳定，且很少进行插入和删除，但要求以最快的速度存取表中的元素，这时采用顺序存储表示较好。

参考：《数据结构》主编 陈锐 于聚然 合肥工业大学出版社