数据结构基础（数组、线性表、栈和队列）

基础知识

数据结构基本概念

1)数据

  数据元素：数据基本单位，可由若干数据项组成；

  数据对象：性质相同的数据元素的集合；

  数据类型：包括原子类型，结构类型，抽象数据类型；

  抽象数据类型(ADT)：通常用(数据对象，数据关系，基本操作集)这样的三元组表示；

  数据结构：包括逻辑结构、存储结构、数据的运算；

2)数据的逻辑结构(独立于计算机的，与存储结构无关)

  包括：线性结构(线性表，栈，队列)，非线性结构(树，图，集合)；

3)数据的存储结构(物理结构，不独立于计算机)

  顺序存储：逻辑上相邻的元素存储在物理位置上也相邻的存储单元里；

  链式存储：用指示元素存储地址的指针表示元素之间的逻辑关系；

  索引存储：建立附加索引表，索引项一般为(关键字，地址)；

  散列存储：即hash存储，由关键字直接计算出地址；

4)数据的运算：包括运算的定义与实现；

算法和算法评价

1)算法：对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表示一个或多个操作；

2)五个特性：有穷性，确定性，可行性，输入，输出；

3)时间复杂度：设算法中所有语句的频度之和为T(n)，算法中最深层循环内语句的频度为f(n)，则T(n)=O(f(n));

  频度：语句在算法中被重复执行的次数；T(n)是问题规模n的函数；

  最好的时间复杂度，平均时间复杂度，最坏时间复杂度； => 一般考虑的是最坏时间复杂度；

  O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)

4)空间复杂度：算法所耗费的存储空间，一般为除输入和程序之外的辅助空间；若算法原地工作，则辅助空间为常量O(1);

5)有序表：关键字有序的线性表，属于逻辑结构；

6)附加说明：

  将两个长度分别为m和n的升序链表，合并为一个长度为m+n的降序链表，最坏情况下的时间复杂度为O(max{m,n})，因为比较次数为2*max{m,n}-1(插空时)；

  相同规模n下，复杂度为O(n)的算法在时间上总是优于复杂度为O(2^n)的算法；

  所谓时间复杂度，是指最坏情况下，估算算法执行时间的一个上界；

  同一个算法，实现语言的级别越高，执行效率就越低；

线性表

线性表是一种逻辑结构，顺序表和链表是存储结构

线性表的定义和基本操作

1)线性表：具有相同数据类型的n个数据元素的有限序列；L=(a1,a2,...,ai,ai+1,...,an);

  除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继；

  特征：有限个数据元素；逻辑结构；元素有先后次序(前驱后继关系)；数据类型相同；

2)基本操作：

  InitList(&L)：初始化

  Length(&L)：求表长

  LocateElem(L,e)：按值查找

  GetElem(L,e)：按位查找

  ListInsert(&L,i,e)：插入

  ListDelete(&L,i,&e)：删除，用e返回删除元素的值

  PrintList(L)：输出

  Empty(L)：判空

  DestroyList(&L)：销毁

线性表的顺序表示

顺序表的定义

1)顺序表：线性表的顺序存储，特点是表中元素的逻辑顺序与其物理顺序相同

2)线性表的顺序存储类型描述

1.静态分配(数据大小、空间固定)

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

2.动态分配(动态分配依然是顺序存储结构，随机存取方式，只是分配的空间大小可以在运行时决定)

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

C语言动态分配初始语句 ：L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);

C++动态分配初始语句 ：L.data=New ElemType(InitSize);

3)顺序表的特点：

  随机存取，随机访问，即首地址+元素序号可以在O(1)时间内找到指定元素；

  存储密度高，每个结点只存储数据元素；

  逻辑上相邻，物理上也相邻，插入和删除需移动大量元素；

顺序表上基本操作的实现(插入，删除，查找)

1)插入操作 

//将元素e插入到顺序表的第i个位置
bool ListInsert(SqList &L,int i, ElemType e) {
    if(i<1 || i>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;
}  

最好的情况：在表尾插入(i=n+1)，则后移语句不执行，时间复杂度为O(1);

最坏的情况：在表头插入(i=1)，则元素后移执行n次，时间复杂度为O(n);

平均情况：在第i个位置插入，元素后移执行n/2次，平均时间复杂度为O(n);

2)删除操作

//删除顺序表中第i个位置的元素
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；
}

最好情况：删除表尾元素(i=n)，无需前移元素，时间复杂度为O(1)；

最坏情况：删除表头元素(i=1)，前移元素n-1次，时间复杂度为O(n);

平均情况：删除第i个位置的元素，前移(n-1)/2次，平均时间复杂度为O(n);

3)按值查找(顺序查找)

//查找顺序表中值为e的元素，若查找成功，则返回位序，否则返回0；
int LocateElem(SqList L, ElemType e){
    for(int i=0;i<L.length;i++){
        if(L.data[i]==e){
           return i+1； 
    }
    return 0;
}

最好情况：查找元素在表头，仅需比较一次，时间复杂度为O(1)；

最坏情况：查找元素在表尾(或不存在)时，需比较n次，时间复杂度为O(n);

平均情况：查找元素在第i个位置，需比较(n+1)/2次，平均时间复杂度为O(n);

 线性表的链式表示

不需使用地址连续的存储单元，即不要求逻辑上相邻的两个元素在物理位置上也相邻，通过“链”建立起数据元素之间的逻辑关系；

单链表

1)定义：线性表的链式存储；每个链表节点，除了存放元素自身的信息外，还需要存放一个指向其后继的指针；

   单链表中结点类型描述：

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

  优点：解决顺序表需要大量连续存储空间的缺点；

  缺点：由于附加指针域，所以也浪费空间；

  特点：非随机存储结构，查找特定结点时，需要从表头开始遍历，依次查找；

2)通常用"头指针"标识一个单链表L，头指针为"NULL"时表示一个空表；

  头结点：为操作方便，单链表第一个结点之前附加一个结点，称为头结点，头结点的指针域指向第一个结点，数据域可以不设信息，也可记录表长等相关信息；

  头结点&头指针：

  1.不论是否有头结点，头指针始终指向链表的第一个结点；

  2.头结点是带头结点链表的第一个结点，结点内通常不存储任何信息；

  头结点的优点：

  1.链表的第一个位置操作与其他位置一致；

  2.头指针是指向头结点(或链表第一个结点)的非空指针(空表中头结点的指针域为空)，所以空表非空表处理一致；

单链表基本操作的实现

1)采用头插法建立单链表

//从空表开始生成新结点
//将新结点插入到当前链表的表头，即头结点之后
LinkList CreateList1(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为头指针
        L->next = s;
        scanf("%d",&x);
    }
    return L;
} 

特点： 读入数据的顺序与生成链表中元素顺序相反；设单链表长为n，则时间复杂度为O(n).

2)采用尾插法建立单链表

  将新结点插入到当前链表的表尾上，需要增加一个尾指针r，使其始终指向当前链表的尾结点.(即最后一个结点为r，会更新)

LinkList CreateList2(LinkList &L){
    int x; //元素类型为整型
    L=(LinkList)malloc(sizeof(LNode)); //创建头结点
    LNode *s,*r=L;
    scanf("%d",&x);  //输入结点值
    while(x != 9999)  {  //输入9999表示结束
        s=(LNode*)malloc(sizeof(LNode));  //创建新结点
        s->data = x;
        r->next = s;  //将新结点插入表中，r为表尾指针
        r = s->next;  //r指向新的表尾结点
        scanf("%d",&x);
    }
    r->next = NULL;  //尾结点指针置空
    return L；
｝

时间复杂度为O(n),单链表长为n的情况下 

3)按序号查找结点值

//取出单链表L(带头结点)中第i个位置的结点指针(元素从第一个位置开始)
LNode *GetElem(LinkList L,int i){
    int j=1; //计数，初始为1
    LNode *p=L->next;  //将头结点指针赋给p
    if(i==0){
        return L;   //返回头结点
    }
    if(i<0){
        return NULL;  //无效，返回NULL
    }
    while(p && j<i){  //从第1个结点开始查找第i个结点
        p = p->next;
        j++;
    }
    return p;   //返回第i个结点的指针
}

4)按值查找表结点

//查找单链表L(带头结点)中数据域值等于e的结点指针，否则返回NULL
LNode *LocateElem(LinkList L, ElemType e){
    LNode *p=L->next;  //将头结点的指针赋给p
    while(p!=NULL && p->data != e){  //从第1个结点开始查找data域为e的结点
        p = p->next;
    }
    return p;  //指到后返回该结点指针，否则返回NULL
}

5)插入结点操作

//将值为x的新结点插入到单链表的第i个位置上
p = GetElem(L,i-1);  //查找前驱结点
s->next = p->next;
p->next = s;

时间复杂度为O(n)(主要是GetElem(L,i-1)所花费的)，若在固定结点后插入，时间复杂度为O(1).

//将*s插入到*p之前
s->next = p->next; //s插入到p之后
p->next = s;
temp=p->data;  //*s,*p交换数据域
p->data = s->data;
s->data = temp;    //时间复杂度为O(1)

6)删除结点操作

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

时间复杂度为O(n)(主要用于GetElem(L,i-1));

//仅知p的后继结点，删除*p
q=p->next;  //删除后继
p->next = q->next; //将后继数据域赋给p
free(q);

7)求表长操作

计算单链表中数据结点(不含头结点)的个数，时间复杂度为O(n)(设置计数器变量)，单链表的长度是不包括头结点的；

双链表

1)单链表：只能从前往后顺序遍历，访问前驱的时间复杂度为O(n),访问后继为O(1);

2)双链表：有两个指针prior和next，分别指向其前驱结点和后继结点;

3)双链表中结点类型描述

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

4)双链表的插入操作

//在*p所指结点之后插入结点*s，时间复杂度为O(1)
s->next = p->next;
p->next->prior = s;
p->next = s; //前两行代码必须在该代码之前
s->prior = p;

5)双链表的删除操作

//删除双链表中结点*p的后继结点*q，时间复杂度为O(1)
p->next = q->next;
q->next->prior = p;
free(q);  //释放结点空间

循环链表 

1)循环单链表：与单链表的区别在于，最后一个结点的指针不是NULL，而是指向头结点；

  表尾结点*r的next域指向L，表中没有指针域为NULL的结点；

  判空条件：头结点的指针是否等于头指针；

  因为循环单链表是一个环，所以在任何位置上的插入和删除操作都等价，无需判断表尾；

  单链表：只能从表头结点开始往后顺序遍历整个链表；循环单链表：可以从表中任一结点开始遍历整个链表；

  仅设立尾指针的循环单链表，设r是尾指针，r->next即为头指针，对表头表尾操作都只需O(1)的时间复杂度；

3)循环双链表

  表尾结点的next指向头结点，头结点的prior指向表尾结点；

  循环双链表L中，当结点*p为尾结点时，p->next=L；当为空表时，L->prior=L, L->next=L;

静态链表

1)借助数组来描述线性表的链式存储结构，结点也有数据域data和指针域next。此处指针为结点的相对地址(数组下标)，静态链表也要预先分配一块连续的存储空间；

 2)静态链表结构类型描述

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

  静态链表以next=-1作为其结束的标志(设单链表使用方便)

顺序表和链表的比较

1)如何选取存储结构

  存储考虑：当线性表长度或存储规模难以估计 =>链表；

  运算考虑：按序号访问 =>顺序表；插入、删除=>链表；

  环境考虑：顺序表基于数组，链表基于指针；

栈和队列

 栈

基本概念

1)栈：只允许在一端进行插入或删除操作的线性表；

2)栈顶：线性表允许进行插入和删除的那一端；

3)栈底：固定的，不允许进行插入和删除的那一端；

4)空栈：不含任何元素的空表；

5)栈特点：后进先出；

6)基本操作：

  InitStack(&S)：初始化一个空栈S；

  StackEmpty(S)：判断栈是否为空，空返回true，不空返回false；

  Push(&S,x)：进栈；

  Pop(&S,x)：出栈

  GetTop(S,&x)：读栈顶元素

  ClearStack(&S)：销毁栈，并释放栈S占用的存储空间；

栈的顺序存储结构(顺序栈)

1)顺序栈：栈的顺序存储，利用一组地址连续的存储单元存放自栈底至栈顶的数据元素，同时附设一个指针top指示当前栈顶的位置；

2)栈的顺序存储类型描述：

#define MaxSize 50  //定义栈中元素的最大个数
typedef struct｛
    ElemType data[MaxSize]; //存放栈中元素
    int top；   //栈顶指针
｝SqStack；

初始栈顶指针S.top=-1; 栈顶元素S.data[S.top]；栈空：S.top=-1；栈满：S.top=MaxSize-1；栈长S.top+1；进栈+1，出栈-1；

3)顺序栈的基本运算

1.初始化

void InitStack(&S){
    S.top=-1;  //初始化栈顶指针
｝

2.判栈空

bool StackEmpty(S){
    if(S.top==-1){  //栈空
        return true;
    }
    else{    //不空
        return false;
}    

3.进栈

bool Push(SqStack &S,ElemType x){
    if(S.top=MaxSize-1){    //栈满，报错
        return false；
    }
    S.data[++S.top]=x;    //进栈，指针加1再进栈
    return true；
}

4.出栈

bool Pop(SqStack &S,ElemType &x){
    if(S.top==-1){    //栈空，报错
        return false;
    }
    x=S.data[S.top--];   //先出栈，指针再减1
    return true；
}

5.读栈顶元素

bool GetTop(SqStack S,ElemType &x){
    if(S.top==-1){   //栈空，报错
        return false;
    }
    x=S.data[S.top];  //x记录栈顶元素
    return true；
｝

注意初始条件，S.top=-1表示栈空，S.top=0表示指向第一个元素；

4)共享栈(能有效利用存储空间)

  将栈底设置在共享空间两端，固定不变；栈顶向共享空间的中间延伸；

栈的链式存储结构(链栈)

1)通常用单链表实现，规定所有操作在单链表表头进行，规定链栈没有头结点，Lhead指向栈顶元素；

2)栈的链式存储类型描述

typedef struct Linknode {
    ElemType data;  //数据域
    struct Linknode *next； //指针域
｝*LiStack；   //栈类型定义

队列 

队列基本概念

1)队列：简称队，只允许在表的一端进行插入，而在表的另一端进行删除的线性表，先进先出(FIFO);

2)队头：允许删除的一端，删除元素称为出队或离队；

3)队尾：允许插入的一段，插入元素称为入队或进队；

4)空队列：不含任何元素的空表；

5)基本操作：

  InitQueue(&Q)：初始化队列；

  QueueEmpty(&Q)：判队空；

  EnQueue(&Q,x)：入队；

  DeQueue(&Q,&x)：出队；

  GetHead(Q,&x)：读队头元素，将值赋给x；

队列的顺序存储结构

==>队列的顺序存储

1)队列的顺序存储：分配一块连续的存储单元存放队列中的元素，并设两个指针，front指向当前队头元素的位置，rear指向当前队尾元素的位置。

2)队列顺序存储类型描述：

#define MaxSize 50 //定义队列中元素的最大个数
typedef struct｛
    ElemType data[MaxSize];  //存放队列元素
    int front,rear;   //队头指针和队尾指针
｝SqQueue；

3)

初始状态 (队空)：Q.front = Q.rear = 0;

进队：先送值到队尾，再队尾指针+1；

出队：先取队头值，再队头指针+1；

==>循环队列

1)把存储队列元素的表从逻辑上看作一个环；

  初始：Q.front = Q.rear = 0;

  入队：队尾指针进1取模，Q.rear=(Q.rear+1)%MaxSize;

  出队：队首指针进1取模，Q.front=(Q.front+1)%MaxSize;

  队列长度：(Q.rear+MaxSize-Q.front)%MaxSize;

2)队空队满判定方法

  1.牺牲一个单元，入队时少用一个单元，front在rear下一个位置则队满；

    队空：Q.front == Q.rear;

    队满：Q.front == (Q.rear+1)%MaxSize;

    队列长度：(Q.rear+MaxSize-Q.front)%MaxSize;

  2.增设表示元素个数的数据成员

    队空：Q.size=0；

    队满：Q.size=MaxSize；

  3.增设数据成员tag

    队空：tag=0，删除导致Q.front=Q.rear;

    队满：tag=1，插入导致Q.front=Q.rear;

==>循环队列的操作(采用“牺牲一个单元”判定法则判队空队满)

1)初始化

void InitQueue(&Q){
    Q.front = Q.rear =0;   //初始化队首、队尾指针
}

2)判队空

bool IsEmpty(Q){
    if(Q.rear==Q.front){  //队空条件
        return true;
    }
    else{
        return false;
    }
}

3)入队

bool EnQueue(SqQueue &Q,ElemType x){
    if((Q.rear+1)%MaxSize == Q.front){  //队满
        return false；
    }
    Q.data[Q.rear]=x; //送值至队尾
    Q.rear = (Q.rear+1)%MaxSize; //队尾指针加1取模
    return true;
}

4)出队

bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.rear == Q.front){  //队空
        return false;
    }
    x=Q.data[Q.front];  //取队头元素值
    Q.front=(Q.front+1)%MaxSize;  //队头指针加1取模
    return true；
}

队列的链式存储结构

==>队列的链式存储

1)队列的链式表示称为链式队列，同时带有队头指针和队尾指针的单链表，头指针指向队头结点，尾指针指向队尾结点；

2)队列链式存储类型描述

typedef struct {  //链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct｛  //链式队列
    LinkNode *front,*rear; //链式队列队头和队尾指针
｝LinkQueue；

  队空：Q.front=NULL and Q.rear=NULL(若是带头结点的链式队列，只需Q.rear=Q.front即可)

  入队：新结点插入链表尾部，即Q.rear指向新结点

  出队：取队头元素，Q.front指向下一结点(若该结点为最后一个结点，则令Q.front，Q.rear均为NULL)

3)链式队列的优点：不存在存储分配不合理和溢出问题，适合数据元素变动较大的问题；

==>链式队列基本操作

1)初始化

void InitQueue(LinkQueue &Q){
    Q.front = Q.rear =(LinkNode *)malloc(sizeof(LinkNode)); // 建立头结点
    Q.front->next = NULL;  //初始为空
}

2)判队空

bool IsEmpty(LinkQueue Q){
    if(Q.rear==Q.front){
        return true;
    }
    else{
        return false;
    }
}

3)入队

void EnQueue(LinkQueue &Q,ElemType x){
    s=(LinkNode *)malloc(sizeof(LinkNode));  //创建新结点
    s->data=x;
    s->next = NULL;
    Q.rear->next = s;   //插入链表尾部
    Q.rear=s；
}

4)出队

bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==Q.rear){  //队空
        return false；
    }
    p=Q.front->next;
    x=p->data;
    Q.front->next = p->next;
    if(Q.rear ==p){  //若原队列只有一个结点，则删除后变空
        Q.rear = Q.front;
    }
    free(p);
    return true;
}

双端队列

1)允许两端都可以进行入队和出队操作的队列(元素逻辑结构仍是线性结构)

  进队：前端进的在后端进的前面

  出队：先出的元素排在后出元素的前面

2)输出受限的双端队列：允许在一端进行插入和删除，另一端只允许插入的双端队列；

3)输入受限的双端队列：允许在一端进行插入和删除，另一端只允许删除的双端队列；

 不能通过输入受限的双端队列得到的是4,2,3,1和4,2,1,3；

 不能通过输出受限的双端队列得到的是4,2,3,1和4,1,3,2；

栈和队列的应用

栈的应用

1)栈在括号匹配的应用：

  设空栈=>左括号进栈=>右括号，则消除栈中与之最近的左括号(匹配则继续，不匹配则退出)；

2)栈在表达式求值中的应用：后缀表达式求值

  操作数进栈=>操作符，从栈中取最上的操作数计算，并将结果压入栈中=>重复上述操作；

3)栈在递归中的应用

  递归=>非递归，需要借助栈；

队列的应用

1)队列在层次遍历中的应用

  根结点入队；队空则结束遍历重复第三步；队列第一个结点出队并访问，若有左孩子，则将左孩子入队，若有右孩子，则将右孩子入队，返回第二步；

2)队列在计算机系统中的应用

  打印机的数据缓冲区(主机和外设速度不匹配的问题)；

  CPU资源竞争(队首用户先使用)(多用户引起的资源竞争问题)；

特殊矩阵的压缩存储

数组

数组是线性表的推广，一维数组是一个线性表，二维数组可看作线性表的线性表；数组一旦定义，维数和维界不可改变，除初始化和销毁外，只能存取和修改元素；

数组的存储结构

一维数组： A[0,1,...,n-1]

二维数组：按行优先和按列优先

矩阵的压缩存储

压缩矩阵：多个值相同的元素只分配一个存储空间；

1)对称矩阵

 2)三角矩阵

 3)三对角矩阵

 4)稀疏矩阵

-----------------------------------

时间原因，此篇停更，掌握基本概念后，刷题才是硬道理！！！

参考资料：

《王道数据结构》