精华内容
下载资源
问答
  • 双向链表插入和删除
    2021-11-02 00:18:40

    在单链表中,查找直接后继结点的执行时间为O(1),而查找直接前驱的执行时间为O(n);为了克服单链表这种单向性的缺点,双向链表就产生了。
    双向链表的结点中有两个指针域,一个指向直接后继,另一个指向直接前驱。
    显然有:
    若p为指向表中某一结点的指针,则有:
    p->next->prior = p->prior->next = p;
    双向链表的存储结构如下:

    typedef struct DuLNode
    {
    	ElemType data;				//数据域
    	struct DuLNode *prior;	    //指向直接前驱
    	struct DuLNode *next;		//指向直接后继
    }DuLNode,*DuLinkList;
    

    在插入和删除时需要同时修改两个方向的指针。
    在插入结点时需要修改四个指针,算法如下:

    //在带头结点的双向链表L中第i个位置之前插入元素e
    Status ListInsert_DuL(DuLinkList &L,int i,ElemType e)
    {
    	if(!(p = GetElem_DuL(L,i)))
    		return ERROR;
    	s = new DuLNode;
    	s->data = e;
    	s->prior = p->prior;
    	p->prior->next = s;
    	s->next = p;
    	p->prior = s;
    	return OK;
    }
    

    如图:
    在这里插入图片描述
    双向链表的删除
    需要同时修改两个指针,算法如下:

    //删除带头结点的双向链表L中的第i个元素
    Status ListInsert_DuL(DuLinkList &L,int i,ElemType e)
    {
    	if(!(p = GetElem_DuL(L,i)))
    		return ERROR;
    	p->prior->next = p->next;
    	p->next->prior = p->prior;
    	delete p;
    	return OK;
    }
    

    如图:
    在这里插入图片描述
    插入和删除的时间复杂度都为O(n)。

    更多相关内容
  • 插入和删除,这几个不太懂的童鞋关注我上一篇文章( https://juejin.cn/post/7022789985589788709 ),然后老师讲解了约瑟夫环,约瑟夫环采用的是循环链表,今天我们复习一下约瑟夫环的算法,顺便提前预习一下双向链表...

    前言:

    今天课上我们老师复习了单链表的头插法和尾插法,插入和删除,这几个不太懂的童鞋关注我上一篇文章( https://juejin.cn/post/7022789985589788709 ),然后老师讲解了约瑟夫环,约瑟夫环采用的是循环链表,今天我们复习一下约瑟夫环的算法,顺便提前预习一下双向链表和循环双向链表。

    每日一遍,防止颓废

    你的室友可能在划水,但绝对没有停止学习,明修栈道,暗度陈仓
    图片库mmexport745448268ed44201630e18478b7f3716_1635173.webp

    图片库mmexportc5f86cf7c912511b1ba88c5a6c4cefe8_1635173.webp

    1.1 约瑟夫环

    我们先了解一下约瑟夫环,约瑟夫环是一个悲惨的故事在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止,我们用简单一点的数据,N个人围成一圈,从第一个开始报数,第M个将被出列。例如N=6,M=5,出列的顺序是:5,4,6,2,3**,**1

    来个图分析一下:
    image.png
    讲人话就是:一个首尾连接的单链表,每次计数,达到要求了把它输出再删除,差不多和单链表的删除一样(只是多循环了几次):
    写一下给大家看看,代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    typedef struct Node {
        int  data;
        struct Node *next;
    }link;
    link * creattail(int * arc, int length) {//这里我们采用尾插法 ,来创建链表 
        int i;
        link * q ; //q用来标记上个结点的位置,然后q和下一个新建结点连接
        link * H =(link*)malloc(sizeof(link));//创建第一个结点 
        H->data = arc[0];
        H->next = NULL;
        q = H;	//q要记住第一个结点 
        for (i = 1; i<length; i++) {
            link * a = (link*)malloc(sizeof(link));//创建新结点 
            q->next = a;    //上个结点连接新建立的结点,从而产生每次新建结点在最后一个 
            a->data = arc[i]; //给新建立的结点赋值 
            a->next = NULL; //因为新建立的结点是最后一个,所以它的指针域是NULL 
            q = a;  //q 现在标记新建立的结点,作为最后一个结点,方便后面新建立的结点连接q  
        }
        return H;//返回第一个结点 
    }
    link * creatcycle (int * arc, int length) {//这里我们采用尾插法 ,来创建链表 
        int i;
        link * q ; //q用来标记上个结点的位置,然后q和下一个新建结点连接
        link * H =(link*)malloc(sizeof(link));//创建第一个结点 
        H->data = arc[0];
        H->next = NULL;
        q = H;	//q要记住第一个结点 
        for (i = 1; i<length; i++) {
            link * a = (link*)malloc(sizeof(link));//创建新结点 
            q->next = a;    //上个结点连接新建立的结点,从而产生每次新建结点在最后一个 
            a->data = arc[i]; //给新建立的结点赋值 
            a->next = H; //因为新建立的结点是最后一个,所以我们指向头结点形成循环链表 
            q = a;  //q 现在标记新建立的结点,作为最后一个结点,方便后面新建立的结点连接q  
        }
        return H;//返回第一个结点 
    }
    void yuesefu(link *p,int n,int m)
    {	 int i=1;
    	 link * q;
    	 q = p;
    	 int j=1;
    	 while(j<n&&p!=NULL)
    	 {	
    	 	if(i==m)//判断计数i是不是等于m,如果等于m说明到了q这个指针要出列 
    	 	{
    	 	  i=1;
    	 	  j++;  //统计结点数 
    	 	  printf("%d,",p->data);
    	 	  q->next = p->next; //上一个结点连接当前的下一个结点 
    	 	  free(p);  //释放结点 
    	 	  p=q->next; //因为我i赋值为1,所以我之间把p指向q的下一个 
    		 }
    		 else
    		 {
    		 	i++;//没到位置计数+1 
    		 	q =p; //标记当前位置,因为p马上要去下一个位置 
    		 	p=p->next;//到下一个结点 
    		 }
    	 }
    	  printf("%d",p->data);//输出最后一个结点 
    	  free(p);
    }
    
    void display(link *p) { //链表的输出函数,遍历链表 
        while (p) {
            printf("%d ", p->data);
            p = p->next;
        }
        printf("\n");
    }
    void displaycycle(link *p,int a) { // 因为是循环链表不管那个结点都可以遍历整个表,所要传遍历次数 a 
    	int i=0;
        while (i<a) { 
        	i++;
            printf("%d ", p->data); 
            p = p->next;
        }
        printf("\n");
    }
    int main() {
        int a[6] = { 1,2,3,4,5,6};
        link * cycle = creatcycle(a, 6);    //采用尾插法,创建循环链表 
        displaycycle(cycle,6);			//输出一下 
        yuesefu(cycle,6,5);				//约瑟夫环实现,cycle代表循环链表,6代表总结点数,5为第几个位置输出 
        free(cycle);
        return 0;
    }
    
    

    效果展示:
    image.png

    2.双向链表

    image.png
    双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点(讲人话就是:一个结点可以往前访问也可以往后面访问)结合生活中的楼梯或者电梯联想一下吧:
    image.png
    用个小故事加深大家的映像

    微风拂过那窗口那个女孩的脸庞,她似乎在注视着什么,楼下的人群过马路的人群,有着一个男孩的,她注视着,直到那个男孩注视着她,他们的眼神在交流,女孩脸庞展露着丝丝红润,似刚刚开放的桃花,微微泛红,又似蜜桃,甜润饱满,男孩的眼神,如电一般,犀利,迷人,他们眼神相对,彼此逃避着,又互相牵引着,女孩快速出门,来到了,楼梯间,她犹豫着,他会走那边,这边也可以上下,那边也可以,男孩也犹豫着,天公不作美,他们之间,一个下楼,一个上楼,彼此错过,男孩摇摇头说:“下次遇到她一定要叫她交房租”,女孩叹着气说:“幸亏跑的快,不然就要交房租了”,哈哈哈,女孩下楼就是链表往下遍历next,男孩上楼就是往上遍历port,他们之间其实就是相当于两条链表,但是有同学就问了,我要是那个男孩就上去一半,发现她不在,然后再到另一边下去,就可以遇到她了,说明我们同学还是很聪明的,这就相当于我往下遍历一半,再往上遍历回到起点,这种做法在双向链表里可以做到的,双向链表就好比坐电梯能上能下,楼层就是我们的数据。

    #include <stdio.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    typedef struct Node {
        int  data;
        struct Node *port,*next;
    }link;
    link * creat(int * arc, int length) {//使用尾插法创建 
        int i=0;
        link * q,* p,*head;
        head = q = p=(link*)malloc(sizeof(link));//创建第一个结点 
        q->data = arc[0];
        q->next = NULL;//第一个结点后继NULL 
        q->port = NULL;// 第一个结点前驱NULL 
        for (i = 1; i<length; i++) {	
            p = (link*)malloc(sizeof(link));//创建新结点 
            p ->data =arc[i];
            p ->port = q; //新结点前驱连接上一个结点 
    		q ->next = p;//上一个结点的后继连接当前的结点 
    		q =p;		//然后把上一个结点的标记q,指向新结点 
    		p->next =NULL; //新结点的指针域指向NULL 
        }
       return head;
    }
    void displayport(link *p) { //链表的输出函数,使用前驱遍历链表 
        while (p) {
            printf("%d ", p->data);
            p = p->port;
        }
        printf("\n");
    }
    void displaynext(link *p) { //链表的输出函数,使用后继遍历链表 
     	  printf("%d ", p->data);
    	while (p->next) {
    		p = p->next; 
            printf("%d ", p->data);   
        }
       	printf("\n");
        displayport(p);//传最后一个结点用后继输出一下 
        
    }
    int main(int argc, char *argv[]) {
    	 int a[6] = { 1,2,3,4,5,6};
         link * list = creat(a, 6);     
         displaynext(list);//使用后继输出 
         
    }
    

    博主用的是尾插法新建的效果展示一下:
    image.png

    3.双向链表插入和删除:

    3.1双向链表的插入,插入是需要两个结点的,注意:要保持p的后继是最后断开就可以了,也就是第四步其他几步的位置没要求。

    image.png

    void insert(link *p,int n,int m)//在第n后的位置插入数据m 
    {
    	int i= 1;
    	while(i<n)
    	{
    		p =p->next;	
    		i++;
    	}
    	link * q=(link*)malloc(sizeof(link));//创建结点 
    	q->data = m;//把m的数据给q 
    	p->next->port = q;//2.p->next的前驱连接新结点 
    	q->next = p->next;//1.新插入的结点后继连接p->next 
    	q->port = p;//3 新插入的结点的前驱指向p 
    	p->next = q;//4 p的后继指向q;注前三条位置可以随便动 
    			
    } 
    

    效果展示:
    image.png

    3.2双向链表的删除,只需要一个结点,就可以完成啦

    image.png
    代码如下:

    void deletelist(link *p,int n)
    {
    	int i=1;
    	while(i<n)
    	{
    		p =p->next;	
    		i++;
    	}
    	p->port->next = p->next;//第一步 
    	p->next->port = p->port;//第二步 
    	free(p);//第三步 
     } 
    

    效果展示:我删除了链表3位置的数据

    image.png

    3.循环双向链表

    3.1循环双向链表和循环单链表差不多,就是多了个前驱结点,可以往前执行。

    image.png

    3.2创建循环双向链表,让我们卷起来,铁子们

    图片库mmexport7e7fb12da5997fbf029f4e19159ee5d8_1635173.webp
    用代码实现一下:

    
    link * creatcycle(int * arc, int length) {//使用尾插法创建 
        int i=0;
        link * q,* p,*head;
        head = q = p=(link*)malloc(sizeof(link));//第一步:创建第一个结点 
        p->data = arc[0];
        p->next = p;//第一个结点后继NULL 
        p->port = p;// 第一个结点前驱NULL 
        for (i = 1; i<length; i++) {	
            p = (link*)malloc(sizeof(link));//第二步:创建新结点 
            p ->data =arc[i];
            p ->port = q; //第三步:新结点前驱连接上一个结点 
    		q ->next = p;//第四步上一个结点的后继连接当前的结点 
    		p->next =head;//第五步:最后一个结点指向head 
    		head->port = p;//head的前驱指向p 
    		q =p;		//然后把上一个结点的标记q,指向新结点 
        }
       return head;
    }
    void displaycycle(link *p) { //链表的输出函数,使用后继遍历链表 
        link * head=p; 
     	printf("%d ", p->data);
    	p = p->next; 
    	while (p!=head) {
            printf("%d ", p->data); 
    		p = p->next;   
        }
       	printf("\n");
    }
    

    效果展示:
    image.png
    使用我们之前双向链表后继的输出应该是死循环
    image.png
    使用我们之前双向链表前驱的输出应该是死循环
    image.png

    总结:

    数据结构,线性表链表的操作我们基本上都操作,循环双向链表的插入和删除和双向表的插入删除是一样的,我们没有做更多的操作了,如果有什么问题,可以评论问我,我们可以一起探讨一下,学习还是得动手敲,博主提供的代码是可以直接建项目跑,也可以跟着博主总结的步骤图,一步一步的敲。好了,创作不易,希望大家喜欢,点赞,关注,评论,收藏,博主会跟着数据结构往下面更新,有喜欢的可以收藏哦。放个图让大家卷起来。

    上一篇:数据结构专升本学习笔记,线性表单链表

    下一篇:数据结构专升本学习,栈篇(画图教您顺序栈的进栈出栈操作)

    图片库mmexportd66b9612472befdcfbc0836c7ee9614d_1635173.webp

    展开全文
  • 本文将详细介绍建立双向链表,实现对双向链表插入,删除操作,需要了解的朋友可以参考下
  • 数据结构复习1.2——双向链表插入删除 插入元素 删除元素 代码:单链表差不多,不会就画一画,就写出来了 //双向链表插入删除 #include<stdio.h> #include<stdlib.h> typedef struct node{...

    数据结构复习1.2——双向链表的插入与删除
    插入元素
    在这里插入图片描述
    删除元素
    在这里插入图片描述
    代码:和单链表差不多,不会就画一画,就写出来了

    //双向链表的插入与删除
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node{
    	int data;
    	struct node *prior; 
    	struct node *next;
    }Lnode,*Linklist; 
    
    //双向链表初始化,定义一个Linklist(Lnode*)型函数,由其带回头指针地址 
    Linklist InitList()
    {
    	Lnode *L;
    	L=(Lnode*)malloc(sizeof(Lnode));
    	if(L==NULL)
    	{
    		printf("申请空间失败\n");
    		exit(0);
    	}
    	L->next ==NULL;
    	L->prior==NULL; 
    	return L;
    }
    //尾插法创建双向链表
    void CreatList(Linklist L)
    {
    	Lnode *s,*r=L;
    	int i,n,num;
    	printf("请输入元素个数n:");
    	scanf("%d",&n);
    	for(i=0;i<n;i++)
    	{
    		printf("请输入第%d个数:",i+1);
    		scanf("%d",&num);
    		s=(Lnode*)malloc(sizeof(Lnode));
    		s->data =num;
    		s->prior=r;//与单链表相比就多了这一句 
    		r->next=s;
    		r=s;
    	}
    	r->next=NULL;
     } 
    //判断链表长度,与单链表相同 
    int LongthList(Linklist L)
    {
    	int i=0;
    	Lnode *p;
    	p=L->next;//带头结点的单链表,头结点按第0个节点算 
    	while(p!=NULL)
    	{
    		p=p->next;
    		i++;
    	}
    	return i;
     }
    //在链表的第i个位置之后插入元素x
    Linklist Insert(Linklist &L,int i,int x)
     {
     	int j;
     	Lnode *s,*p=L;
     	if(i<0||i>LongthList(L))
     	{
     		printf("插入位置错误\n");
     		return 0;
    	}
    	s=(Lnode*)malloc(sizeof(Lnode));
    	s->data=x;
    	for(j=0;j<i;j++)
    	//定位;若要在第i个元素之前插入,则j=1;(或者j=0,j<i-1;)少循环一次就可以了 
    	{
    	 	p=p->next;
    	}
    	//在i前插入 
        /*
        s->prior=p->prior;
    	p->prior->next=s;
    	s->next=p; 
    	p->prior=s;
    	*/
    	//在i之后 
    	p->next->prior = s;
        s->next = p->next;
        p->next = s;
        s->prior = p;
    }  
     //删除第i个节点,并释放
     int DeleteLnode(Linklist L,int i,int &x)
     {
     	Lnode *p=L;
     	int j=0;
     	if(i<0||i>LongthList(L))
     	{
     		printf("删除位置错误\n");
     		return 0;
    	}
    	//找到p,即要删除的元素 
     	while(p&&j<i)
     	{
     		p=p->next;
     		j++;
    	}
    	x=p->data;//如果不加取地址符,直接free
    	p->prior->next=p->next;
    	p->next->prior=p->prior; 
    	free(p); 
      } 
    
    //遍历链表,与遍历单链表相同 
    void PrintList(Linklist L)
    {
        Lnode *p;
        p=L->next;
     	while(p!=NULL)
     	{
     		printf("%d\n",p->data);
     		p=p->next;
    	}
    } 
     
    int main()
    {
    	Linklist S;int l,x; 
    	S=InitList();
    	CreatList(S);
    	l=LongthList(S);
    	printf("链表长为%d\n",l);
    	PrintList(S);
    	
    	Insert(S,2,4);
    	printf("插入新元素之后,遍历\n");
    	PrintList(S);
    	
    	DeleteLnode(S,3,x);
    	printf("%d已经删除\n",x); 
    	printf("删除元素之后,遍历\n");
    	PrintList(S);
    }
    

    运行结果
    在这里插入图片描述

    展开全文
  • 一 单链表 ...注意:此时理解双向链表的两个箭头: prenext都是从本节点指向别的节点的!!! pre: 从该节点指向它的前一个节点; next: 从该节点指向它的后一个节点 举例:a2.pre = a1; a2.next =

    一 单链表

    1.1 插入
    在这里插入图片描述
    实现在ai和ai+1中间插入e(固定套路):

    1. e —> ai+1
    2. ai—> e
      e.next = ai.next;
      ai.next = e;

    1.2 删除节点
    在这里插入图片描述
    实现ai的删除:
    ai-1.next = ai-1.next.next;

    二 双向链表

    注意:此时理解双向链表的两个箭头:
    pre和next都是从本节点指向别的节点的!!!
    pre: 从该节点指向它的前一个节点;
    next: 从该节点指向它的后一个节点

    举例:a2.pre = a1; a2.next = a3
    举例:a2.pre = a1; a2.next = a3

    2.1 插入在这里插入图片描述
    实现在ai和ai+1中间插入c:(记住!!固定顺序,套路)
    插入步骤:
    ①c----> ai+1;
    ②ai----> c
    ③c------>ai
    ④ai+1—>c

    代码实现 :
    c.next = ai.next;
    ai.next = c;
    c.pre = c.next.pre;
    c.next.pre = c;

    2.2 删除
    在这里插入图片描述
    实现:ai的删除
    删除步骤:
    ai-1----> ai+1
    ai+1---->ai-1

    实现代码:
    ai-1.next = ai-1.next.next;
    ai-1.next.pre = ai-1;

    展开全文
  • 双向链表定义如下: #include<stdio.h> #include<stdlib.h> typedef struct DLnode{ int data; struct DLnode *prev,*next; }DLnode,*DLinklist; 尾插法创建: void Create(DLinklist &...
  • 双向链表的节点插入和删除

    千次阅读 2019-04-26 00:49:33
    思路很简单,直接上代码 #include<iostream> using namespace std; typedef struct node { int val; struct node* next; struct node* pre; }node; void Init(node **head, node... (*head)=(node*)mal...
  • 1.双向链表插入操作。 代码示例: s->next=p; s->prior=p->prior; p->prior->next=s; p->prior=s; 2.双向链表删除操作 代码示例; p->prior->next=p->next; p->next->prior=...
  • 双向链表插入和删除

    万次阅读 多人点赞 2018-09-21 17:23:50
    双向链表插入 第一步:首先找到插入位置,节点 s 将插入到节点 p 之前 第二步:将节点 s 的前驱指向节点 p 的前驱,即 s-&gt;prior = p-&gt;prior; 第三步:将节点 p 的前驱的后继指向节点 s 即 p-&...
  • 双向链表——插入删除指定位置相同节点
  • 一、单链表链表 单链表:无法逆向检索,不方便 双链表:可进可退,存储密度更低 双链表的结构体定义 typedef struct DNode{ //定义双链表结点类型 ElemType data; //数据域 struct DNode *prior,*next; /...
  • 双向链表,创建,插入删除,销毁等,写的一个代码(包括详细的注释,初学者都看得懂),已经成功测试。及拿即用。
  • 1.双向链表的定义 typedef struct DulNode { ELemType data; struct DulNode * prior; //直接前驱指针 struct DulNode * next; //直接后继指针 } DulNode, * DuLinkList; 2.插入操作 假设将存储元素e的结点s...
  • 双向链表插入删除节点(详细图解+代码)

    万次阅读 多人点赞 2020-02-01 20:36:36
    双向链表 在单链表的基础上增加了前缀结点,一定程度上提升了查找元素的速度 在查找元素时,可以反向查找前缀结点 插入结点过程(分为4步) 这四个步骤的顺序可调整,但是必须要保证需要的链不断!!...
  • 双向链表插入删除(c++实现)

    千次阅读 2020-04-30 16:28:13
    目录前言双向链表插入节点实现代码双向链表删除节点实现代码整个项目的完整代码运行截图总结 前言 本篇文章主要接着上文的双向链表的创建与遍历(c++实现) ...
  • 双向链表结点的插入和删除算法

    万次阅读 多人点赞 2018-10-03 23:47:46
    双向链表插入删除 双向链表的结点定义 #define ElemType int //双向链表的存储结构 typedef struct DuLNode { ElemType data; DuLNode *prior; DuLNode *next; }DuLNode, *DuLinkList; 双向链表...
  • 主要介绍了Python单向链表和双向链表原理与用法,结合实例形式详细分析了单向链表与双向链表的概念、原理以及创建、添加、删除等相关操作技巧,需要的朋友可以参考下
  • C 链表 操作
  • 主要介绍了c++双向链表操作示例,包括创建双向链、删除双向链表双向链表中查找数据、插入数据等,需要的朋友可以参考下
  • 建立双向链表实现对双向链表插入删除操作1参考.pdf
  • 双向链表 建立和插入

    2021-11-21 19:38:25
    单链表有next指针,在查询下一个结点的时间复杂度为O(1),但在查询上一个结点...每次在插入删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难些;   2.相对于单向链表, 必然占用内存空间更...
  • 相信大家都明白 LinkedList 是基于双向链表而实现的,本篇文章主要讲解一下双向链表的实现,并且我们参考 LinkedList 自己实现...由于不必须按顺序存储,链表的插入和删除操作可以达到 O(1) 的复杂度。 而双向链表比单
  • 如何实现双向链表插入删除操作

    千次阅读 多人点赞 2017-08-20 11:07:44
    如何实现双向链表插入删除操作  循环单链表的出现,虽然能够实现从任一结点出发沿着链能找到其前驱结点,但是时间复杂度为O(N)。如果希望能从链表中快速确定某一个结点的前驱,另一个解决方法就是在单链表的每...
  • 给出了双向循环链表的定义、介绍,提供了双向循环链表的建立插入删除源代码
  • 【数据结构算法】③、双向链表和双向循环链表的实现、双向链表的创建-遍历-插入-删除-删除指定元素-查询指定元素、双向循环链表的创建-遍历-插入删除
  • 这是一个关于双链表的创建,删除插入操作
  • 双向链表的创建、插入删除

    千次阅读 2020-04-21 18:00:57
    **双向链表的创建、插入删除**创建一个双向链表的数据结构双向链表结构创建双链表并初始化正向遍历链表反向遍历链表双向链表的尾插双向链表的头插在指定位置插入节点删除指定节点主函数整体工程CMD运行结果 ...
  • 双向链表插入删除操作

    万次阅读 2017-11-11 18:01:28
    双向链表 循环单链表的出现,虽然能够实现从任一结点出发沿着链能找到其前驱结点,但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱,另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,533
精华内容 39,013
关键字:

双向链表的插入和删除

友情链接: GetPass100.rar