链表和双链表(AcWing 826.827)

今天我们讲的双链表和单链表是用数组的形式进行的。

也就是用邻接表的形式完成的。

#include<bits/stdc++.h>
using namespace std;
const int N =100010;
char cp;
int x,k;
int idx,head;
int a[N],Next[N];
void init()
{
    idx=0;
    head=-1;
}
void add_head(int x)
{
    a[idx]=x;
    Next[idx]=head;
    head=idx;
    idx++;
}
void shanchu(int k)
{
    if(k==0){head=Next[head];}
    else
    Next[k-1]=Next[Next[k-1]];
}
void charu(int k,int x)
{
    Next[idx]=Next[k-1];
    Next[k-1]=idx;
    a[idx]=x;
    idx++;
}
int main()
{
    init();
    int m;
    cin.tie(0);//优化速度,解除cin,cout捆绑
    ios::sync_with_stdio(false);//优化速度2,解除cin,scanf捆绑
    cin>>m;
    while(m--)
    {
        cin>>cp;
        if(cp==‘H‘)
        {
            cin>>x;
            add_head(x);
        }
        if(cp==‘D‘)
        {
            cin>>k;
            shanchu(k);
        }
        if(cp==‘I‘)
        {
            cin>>k>>x;
            charu(k,x);
        }
    }
    while(head!=-1)
    {
        cout<<a[head]<<‘ ‘;
        head=Next[head];
    }
    return 0;
}
//双链表其实理解起来更加复杂,但用起来却更加方便,我们需要额外定义两个数组,和两个指针来索引我们的链表。一般情况下我们定义头节点等于0,尾节点为1.#include<iostream> //刚开始学的时候都非常难理解,但是你懂了还是贼**舒服好吧,建议多画图!容易加深亲们的理解噢~~
#include<algorithm>
using namespace std;
const int N = 100010;
int a[N] , l[N], r[N];
int adx;
//在k的右边加上一个x
void add_to(int k,int x)
{
    a[adx]=x;
    l[adx]=k;
    r[adx]=r[k];
    l[r[k]]=adx;
    r[k]=adx++;
}
void shanchu(int k)
{
    r[l[k]]=r[k];
    l[r[k]]=l[k];
}
int main()
{
    r[0]=1;
    l[1]=0;
    adx=2; //因为数组中已有两个元素,所以adx从2开始。0
    int n;
    cin>>n;
    while(n--)
    {
        string cp;
        cin>>cp;
        int k,x;
        if(cp=="L")
        {
            cin>>x;
            add_to(0,x);
        }
        else if(cp=="R")
        {
            cin>>x;
            add_to(l[1],x);
        }
        else if(cp=="D")
        {
            cin>>k;
            shanchu(k+1);
        }
        else if(cp=="IL")
        {
            cin>>k>>x;
            add_to(l[k+1],x);
        }
        else{
            int k,x;
            cin>>k>>x;
            add_to(k+1,x);
        }
    }
    for(int i=r[0];i!=1;i=r[i])
    cout<<a[i]<<" ";
    return 0;
}

原文地址:https://www.cnblogs.com/zyz010206/p/12369946.html

时间: 2024-09-28 12:23:46

链表和双链表(AcWing 826.827)的相关文章

Python与数据结构[0] -&gt; 链表[1] -&gt; 双链表与循环双链表的 Python 实现

双链表 / Doubly Linked List 目录 双链表 循环双链表 1 双链表 双链表和单链表的不同之处在于,双链表需要多增加一个域(C语言),即在Python中需要多增加一个属性,用于存储指向前一个结点的信息. Doubly linked list: node_1 <---> node_2 <---> node_3 完整代码 1 from linked_list import LinkedList, test 2 3 4 class NodeDual: 5 def __i

深度解析(三)数组、单链表和双链表

数组.单链表和双链表介绍 以及 双向链表的C/C++/Java实现 概要 线性表是一种线性结构,它是具有相同类型的n(n≥0)个数据元素组成的有限序列.本章先介绍线性表的几个基本组成部分:数组.单向链表.双向链表:随后给出双向链表的C.C++和Java三种语言的实现.内容包括:数组单向链表双向链表1. C实现双链表2. C++实现双链表3. Java实现双链表 数组 数组有上界和下界,数组的元素在上下界内是连续的. 存储10,20,30,40,50的数组的示意图如下: 数组的特点是:数据是连续的

2.2 在单链表和双链表中删除倒数第K个节点

题目:分别实现两个函数,一个可以删除单链表中倒数第K个节点,另一个可以删除双链表中倒数第K个节点 要求:如果链表长度为N,时间复杂度达到O(N),额外空间复杂度达到O(1) My: 删除单链表或双链表中倒数第K个节点,核心代码(单链表和双链表的方法定义参见另一篇文:https://www.cnblogs.com/latup/p/9823179.html): 1 def del_k(L, k): 2 index = L.length - k + 1 3 L.delt(index) 原文地址:htt

浅谈单链表与双链表的区别

昨天面试官面试的时候问了我一道关于链表的问题:情境如下 面试官:请说一下链表跟数组的区别? 我:数组静态分配内存,链表动态分配内存:数组在内存中连续,链表不连续:数组利用下标定位,时间复杂度为O(1),链表定位元素时间复杂度O(n):数组插入或删除元素的时间复杂度O(n),链表的时间复杂度O(1). 根据以上分析可得出数组和链表的优缺点如下: 数组的优点 随机访问性强(通过下标进行快速定位) 查找速度快数组的缺点 插入和删除效率低(插入和删除需要移动数据) 可能浪费内存(因为是连续的,所以每次申

算法总结之 在单链表和双链表中删除倒数第k个节点

分别实现两个函数,一个可以删除单链表中倒数第k个节点,另一个可以删除双链表中倒数第k个节点 思路: 如果链表为空,或者k<1 参数无效 除此之外 让链表从头开始走到尾,每移动一步,就让k的值减1 当链表走到头时候 如果k值大于0   说明不用调整  因为链表根本没有倒数第k个节点 此时将原链表直接返回即可 如果k值=0,说明链表倒数第k个节点就是头节点,此时直接返回head.next 也就是原链表的第二个节点 让第二个节点作为链表的头节点,此时直接返回head.next 如果k值<0  重新从

单链表,双链表,循环链表的区别

单向链表(单链表) 单向链表,它包含两个域,一个信息域和一个指针域.这个链接指向表中的下一个节点,而最后一个节点则 指向一个空值NULL. 单向链表只可向一个方向遍历. 查找一个节点的时候需要从第一个节点开始每次访问下一个节点,一直访问到需要的位置.也可以提前把一个节点的位置另外保存起来,然后直接访问. 双向链表,(双链表) 双向链表中不仅有指向后一个节点的指针,还有指向前一个节点的指针.第一个节点的"前连接"指向NULL,最后一个节点的"后连接"指向NULL. 这

[算法]在单链表和双链表中删除倒数第k个结点

题目: 分别实现两个函数,一个可以删除单链表中倒数第K个节点,另一个可以删除双链表中倒数第K个节点. 要求: 如果链表长度为N,时间复杂度达到O(N),额外空间复杂度达到O(1). 解答: 让链表从头走到尾,每移动一步,就让K值减一,当链表走到结尾时,如果K值大于0,说明不用调整链表,因为链表根本没有倒数第K个节点,此时将原链表直接返回即可:如果K值等于0,说明链表倒数第K个节点就是头结点,此时直接返回head.next,相当于删除了头结点.当K的值小于零时,再次从头结点开始走,每移动一步,就让

日常学习随笔-数组、单链表、双链表三种形式实现栈结构的基本操作

一.栈结构 栈(stack)是限制插入和删除只能在一个位置上的表,该位置是 表的末端,叫做栈的顶(Top).对栈的基本操作有push(进栈),pop(出栈),peak(栈顶元素),size(栈容量)等. 栈的核心思想:"先进后出". 二.案例一:数组实现"栈" 1 package com.xfwl.algorithmAnalysis.stack; 2 3 import java.util.Arrays; 4 5 /** 6 * 自定义栈结构(基于数组的形式) 7 *

数据结构单链表,双链表,数组的底层实现原理

单链表: 链表是动态分配内存在内存中不连续,单链表只有一个向下的指针,指向下一个节点,单链表的定位时间复杂度是O(n),插入删除的时间复杂度是O(1) 双链表: 链表是动态分配内容在内存中不连续,单双链表一致,双链表有两个指针prov,next ,prov指向上一个节点,next指向下一个节点,理论上同样的数据量双向链表的查询速度比单链表快,双向链表可以使用二分查找法,最多查找一半的元素就可得到目标,单链表需要遍历整个链表对象. 数组: 数组静态分配内存,在内存中连续 数组的优点 随机访问性强(