王道数据结构 线性表笔记

已于 2022-07-15 15:51:22 修改
阅读量196 收藏 2
点赞数 1
分类专栏： 算法笔记 文章标签： 数据结构 算法 c++
于 2022-07-15 15:50:55 首次发布
原文链接：https://github.com/oxyanyano/2022-WangDao-CS-DS-Notes
版权

线性表 （Linear List）

//@[TOC】目录太长 因此将目录省略 可以直接使用有侧目录观看

一、线性表的定义：

线性表是n个具有相同特性的数据元素的有限序列。

二、线性表的基本操作

注：参数代“&”表示：方法运行完后，对参数修改的结果要“带回来”

对数据的操作：创销，增删查改

InitList(&L);     //初始化表：构造一个空的线性表L，分配内存空间
DestoryList(&L);  //销毁操作：销毁线性表，并释放线性表L所占用的内存空间

ListInsert(&L,i,e);  //插入操作：在表L中第i个位置上查入指定元素e
ListDelete(&L,i,&e); //删除操作：删除表L中第i个位置的元素，/*并用e反回删除元素的值*/

LocateElem(L,e); //按值查找操作
GetElem(L,i);    //按位查找操作

//其它常用操作
Length(L);  //求表长
Print(L);   //输出操作
Empty(L);   //判空操作

三、存储结构

顺序存储和链式存储

四、线性表分类

线性表的顺序存储：顺序表

线性表的链式存储：单双链表、循环链表

静态链表比较特殊：逻辑上离散，物理上连续

顺序表—— Sequence List

一、顺序表的定义

顺序表：线性表的顺序存储，它是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。

二、顺序表的特点

①随机访问：可直接通过下标访问

②存储密度高：每个节点只能存数据元素

③拓展容量不方便：即便采用动态分配方式，迁移数据时时间复杂度也比较高

④插入、删除操作不方便：需要移动大量元素

三、顺序表的实现方式

实现方式：静态分配和动态分配

四、静态分配的顺序表上的操作

静态分配的顺序表的优缺点

缺点：顺序表的表长确定后无法修改，存满了就存不了了

顺序表的类型描述
#define MaxSize 10;			 //定义最大长度
typedef struct{
    int data[MaxSize];       //“静态”的数组存数据，存int数据
    int length;              //顺序表的当前长度
}SqList;
初始化
//初始化
void InitList(SqList &L){
    for(int i=0; i<MaxSize; i++){
        L.data=[i]=0;	     //将所有元素都设为默认值0
    }
    L.length=0;              //顺序表长度初始为0
}
插入
//插入操作：在顺序表L的第i个(位序)上插入x
bool ListInsert(SqList &L, int i,int e){
    if(i<1||i>L.length+1)		//判断i的范围是否有效
        return false;
    if(L.length>=MaxSize)		//当存储空间已满时，不能插入
        return false;
    for(int j=L.length; j>=i; j--)
        L.data[j]=L.data[j-1];  //将第i个及后面的元素后移
    L.data[i-1]=e;				//将e放到第i个位置
    L.length++;                 //长度+1
}
插入的时间复杂度：

最好情况：插到表尾，不需移动元素，循环0次，最好时间复杂度=O(1)

最坏情况：插到表头，移动n个元素，循环n次，最坏时间复杂度=O(n)

平均情况：设插入概率为p=1/n+1，则循环np+(n-1)p+…+1p=n/2，平均时间复杂度=O(n)

删除
//删除操作：删除顺序表L中第i个元素并返回其元素值
bool ListDelete(SqList &L, int i,int &e){
    if(i<1||i>L.length+1){		       //判断i的范围是否有效
        return false;
    }else{
        e = L.data[i-1];               //将被删除的元素赋值给e
        for(int j=i; j<L.length; j++){
            L.data[j]=L.data[j-1];     //将第i个后面的元素前移
        }
    	L.length--;                    //长度-1
        return ture;
    }
}
删除的时间复杂度：

最好情况：删除表尾，不需移动元素，循环0次，最好时间复杂度=O(1)

最坏情况：删除表头，移动n-1个元素，循环n次，最坏时间复杂度=O(n)

平均情况：设删除概率为p=1/n，则循环(n-1)p+(n-2)p+…+1p=(n-1)/2，平均时间复杂度=O(n)

查找
按位查找
//按位查找：返回顺序表中第i个元素的元素值
int GetElem(Sqlist L, int i){
    return L.data[i-1];
}
按位查找的时间复杂度

时间复杂度=O(1)

按值查找
//按值查找：返回顺序表L中第一个值为x的元素的位置
int LocateElem(Sqlist L, int e){
    for(int i=0; i<L.length; i++){
        if(L.data[i] == e)
            return i+1;  //返回元素位置
    }
    return -1;  //查找失败，返回-1
}
按值查找的时间复杂度

最好情况：目标在表头，循环1次，最好时间复杂度=O(1)

最坏情况：目标在表尾，循环n次，最坏时间复杂度=O(n)

平均情况：设删除概率为p=1/n，则循环(n-1)p+(n-2)p+…+1p=(n+1)/2，平均时间复杂度=O(n)

无销毁

系统自动销毁

五、动态分配的顺序表上的操作

动态分配的顺序表的优缺点：

优点：可以动态增加长度

缺点：动态增加长度中的迁移工作时间开销大

顺序表的类型描述
typedef struct{
    int *data;         //指向“动态”分配的数组的指针
    int MaxSize;	   //顺序表的最大长度
    int length;        //顺序表的当前长度
}SqList;
初始化
//初始化
void InitList(SqList &L){
    //用malloc函数申请一片连续的存储空间
    L.data=(int *)malloc(InitSize*sizeof(int));
    L.MaxSize=InitSize;
    L.length=0;              //顺序表长度初始为0
}
动态增加数组长度

方法：借用一个指针指向原来顺序表，新建一个更大的顺序表，将原数据迁移过来，并更改顺序表大小，最后释放原顺序表空间

//动态分配
void IncreaseSize(SqlList &L, int len){
    int *p=L.data;
    L.data=(int *)malloc((L.InitSize+len)*sizeof(int));
    for(int i=0; i<L.length; i++){
        L.data[i]=p[i];				//将数据迁移至新区域
    }
    L.MaxSize=L.MaxSize+len;		//顺序表最大长度+len
    free(p);						//释放原来的内存空间
}
插入

在静态分配的基础上，如果容量不够，则动态增加

//插入操作：在顺序表L的第i个(位序)上插入x
bool ListInsert(SqList &L, int i,int e){
    if(i<1||i>L.length+1)		//判断i的范围是否有效
        return false;
    if(L.length>=MaxSize)		//当存储空间已满时，动态增加数组长度
        IncreaseSize(L,10);
    for(int j=L.length; j>=i; j--)
        L.data[j]=L.data[j-1];  //将第i个及后面的元素后移
    L.data[i-1]=e;				//将e放到第i个位置
    L.length++;                 //长度+1
}
插入的时间复杂度：

最好情况：插到表尾，不需移动元素，循环0次，最好时间复杂度=O(1)

最坏情况：插到表头，移动n个元素，循环n次，最坏时间复杂度=O(n)

平均情况：设插入概率为p=1/n+1，则循环np+(n-1)p+…+1p=n/2，平均时间复杂度=O(n)

删除(与静态一样)
//删除操作：删除顺序表L中第i个元素并返回其元素值
bool ListDelete(SqList &L, int i,int &e){
    if(i<1||i>L.length+1){		       //判断i的范围是否有效
        return false;
    }else{
        e = L.data[i-1];               //将被删除的元素赋值给e
        for(int j=i; j<L.length; j++){
            L.data[j]=L.data[j-1];     //将第i个后面的元素前移
        }
    	L.length--;                    //长度-1
        return ture;
    }
}
删除的时间复杂度：

最好情况：删除表尾，不需移动元素，循环0次，最好时间复杂度=O(1)

最坏情况：删除表头，移动n-1个元素，循环n次，最坏时间复杂度=O(n)

平均情况：设删除概率为p=1/n，则循环(n-1)p+(n-2)p+…+1p=(n-1)/2，平均时间复杂度=O(n)

查找(与静态一样)
按位查找
//按位查找：返回顺序表中第i个元素的元素值
int GetElem(Sqlist L, int i){
    return L.data[i-1];
}
按位查找的时间复杂度

时间复杂度=O(1)

按值查找
//按值查找：返回顺序表L中第一个值为x的元素的位置
int LocateElem(Sqlist L, int e){
    for(int i=0; i<L.length; i++){
        if(L.data[i] == e)
            return i+1;  //返回元素位置
    }
    return -1;  //查找失败，返回-1
}
按值查找的时间复杂度

最好情况：目标在表头，循环1次，最好时间复杂度=O(1)

最坏情况：目标在表尾，循环n次，最坏时间复杂度=O(n)

平均情况：设删除概率为p=1/n，则循环(n-1)p+(n-2)p+…+1p=(n+1)/2，平均时间复杂度=O(n)

销毁
//销毁操作
void DestroyList(Sqlist &L){
    free(L.data);
    L.length = 0;
    L.MaxSize = 0;
    L.data = nullptr;  //令其为空指针
}

六、共同的操作

求表长
//求表长
int Length(Sqlist L){
    return L.length;
}
遍历
//遍历操作
void PrintList(Sqlist L){
    for(int i=0; i<L.length; i++){
        cout<<L.data[i]<<" ";
    }
    cout<<endl;
}
判空
//判空操作
int Empty(Sqlist L){
    return L.length==0? 1 : 0;
}

七、完整代码

//动态分配的顺序表的完整代码
#include<bits/stdc++.h>
using namespace std;

#define MaxSize 100   //定义线性表的最大长度
typedef struct Sqlist{
	int data[MaxSize];
	int length;
}Sqlist;

//初始化
void Init(Sqlist &L){
    L.length = 0;
}

//求表长
int Length(Sqlist L){
    return L.length;
}

//插入操作：在表中第i个位置上插入x
void Insert(Sqlist &L, int i, int x){
    if(i<1 || i>L.length+1 || L.length >= MaxSize){
        cout<<x<<" Insert failed."<<endl;
        return;
    }
    for(int j=L.length; j>=i; j--){  //第i个及以后的元素后移
        L.data[j] = L.data[j-1];
    }
    L.data[i-1]=x;
    L.length++;
}

//遍历操作
void PrintList(Sqlist L){
    cout<<"L: ";
    for(int i=0; i<L.length; i++){
        cout<<L.data[i]<<" ";
    }
    cout<<endl;
}

//按值查找：返回顺序表L中第一个值为x的元素的位置
int LocateElem(Sqlist L, int x){
    for(int i=0; i<L.length; i++){
        if(L.data[i] == x)
            return i+1;  //返回元素位置
    }
    return -1;  //查找失败，返回-1
}

//按位查找：返回顺序表中第i个元素的元素值
int GetElem(Sqlist L, int i){
    return L.data[i-1];
}

//删除操作：删除顺序表L中第i个元素并返回其元素值
int Delete(Sqlist &L, int i, int &x){
    if(i<1 || i>L.length){
        return -1;
    }else{
        x = L.data[i-1];
        for(int j=i; j<L.length; j++){
            L.data[j-1] = L.data[j];
        }
        L.length--;
        return x;
    }
}

//判空操作
int Empty(Sqlist L){
    return L.length==0? 1 : 0;
}

int main(){
    Sqlist L;
    Init(L); 
    Insert(L, 1, 50);
    Insert(L, 2, 60);
    Insert(L, 1, 40);
    Insert(L, 1, 666);
    Insert(L, 5, 70);
    Insert(L, 6, 40);
    Insert(L, 7, 100);
    cout<<"长度："<<Length(L)<<endl;
    PrintList(L);
    int x;
    cout<<"第三个元素是："<<GetElem(L,3)<<endl;
    cout<<"40在第"<<LocateElem(L,40)<<"位"<<endl;
    cout<<"删除"<<Delete(L,6,x)<<endl;
    PrintList(L);
    if(!Empty(L)){
        cout<<"L不为空"<<endl;
    }else{
        cout<<"L为空"<<endl;
    }
    return 0;
}

单链表—— Singly Linked List

一、单链表的定义

单链表：线性表的链式存储，它是通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。

二、单链表的特点

①不能随机访问：遍历查找访问

②存储密度不高：每个节点既要存数据元素又要存指针

③拓展容量方便：直接用建立单链表拓展

④插入、删除操作方便：知道位置直接插入和删除

三、单链表的实现方式

实现方式：不带头结点和带头结点，一般带头结点比不带头结点好

带头结点：写操作代码方便，一般用带头结点，不明确的都是带头结点的

不带头结点：写操作代码麻烦，要区分第一个数据和后续数据的处理

注：这两种方式主要是：类型描述相同，初始化和判空不同

四、单链表上的操作

单链表的类型描述
typedef struct LNode{    //定义单链表结点类型
	int data;            //数据域，可以是别的各种数据类型，本文统一用int类型
	struct LNode *next;  //指针域
}LNode, *LinkList;
初始化和判空

在这里插入图片描述

不带头结点的初始化和判空
//初始化
void InitList(LinkList &L){
    L = NULL;
    L->next = NULL;
}

//判空操作
bool Empty(LinkList L){
    if(L == NULL){
        return true;
    }else{
        return false;
    }
}
带头结点的初始化和判空
//初始化
void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LinkList));
    L->next = NULL;
}

//判空操作
bool Empty(LinkList L){
    if(L->next == NULL){
        return true;
    }else{
        return false;
    }
}
建立单链表
头插法建立单链表

用于链表的逆置

在这里插入图片描述

//头插法建立单链表
LinkList HeadInsert(LinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){ //输入9999表示结束
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin>>x;
    }
    return L;
}
尾插法建立单链表

在这里插入图片描述

//尾插法建立单链表
LinkList TailInsert(LinkList &L){
    InitList(L);
    LNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin>>x;
    }
    r->next = NULL;
    return L;
}
插入

时间复杂度=O(1)

带头结点的插入
//将x插入到单链表L的第i个位置上
bool Insert(LinkList &L, int i, int e){
    if(i<1) return false;
    LNode *p = GetElem(L,i-1);    //查找第i个位置
    return InsertNextNode(p, e);  //用后插操作，插在p后面
}
不带头结点的插入
//将x插入到单链表L的第i个位置上
bool Insert(LinkList &L, int i, int e){
    if(i<1) return false;
    if(i==1){
        LNode *s = (LNode *)malloc(sizeof(LNode));
    	s->data = e;
    	s->next = L;
    	L = s;
        return true;
    }
    LNode *p = GetElem(L,i-1);    //查找第i个位置
    return InsertNextNode(p, e);  //用后插操作，插在p后面
}
指定结点的后插操作
//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p, int e){
    if(p==NULL) return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL) return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
指定结点的前插操作

还是插在p后面，只不过让p和插入结点的值交换

//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p, int e){
    if(p==NULL) return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL) return false;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}
删除
按位序删除
//删除操作:将单链表中的第i个结点删除
bool Delete(LinkList &L, int i int &e){
    if(i<1 || i>Length(L))
        return false;
    LNode *p = GetElem(L,i-1);  //查找第i个位置
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}
按位序删除的时间复杂度：

最好情况：删除第一个，不需查找位置，循环0次，最好时间复杂度=O(1)

最坏情况：删除最后一个，需查找第n位，循环n次，最坏时间复杂度=O(n)

平均情况：删除任意一个，平均时间复杂度=O(n)

指定结点的删除

时间复杂度=O(n)

方法：p的后一个为q，p指向q的下一个，把q的值给p，最后释放q

//删除指定结点p
bool Delete(LNode *p){
    if(p==NULL) return false;
    LNode *q = p->next;
    p->data = q->data
    p->next = q->next;
    free(q);
    return true;
}
查找
按位查找

平均时间复杂度=O(n)

//按位查找：查找在单链表L中第i个位置的结点
LNode *GetElem(LinkList L, int i){
    int j=0;
    LNode *p = L;
    if(i<0) return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}
按值查找

平均时间复杂度=O(n)

//按值查找：查找e在L中的位置
LNode *LocateElem(LinkList L, int e){
    LNode *p = L->next;
    while(p && p->data != e){
        p = p->next;
    }
    return p;
}
求表长

平均时间复杂度=O(n)

//求表的长度
int Length(LinkList L){
    int len = 0;
    LNode *p = L;
    while(P->next){
        p = p->next;
        len++;
    }
    return len;
}
遍历
//遍历操作
void PrintList(LinkList L){
    LNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

五、完整代码

#include<bits/stdc++.h>
using namespace std;

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

//初始化
void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LinkList));
    L->next = NULL;
}

//遍历操作
void PrintList(LinkList L){
    LNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

//求单链表的长度
int Length(LinkList L){
    LNode *p = L->next;
    int len = 0;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

//头插法建立单链表
LinkList HeadInsert(LinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin>>x;
    }
    return L;
}

//尾插法建立单链表
LinkList TailInsert(LinkList &L){
    InitList(L);
    LNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin>>x;
    }
    r->next = NULL;
    return L;
}

//按值查找：查找x在L中的位置
LNode *LocateElem(LinkList L, int x){
    LNode *p = L->next;
    while(p && p->data != x){
        p = p->next;
    }
    return p;
}

//按位查找：查找在单链表L中第i个位置的结点
LNode *GetElem(LinkList L, int i){
    int j=1;
    LNode *p = L->next;
    if(i==0)return L;
    if(i<1)return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

//将x插入到单链表L的第i个位置上
void Insert(LinkList &L, int i, int x){
    LNode *p = GetElem(L,i-1);
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
}

//删除操作:将单链表中的第i个结点删除
void Delete(LinkList &L, int i){
    if(i<1 || i>Length(L)){
        cout<<"delete failed: index is wrong."<<endl;
        return;
    }
    LNode *p = GetElem(L,i-1);
    LNode *q = p->next;
    p->next = q->next;
    free(q);
}


int main(){
    //初始化，尾插法建立单链表
    LinkList L = TailInsert(L);
    //插入：在第二个位置插入结点，数据域为888，并遍历单链表
    Insert(L,2,888);
    cout<<"在第二个位置插入888： ";
    PrintList(L);
    //删除：删除第四个结点
    Delete(L,4);
    cout<<"删除第四个结点后：";
    PrintList(L);
    //按位查找：查找第三个结点，并输出其数据域的值
    LNode *p = GetElem(L,3);
    cout<<"第三个结点的值为："<<p->data<<endl;
    //按值查找：查找数据域为2的结点的指针
    LNode *q = LocateElem(L,2);
    cout<<"数据为2的结点的下一个结点的值为："<<q->next->data<<endl;
    //输出单链表的长度
    cout<<"单链表的长度："<<Length(L)<<endl;
    return 0;
}

双链表—— Double Linked List

一、单链表的定义

单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。

双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。

二、双链表的实现方式

实现方式：不带头结点和带头结点，一般带头结点比不带头结点好

带头结点：写操作代码方便，一般用带头结点，不明确的都是带头结点的

不带头结点：写操作代码麻烦，要区分第一个数据和后续数据的处理

三、双链表上的操作（带头结点）

双链表的类型描述
typedef struct DNode{
    int data;  //数据域
    struct DNode *prior,*next;  //前驱和后继指针
}DNode, *DLinkList;
初始化

在这里插入图片描述

//初始化
bool InitList(DLinkList &L){
    L = (LNode *)malloc(sizeof(DLinkList));
    if(L == NULL) return false;
    L->prior = NULL;
    L->next = NULL;
    return true;
}
判空
//判空操作
bool Empty(DLinkList L){
    if(L->next == NULL){
        return true;
    }else{
        return false;
    }
}
建立双链表
头插法建立双链表

用于链表的逆置

//头插法建立双链表
DLinkList HeadInsert(DLinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){
        DNode *s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        if(L->next == NULL){
            s->next = NULL;
            s->prior = L;
            L->next = s;
        }else{
            s->next = L->next;
            L->next->prior = s;
            s->prior = L;
            L->next = s;
        }
        cin>>x;
    }
    return L;
}
尾插法建立单链表
//尾插法建立双链表
DLinkList TailInsert(DLinkList &L){
    InitList(L);
    DNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        s->next = NULL;
        s->prior = r;
        r->next = s;
        r = s;
        cin>>x;
    }
    return L;
}
插入

时间复杂度=O(1)

插入操作

//将x插入到双链表L中*p结点的下一个结点
bool Insert(DNode *p, int x){
    DNode *s = (DNode *)malloc(sizeof(DNode));
    if(p == NULL||s==NULL) return false;
    s->data = x;
    s->next = p->next;  //1
    if(p->next != NULL) p->next->prior = s; //2
    s->prior = p;  //3
    p->next = s; //4
    return true;
}

//在双链表L中*p结点后插入s结点
bool Insert(DNode *p, DNode *s){
    if(p == NULL||s==NULL) return false;
    s->next = p->next;  //1
    if(p->next != NULL) p->next->prior = s; //2
    s->prior = p;  //3
    p->next = s; //4
    return true;
}
删除
按位序删除

时间复杂度=O(n)

删除操作

//删除操作:将双链表中的第i个结点删除
bool Delete(DLinkList &L, int i){
    if(i<1 || i>Length(L)) return false;
    DNode *p = GetElem(L,i-1);
    if(p == NULL) return false;
    DNode *q = p->next;
    p->next = q->next; //1
    if(p->next != NULL) q->next->prior = p; //2
    free(q);
    return true;
}
指定结点的删除

时间复杂度=O(1)

//删除操作:删除双链表中的p结点的后继结点
void DeleteNextNode(DNode *p){
    if(p == NULL) return false;
    DNode *q = p->next;
    if(q == NULL) return false;
    p->next = q->next; //1
    if(p->next != NULL) q->next->prior = p; //2
    free(q);
}
查找(与单链表完全一样)
按位查找

平均时间复杂度=O(n)

//按位查找：查找在单链表L中第i个位置的结点
DNode *GetElem(DLinkList L, int i){
    int j=0;
    DNode *p = L;
    if(i<0) return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}
按值查找

平均时间复杂度=O(n)

//按值查找：查找e在L中的位置
DNode *LocateElem(DLinkList L, int e){
    DNode *p = L->next;
    while(p && p->data != e){
        p = p->next;
    }
    return p;
}
求表长(与单链表完全一样)

平均时间复杂度=O(n)

//求表的长度
int Length(DLinkList L){
    int len = 0;
    DNode *p = L;
    while(P->next){
        p = p->next;
        len++;
    }
    return len;
}
遍历(与单链表完全一样)
//遍历操作
void PrintList(DLinkList L){
    DNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}
销毁
//销毁操作
void DestoryList(DLinkList L){
    //循环释放各点的数据结点
    while(L->next != NULL){
        DeleteNextNode(L);
    }
    free(L); //释放头结点
    L = NULL;
}

四、完整代码

#include<bits/stdc++.h>
using namespace std;

typedef struct DNode{
    int data;
    struct DNode *prior,*next;
}DNode, *DLinkList;

//初始化
void InitList(DLinkList &L){
    L = (DNode *)malloc(sizeof(DLinkList));
    L->prior = NULL;
    L->next = NULL;
}

//遍历操作
void PrintList(DLinkList L){
    DNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

//求双链表的长度
int Length(DLinkList L){
    DNode *p = L->next;
    int len = 0;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

//头插法建立双链表
DLinkList HeadInsert(DLinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){
        DNode *s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        if(L->next == NULL){
            s->next = NULL;
            s->prior = L;
            L->next = s;
        }else{
            s->next = L->next;
            L->next->prior = s;
            s->prior = L;
            L->next = s;
        }
        cin>>x;
    }
    return L;
}

//尾插法建立双链表
DLinkList TailInsert(DLinkList &L){
    InitList(L);
    DNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        s->next = NULL;
        s->prior = r;
        r->next = s;
        r = s;
        cin>>x;
    }
    return L;
}

//按值查找：查找x在L中的位置
DNode *LocateElem(DLinkList L, int x){
    DNode *p = L->next;
    while(p && p->data != x){
        p = p->next;
    }
    return p;
}

//按位查找：查找在双链表L中第i个位置的结点
DNode *GetElem(DLinkList L, int i){
    int j=1;
    DNode *p = L->next;
    if(i==0)return L;
    if(i<1)return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

//将x插入到双链表L中*p结点的下一个结点
void Insert(DLinkList &L, DNode *p, int x){
    DNode *s = (DNode *)malloc(sizeof(DNode));
    s->data = x;
    s->next = p->next;
    p->next->prior = s;
    s->prior = p;
    p->next = s;
}

//删除操作:将双链表中的第i个结点删除
void Delete(DLinkList &L, int i){
    if(i<1 || i>Length(L)){
        cout<<"delete failed: index is wrong."<<endl;
        return;
    }
    DNode *p = GetElem(L,i-1);
    DNode *q = p->next;
    p->next = q->next;
    q->next->prior = p;
    free(q);
}

//判空操作
bool Empty(DLinkList L){
    if(L->next == NULL){
        cout<<"L is null"<<endl;
        return true;
    }else{
        cout<<"L is not null"<<endl;
        return false;
    }
}


int main(){
    //尾插法建立双链表，并遍历单链表
    DLinkList L = TailInsert(L);
    cout<<"L: ";
    PrintList(L);
    
    DNode *p;
    //按值查找
    p = LocateElem(L,2);
    cout<<"值为2的结点的下一个结点值是："<<p->next->data<<endl;
    cout<<"值为2的结点的上一个结点值是："<<p->prior->data<<endl;
    //按位查找
    p = GetElem(L,3);
    cout<<"第三个结点值是："<<p->data<<endl;
    
    //插入操作
    Insert(L,p,7);
    cout<<"在第三个结点后面插入值为7的结点后L： ";
    PrintList(L);
    
    //删除操作
    Delete(L, 5);
    cout<<"删除第五个结点后L： ";
    PrintList(L);
    
    //求表长
    cout<<"表长为："<<Length(L)<<endl;;
    
    //判空
    Empty(L);
    return 0;
}

循环链表—— Double Linked List

一、循环链表的定义

循环链表：一般包括循环循环链表和循环循环链表，如下图所示

循环链表

二、循环链表的实现方式

实现方式：不带头结点和带头结点，一般带头结点比不带头结点好

带头结点：写操作代码方便，一般用带头结点，不明确的都是带头结点的

不带头结点：写操作代码麻烦，要区分第一个数据和后续数据的处理

三、循环单链表上的操作（带头结点）

循环单链表的类型描述(与单链表一样)
typedef struct LNode{    //定义循环链表结点类型
	int data;            //数据域，可以是别的各种数据类型，本文统一用int类型
	struct LNode *next;  //指针域
}LNode, *LinkList;;
初始化和判空(与单链表不一样)

L->next = NULL改为L->next = L

//初始化
void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LinkList));
    L->next = L;
}

//判空操作
bool Empty(LinkList L){
    if(L->next == L){
        return true;
    }else{
        return false;
    }
}
判断表尾结点
//判断结点p是否是表尾结点
bool isTail(LinkList L){
    if(p->next == L){
        return true;
    }else{
        return false;
    }
}
插入、删除

循环单链表的插入、删除算法与单链表几乎一样，不同的是如果在表尾进行，那么要让单链表继续保持循环的性质，即让尾结点的next域指向头结点。

时间复杂度=O(1)

查找

单链表的查找是从表头开始，找到表尾停止。而循环单链表中，若从表头开始查找，那与单链表的操作一致。若从表的任意位置开始查找，那么需要一个计数变量sum，当sum=表长时还未找到，则查找失败，退出循环。

求表长

与单链表一样

遍历

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

四、循环双链表上的操作（带头结点）

循环链表的类型描述
typedef struct DNode{
    int data;  //数据域
    struct DNode *prior,*next;  //前驱和后继指针
}DNode, *DLinkList;
初始化和判空

L->next = NULL改为L->next = L

L->prior = NULL改为L->prior = L

//初始化
bool InitList(DLinkList &L){
    L = (LNode *)malloc(sizeof(DLinkList));
    if(L == NULL) return false;
    L->prior = L;
    L->next = L;
    return true;
}

//判空操作
bool Empty(DLinkList L){
    if(L->next == L){
        return true;
    }else{
        return false;
    }
}
判断表尾结点
//判断结点p是否是表尾结点
bool isTail(DLinkList L){
    if(L->next == L){
        return true;
    }else{
        return false;
    }
}
插入

循环双链表的插入、删除算法与双链表几乎一样，不同的是如果在表尾进行，那么要让双链表继续保持循环的性质，即让尾结点的next域指向头结点，同时让头结点的prior域指向尾结点。

注：p->next->prior = s; 循环时不判断

时间复杂度=O(1)

//将x插入到循环链表L中*p结点的下一个结点
bool Insert(DNode *p, int x){
    DNode *s = (DNode *)malloc(sizeof(DNode));
    if(p == NULL||s==NULL) return false;
    s->data = x;
    s->next = p->next;  //1
    p->next->prior = s; //2
    s->prior = p;  //3
    p->next = s; //4
    return true;
}

//在循环链表L中*p结点后插入s结点
bool Insert(DNode *p, DNode *s){
    s->next = p->next;  //1
    p->next->prior = s; //2
    s->prior = p;  //3
    p->next = s; //4
    return true;
}
删除

注：p->next->prior = s; 循环时不判断

按位序删除

时间复杂度=O(n)

//删除操作:将循环链表中的第i个结点删除
bool Delete(DLinkList &L, int i){
    if(i<1 || i>Length(L)) return false;
    DNode *p = GetElem(L,i-1);
    DNode *q = p->next;
    p->next = q->next; //1
    q->next->prior = p; //2
    free(q);
    return true;
}
指定结点的删除

时间复杂度=O(1)

//删除操作:删除循环链表中的p结点的后继结点
void DeleteNextNode(DNode *p){
    DNode *q = p->next;
    p->next = q->next; //1
    q->next->prior = p; //2
    free(q);
}
查找(与单双链表完全一样)
按位查找

平均时间复杂度=O(n)

//按位查找：查找在循环链表L中第i个位置的结点
DNode *GetElem(DLinkList L, int i){
    int j=0;
    DNode *p = L;
    if(i<0) return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}
按值查找

平均时间复杂度=O(n)

//按值查找：查找e在L中的位置
DNode *LocateElem(DLinkList L, int e){
    DNode *p = L->next;
    while(p && p->data != e){
        p = p->next;
    }
    return p;
}
求表长、遍历、销毁

与单双链表一样

静态链表—— Static Linked List

一、静态链表的定义

静态链表借助数组来描述线性表的链式存储结构，结点也有数据域data和指针域next，这里的指针是结点的相对地址（数组下标），又称游标。和顺序表一样，静态链表也需要预先分配一块连续的内存空间。

静态链表

二、静态链表的特点

顺序表：逻辑上连续，物理上连续

静态链表：逻辑上离散，物理上连续

单双链表：逻辑上离散，物理上离散

静态链表比顺序表好。比单双链表差

优点：增加、删除操作不需要移动大量元素

缺点：①不能随机存取。只能从头结点遍历找

​ ②容量不可变

三、静态链表上的操作

静态链表的类型描述
#define MaxSize 50  //静态链表的最大长度
typedef struct SLinkList{
	ElemType data;  //数据元素
	int next;  //下一个元素的数组下标
}SLinkList[MaxSize];
初始化

a[0]的next设为-1

其它的next设为-2

判空

它的next为-2

则此结点为空

插入

①找一个空的结点，存入数据

②从头结点出发找到位序为i-1的结点

③修改新结点的next

④修改i-1号结点的next

删除

②从头结点出发找到前驱结点

③修改前驱结点的next

④被删除结点的next设为-2

查找

从头结点出发挨个往后遍历结点

求表长

从头结点出发挨个往后遍历结点

遍历

从头结点出发挨个往后遍历结点

RockyBlog
关注
专栏目录
王道考研数据结构笔记
weixin_45016439的博客
04-15 2万+
2022年4月16日 整理了这篇博客的pdf版本，但是缺的部分可能没法补上啦，把毕业的事忙完了可能！可以！对着书把笔记再整理一遍！所以所以，如果有需要pdf版本的可以私信我(有偿，奶茶钱这样)。 大家加油！一定会成功的！ 王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h>
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
【王道数据结构】第二章 | 线性表
强哥的微博
02-03 1083
【王道数据结构】第二章 | 线性表 线性表的定义 线性表的基础操作 顺序表的定义 顺序表的基本操作
线性表的顺序存储的介绍 — 基本运算(销毁线性表、输出线性表、增删查等)和 静态分配和动态分配
weixin_53161762的博客
03-11 2381
一、什么是线性表？ 线性表是由n(n≥0)个属性相同的数据元素a1,a2…an组成的一个有限序列。 可以表示为 A= (a1, a2, a3, … ai … an) 二、线性表的特征： 1、有且只有一个表头元素a1，它无前驱； 2、有且只有一个表尾元素an，它无后继； 3、表头元素与表尾元素外，其它所有元素有且只有一个前驱，也有且只有一个后继。 4、线性表中结点的个数n称为线性表的长度。当n＝0时，称为空表。 线性表 A= (a1, a2, a3, … ai … an) ，以线性表A为例，a2的前驱是a1，
顺序表、单链表——C语言实现及其比较
chunzhi5303的博客
02-09 663
（一）顺序表的实现 顺序表的存储结构定义 #define MaxSize 100 typedef int DataType; typedef struct { DataType data[MaxSize]; //存储数组 int length; //顺序表的长度 } seqList; ...
《王道》数据结构笔记整理2022
热门推荐
池鱼
08-21 22万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
23王道数据结构 C2线性表笔记
qq_52138199的博客
02-11 629
顺序表
王道数据结构-考研笔记
weixin_51297735的博客
04-29 2041
本数据结构笔记配合王道视频食用，效果更佳。若有条件，可彩印成册，涂写勾画，记出自己的笔记，内容若有错误，请见谅。本数据结构笔记内容绝大部分来自王道数据结构视频，部分来自《大话数据结构》，希望能够帮助到在考研路上的诸位。一路生花吧！
王道数据结构-线性表
m0_65036580的博客
08-30 349
线性表的学习笔记和书后习题第一题
王道数据结构笔记
NEVER STOP
08-14 1423
王道数据结构笔记
王道计算机考研 数据结构 笔记（包括PPT内容和笔记内容）
10-12
"王道计算机考研 数据结构 笔记（包括PPT内容和笔记内容）" 本资源摘要信息主要关注数据结构的基本概念、存储结构、算法设计、时间复杂度分析等知识点。 数据结构的基本概念 数据结构是指计算机存储、组织和管理...
Pandas_数据结构详解
2201_75415080的博客
09-19 1208
DataFrame是一个表格型的==结构化==数据结构，它含有一组或多组有序的列（Series），每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame是Pandas中最基本的数据结构，Series的许多属性和方法在DataFrame中也一样适用.两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。
数据结构——二叉树堆的专题
imaima666的博客
09-19 787
如果有一个关键码的集合K = {K0 ，K1 ，K2 ，K3…) i = 0，1， 2…，则称为(或将。
数据结构—树
最新发布
2301_80151359的博客
09-22 422
在文件系统中，树结构被广泛应用，它通过父结点和子结点之间的关系来表示不同层级的文件和文件夹之间的关联。树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系。若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点。以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙。一个结点含有的子树的根结点称为该结点的子结点；1.有一个特殊的结点，称为根结点，根结点没有前驱结点。具有相同父结点的结点互称为兄弟结点(亲兄弟)；
每日学习一个数据结构-哈夫曼树Huffman Tree
wendao76的专栏
09-20 561
哈夫曼树的主要应用领域包括数据压缩和传输优化。例如，在文件压缩软件中，使用哈夫曼编码可以有效地减少文件大小，从而节省存储空间或加快文件在网络上的传输速度。哈夫曼树（Huffman Tree）是一种特殊的二叉树，用于最小化带权路径长度，通常应用于数据压缩。假设有四个字符A、B、C、D，它们的频率分别为5、9、12、13。通过这种方式，可以有效地压缩原始数据。
Pandas中DataFrame表格型数据结构
weixin_43597208的博客
09-19 530
series是有一组数据与一组索引（行索引）组成的数据结构，而dataframe是由一组数据与一对索引（行索引和列索引）组成的表格型数据结构。总结：直接以字典的形式传入dataframe时，字典的key值就相当于列索引，如果没有设置行索引，行索引还是使用从0开始的默认索引，同样可以使用index参数自定义行索引。2.当传入一个嵌套列表时，会根据嵌套列表数显示成多列数据，行、列索引同样是从0开始的默认索引。1.只传入一个单一列表时，该列表的值会显示成一列，且行和列都是从0列开始的默认索引。
【探索数据结构与算法】插入排序：原理、实现与分析（图文详解）
2302_80220709的博客
09-16 1134
因此，第i个元素需要比较i次（其中i从2开始，直到n），总共需要进行的比较次数大约为1 + 2 + 3 + ... + (n-1) = n(n-1)/2，时间复杂度为O(n^2)。当输入数组已经是排序状态时，插入排序的性能最优。插入排序是一种原地排序算法，它只需要一个额外的存储空间来暂存当前需要插入的元素（即“key”），而不需要额外的数组来存储排序过程中的数据。在插入排序过程中，如果两个相等的元素，后面的元素不会移动到前面元素的前面，而是直接插入到与它相等的元素之后，从而保持了原有的相对顺序。
数据结构篇--顺序查找【详解】
m0_64056556的博客
09-22 740
就是在数据集合中寻找某种条件的数据元素的过程。是指用于查找的数据元素。找到了满足条件的数据元素，就是，否则就是称为。是指数据元素的某个数据项的值，可用于标识或者记录，一般我们只指一个。是指一个查找表操作仅仅涉及查找操作，简单来说就只是看看，不动态修改查找表。是指对这个查找表的操作设计查找，还要动态的插入和删除查找表。是指查找表中每个数据元素需要进行关键字比较次数的平均值。也就是上面这个公式。感觉有点模模糊糊的没看太懂？我们从一道简单的题中来近距离理解平均查找长度的概念。
数据结构线性表算法详解与合并操作
"该文档是针对数据结构中线性表的算法例题讲解，主要讨论了如何合并两个线性表以及如何合并两个已排序的线性表。文档出自《数据结构C语言版》清华大学出版社，由严蔚敏编写。文中包含实例代码分析，并提出了对于算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值