数据结构-链表

链表的特点

  链表的特点是用一组任意位置的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。链表的操作有初始化、添加、遍历、插入、删除、查找、释放等。链表分为单向链表和双向链表。
  链表一般是循环的，收尾相连的，最后一个节点的next指针指向第1个节点，第1个节点的pre指针指向最后一个节点。单向链表只有一个遍历方向，双向链表有两个遍历方向。在需要频繁访问前后几个节点的时候使用双向链表。

下面给出一个题目(报数问题)，给出动态链表，静态链表、STL 链表解决问题的方案

问题描述：
 			有n个人，编号为1~n,按顺序围成一圈，从第一个人开始报数，
 			数到m的人出列，再由下一个人重新从1开始报数，数到m的人再出列，
 			依次类	推，直到所有的人都出列，请依次输出出列人的编号。
输入：
 			两个整数n和m，1≤m，n≤100。
输出：
 			n个整数，按照顺序输出每个出列人的编号。

输入样例：

10 3

输出样例：

3 6 9 2 7 1 8 5 10 4

动态链表

  动态链表需要临时分配链表节点，使用完毕后释放链表节点。动态链表能够及时的释放空间，不使用多余的内存；但是需要耗费空间管理，容易出现错误。

#include<bits/stdc++.h>
using namespace std;
struct node         //定义链表的节点
{
    int data;       //节点的值
    node *next;     //单向链表，只有一个next指针
};
int main()
{
    int n,m;
    cin>>n>>m;
    node *head,*p,*now,*prev;
    head=new node;
    head->data=1;
    head->next=NULL;
    now=head;
    //创建循环链表
    for(int i=2;i<=n;i++)
    {
        p=new node;
        p->data=i;
        p->next=NULL;
        now->next=p;
        now=p;
    }
    now->next=head;
    //解决问题的代码
    now=head,prev=head;
    while((n--)>1)
    {
        for(int i=1;i<m;i++)
        {
            prev=now;
            now=now->next;
        }
        cout<<now->data<<" ";
        prev->next=now->next;
        delete now;
        now=prev->next;
    }
    cout<<now->data<<endl;
    delete now;
    return 0;
}

静态链表

   在算法中一般不使用动态链表,省去动态分配和释放的麻烦
  静态链表使用预先分配的一段连续空间存储链表。实现的方法有两种：
  1.定义链表结构体数组
  2.使用一维数组，直接在数组上进行链表操作

用结构体数组实现单向静态链表

结构体数组定义应该在全局定义，不能定义在函数内部，防止爆栈

#include<bits/stdc++.h>
using namespace std;
const int N=110;
struct node
{
    int id,nextid;
    //int data;
}nodes[N]; //定义在全局的静态分配
int main()
{
    int n,m;
    cin>>n>>m;
    nodes[0].nextid=1;
    for(int i=1;i<=n;i++)
    {
        nodes[i].id=i;
        nodes[i].nextid=i+1;
    }
    nodes[n].nextid=1;  //循环链表 尾指向头
    int now=1,prev=1;
    while((n--)>1)
    {
        for(int i=1;i<m;i++)
        {
            prev=now;
            now=nodes[now].nextid;
        }
        cout<<nodes[now].id<<" ";
        nodes[prev].nextid=nodes[now].nextid;
        now=nodes[prev].nextid;
    }
    cout<<nodes[now].nextid<<endl;
    return 0;
}

用结构体数组实现双向静态链表

#include<bits/stdc++.h>
using namespace std;
const int N=110;
struct node
{
    int id;
    //int data;
    int preid,nextid;
}nodes[N];
int main()
{
    int n,m;
    cin>>n>>m;
    nodes[0].nextid=1;
    for(int i=1;i<=n;i++)
    {
        nodes[i].id=i;
        nodes[i].preid=i-1;
        nodes[i].nextid=i+1;
    }
    nodes[n].nextid=1;  //双向循环链表：尾指向头
    nodes[1].preid=n;   //双向循环链表：头指向尾
    int now=1;
    while((n--)>1)
    {
        for(int i=1;i<m;i++) now=nodes[now].nextid;
        cout<<nodes[now].id<<" ";
        int prev=nodes[now].preid,next=nodes[now].nextid;
        nodes[prev].nextid=nodes[now].nextid;
        nodes[next].preid=nodes[now].preid;
        now=next;
    }
    cout<<nodes[now].nextid<<endl;
    return 0;
}

用一维数组实现单向链表静态链表

这是最简单的实现方法。定义了一个一维数组nodes[],nodes[i]的i就是节点的值，而nodes[i]的值是下一个节点。它的使用环境很有限，因为它的节点只能存一个数据，就是i。

#include<bits/stdc++.h>
using namespace std;
int nodes[150];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n-1;i++) nodes[i]=i+1;  //nodes[i]的i就是节点的值
    nodes[n]=1;
    int now=1,prev=1;
    while((n--)>1)
    {
        for(int i=1;i<m;i++)
        {
            prev=now;
            now=nodes[now];
        }
        cout<<now<<" ";
        nodes[prev]=nodes[now];
        now=nodes[prev];
    }
    cout<<now<<endl;
    return 0;
}

STL list

list 是双向链表，在标准模板库中

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m;
    cin>>n>>m;
    list<int> node; // 声明一个存储整数的链表
    for(int i=1;i<=n;i++) node.push_back(i);
    //循环从1到n，将每个整数添加到链表中 
    list<int>::iterator it=node.begin();
    // 声明一个链表迭代器，并将其指向链表的第一个元素
    //迭代器是一种类似指针的对象，它允许你在容器中依次访问元素
    while((n--)>1)
    {
        for(int i=1;i<m;i++)
        {
            it++;// 将迭代器向后移动一位
            if(it==node.end()) it=node.begin();  //循环到尾回到头部
        }
        cout<<*it<<" ";
        // 将下一个节点的迭代器保存到next中
        list<int>::iterator next=++it;
        if(next==node.end()) next=node.begin();
        //如果下一个节点是链表的末尾，则将其设置为链表的头部(实现循环)
        node.erase(--it);
        // 删除当前节点，并将迭代器it指向下一个节点
        it=next;
    }
    cout<<*it;
    return 0;
}

至此实现报数问题的五种代码展示完了，下面介绍在算法题中该如何实现链表的操作(用数组模拟链表)

单链表题目

问题描述

问题描述
		实现一个单链表，链表初始为空，支持三种操作：
		向链表头插入一个数；删除第 k个插入的数后面的一个数；
		在第 k个插入的数后插入一个数。
		现在要对该链表进行 M次操作，进行完所有操作后，从头到尾输出整个链表。

		注意:题目中第 k个插入的数并不是指当前链表的第 k个数。例如操作过程中一共插入了 n个数，则按照插入的时间顺序，这 n个数依次为：第 1 个插入的数，第 2个插入的数，…第 n个插入的数。

输入格式
		第一行包含整数 M，表示操作次数。

		接下来 M行，每行包含一个操作命令，操作命令可能为以下几种：
		H x，表示向链表头插入一个数 x。
		D k，表示删除第 k个插入的数后面的数（当 k为 0 时，表示删除头结点）。
		I k x，表示在第 k个插入的数后面插入一个数 x（此操作中 k均大于 0）。
输出格式
		共一行，将整个链表从头到尾输出。

数据范围
		1≤M≤100000

输入样例

10
H 9
I 1 1
D 1
D 0
H 6
I 3 6
I 4 5
I 4 5
I 3 4
D 6

输出样例

6 4 6 5

解析

先解释一下什么叫第k个插入的元素：

1. 把插入操作按先后排序，第 k 次执行插入操作的那个元素。
2. 并不是链表中从前往后数第 k 个元素。

插入操作：

• 链表为空的时候：idx 的值为 0,
• 插入第一个元素 a 后：e[0] = a, idx 的值变为 1，
• 插入第二个元素 b 后：e[1] = b, idx 的值变为 2,
• 插入第三个元素 c 后：e[2] = c, idx 的值变为 3，
  所以： 第 k 个出入元素的索引值 k - 1

伴随着删除操作的插入：

• 链表为空的时候：idx 的值为 0,
• 插入第一个元素 a 后：e[0] = a, idx 的值变为 1，
• 插入第二个元素 b 后：e[1] = b, idx 的值变为 2,
• 删除第一个插入的元素 a：head 变为 1， idx 不变，依旧为 2。
• 删除第二个插入的元素 b：head 变为 2， idx 不变，依旧为 2。
• 插入第三个元素 c 后：e[2] = c, idx 的值变为 3。
  所以删除操作并不改变第 k 个插入元素的索引。
  

代码

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
// head 表示头节点的下标
// e[i] 表示节点i的值
// ne[i] 表示节点i的next指针是多少
// idx 存储当前已经用到了哪个节点
int head,e[N],ne[N],idx;
void init()
{
    head=-1; // 初始化头节点为-1，表示链表为空
    idx=0;  // 初始化已用节点为0
}
// 在链表头部插入一个节点
void insert_to_head(int x)
{
    ne[idx]=head;
    head=idx;
    e[idx]=x;
    idx++;
}
// 在第k个插入的节点之后，插入一个值为x的节点
void insert(int k,int x)
{
    ne[idx]=ne[k];
    ne[k]=idx;
    e[idx]=x;
    idx++;
}
// 在第k个插入的节点之后，插入的数
void remove(int k)
{
    ne[k]=ne[ne[k]];
}
int main()
{
    int m;
    cin>>m;
    init();
    while(m--)
    {
        char op;
        cin>>op;
        int k,x;
        if(op=='H') 
        {
            cin>>x;
            insert_to_head(x);
        }
        else if(op=='I')
        {
            cin>>k>>x;
            insert(k-1,x);
        }
        else
        {
            cin>>k;
            if(!k) head=ne[head];
            else remove(k-1);
        }
    }
    for(int i=head;i!=-1;i=ne[i]) cout<<e[i]<<" ";
    return 0;
}

双链表题目

问题描述

问题描述：
		实现一个双链表，双链表初始为空，支持 5种操作：
		1.在最左侧插入一个数；
		2.在最右侧插入一个数；
		3.将第 k个插入的数删除；
		4.在第 k个插入的数左侧插入一个数；
		5.在第 k个插入的数右侧插入一个数
		现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。

注意:题目中第 k个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n个数依次为：第 1个插入的数，第 2个插入的数，…第 n 个插入的数。

输入格式：
		第一行包含整数 M，表示操作次数。
		接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：
		L x，表示在链表的最左端插入数 x。
		R x，表示在链表的最右端插入数 x。
		D k，表示将第 k个插入的数删除。
		IL k x，表示在第 k个插入的数左侧插入一个数。
		IR k x，表示在第 k个插入的数右侧插入一个数。
输出格式：
		共一行，将整个链表从左到右输出。

数据范围：
		1≤M≤100000

解析

初始化链表

1. r[0]=1,l[1]=0;
2. idx=2; 因为0，1已经被使用了

删除第k个插入的节点

1. 将第k个插入节点的右边节点的左手连接第k个插入节点的上一个节点
2. 将第k个插入节点的左边节点的右手连接第k个插入节点的下一个节点

因为idx从2开始，需要特别注意在操作的时候k需要加1

代码

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int idx,e[N],l[N],r[N];
int m;
//初始化双链表
void init()
{
    //0是左端点，1是右端点
    r[0]=1,l[1]=0;
    idx=2;  //idx为2,因为0,1已经使用
}
//在第k个节点的右边插入一个数
void insert(int k,int x)
{
    e[idx]=x;
    l[idx]=k,r[idx]=r[k];
    l[r[k]]=idx,r[k]=idx++;
}
//删除第k个插入的节点

void remove(int k)
{
    l[r[k]]=l[k];
    r[l[k]]=r[k];
}
int main()
{
    cin>>m;
    init();
    while(m--)
    {
        string op;
        cin>>op;
        int k,x;
        if(op=="L")
        {
            cin>>x;
            insert(0,x);
        }
        else if(op=="R")
        {
            cin>>x;
            insert(l[1],x);
        }
        else if(op=="D")
        {
            cin>>k;
            remove(k+1);
        }
        else if(op=="IL")
        {
            cin>>k>>x;
            insert(l[k+1],x);
        }
        else
        {
            cin>>k>>x;
            insert(k+1,x);
        }
    }
    for(int i=r[0];i!=1;i=r[i]) cout<<e[i]<<" ";
    return 0;
}