408考研-数据结构算法-双链表

最新推荐文章于 2023-10-31 08:22:42 发布
最新推荐文章于 2023-10-31 08:22:42 发布
阅读量340 收藏 1
点赞数
分类专栏： 数据结构和算法 文章标签： 考研 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mwq384807683/article/details/132613220
版权

双向链表的存储方式

双向链表跟链表差不多，只是它每个结点都含有两个链——一个指向下一结点，另一个指向前一结点。此外，它还能直接访问第一个和最后一个结点。

单链表只能向后操作，不可以向前操作。为了向前、向后操作方便，可以给每个元素附加两个指针域，一个存储前一个元素的地址，另一个存储下一个元素的地址。这种链表称为双向链表，如图

在这里插入图片描述
在这里插入图片描述
从图中可以看出，双向链表每个节点包含3个域：数据域和两个指针域。两个指针域分别存储前后两个元素节点的地址，即前驱和后继，因此指针指向的类型也是节点类型。

Node{
 int data;
 Node next;
 Node prev;
}

双向链表的基本操作

下面以带头节点的双向链表为例，讲解双向链表的初始化、创建、取值、查找、插入、删除操作。

1．初始化

双向链表初始化是指构建一个空表。先创建一个头节点，不存储数据，然后令其前后两个指针域均为空，如图

在这里插入图片描述
2．创建

创建双向链表也可以用头插法和尾插法。头插法创建的链表和输入顺序正好相反，称为逆序建表；尾插法创建的链表和输入顺序一致，称为正序建表。

头插法建双向链表的过程如下。

1）初始状态是指初始化后的空表，只有一个头节点，前后两个指针域均为空，如图

在这里插入图片描述
2）输入数据元素1，创建新节点，把元素1放入新节点数据域，如图

在这里插入图片描述
3）头插操作，插入头节点的后面，如图

在这里插入图片描述
4）输入数据元素2，创建新节点，把元素2放入新节点数据域，如图

在这里插入图片描述
5）头插操作，插入头节点的后面，如图
在这里插入图片描述
赋值解释

① s->next=L->next：将L节点后面的节点（后继）地址赋值给s节点的指针域，即s节点的next指针指向L的后继节点。

② L->next->prior=s：将s节点的地址赋值给L的后继节点的prior指针域，即L的后继节点的prior指针指向s节点。

③ s->prior=L：将L节点的地址赋值给s节点的prior指针域，即s节点的prior指针指向L节点。

④ L->next=s：将s节点的地址赋值给L节点的指针域，即L节点的next指针指向s节点。

注意：赋值语句的右侧是一个地址，左侧是一个节点的指针域。

修改指针顺序的原则：先修改没有指针标记的那一端

在这里插入图片描述
如果要插入节点的两端都有标记，例如再定义一个指针q指向第1个节点，那么先修改哪个指针都无所谓。实际上，只需要将④语句放在最后修改即可，①②③语句顺序无要求。

拉直链表之后，如图

在这里插入图片描述
6）继续依次输入数据元素3、4、5，头插法创建的双向链表如图
在这里插入图片描述
尾插法建双向链表和尾插法建单链表类似，需要有一个尾指针

/**

 * 双向链表节点类
 */
public class Node {
    int data; //数据节点
    Node prev; //前一个节点
    Node next; //后一个节点

    public Node(int data){
        this.data = data;
        prev = null;
        next = null;
    }
}

public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }
    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }
}    

public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        list.print();
   }
}

3．取值和查找

双向链表的取值、查找和单链表的一样

public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }
    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }


	//在链表中查找节点
	    public Node find(int data){
	        //从链表的头结点开始查找
	        Node current = head;
	        while (current != null){
	            //如果找到了节点数据与目标数据匹配，则返回该节点
	            if(current.data == data){
	                return current;
	            }
	            current = current.next; //否则，继续查找下一个节点
	        }
	        return null;
	    }
	}    


public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

//        list.print();

//        //查找节点
        Node foundNode = list.find(5);
        if(foundNode != null){
            System.out.println("找到了节点: "+ foundNode.data);
        }else{
            System.out.println("未找到节点");
        }
}

4．指定位置插入

单链表只有一个指针域，是向后操作的，不可以向前处理，因此单链表如果在第i个节点之前插入一个元素，就必须先找到第i-1个节点。在第i个节点之前插入一个元素相当于把新节点放在第i-1个节点之后。而双向链表不需要，因为有两个指针，可以向前后两个方向操作，直接找到第i个节点，就可以把新节点插入第i个节点之前。注意：这里假设第i个节点是存在的，如果第i个节点不存在，而第i-1个节点存在，还是需要找到第i-1个节点，将新节点插入第i-1个节点之后，如图

在这里插入图片描述
赋值解释

① p->prior->next=s:s节点的地址赋值给p的前驱节点的next指针域，即p的前驱的next指针指向s。

② s->prior=p->prior:p的前驱的地址赋值给s节点的prior指针域，即s节点的prior指针指向p的前驱。

③ s->next=p:p节点的地址赋值给s节点的next指针域，即s节点的next指针指向p节点。

④ p->prior=s:s节点的地址赋值给p节点的prior指针域，即p节点的prior指针指向s节点。

因为p的前驱无标记，一旦修改了p节点的prior指针，p的前驱就找不到了，因此，最后修改这个指针。实际上，只需要将④语句放在最后修改即可，①②③语句顺序无要求。

修改指针顺序的原则：先修改没有指针标记的那一端。

package com.maweiqi.DoublyLindked;

/**
 * 双向链表类
 */
public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }


    //在制定节点后面插入新节点
    public void insertAfter(Node node , int data){
        if(node == null){
            System.out.println("指定节点为空，插入失败");
            return;
        }

        //创建新节点
        Node newNode = new Node(data);
        //将新节点的前驱指向指定节点
        newNode.prev = node;
        //将新节点的后继指向指定节点的后继
        newNode.next = node.next;
        //如果指定节点有后继，则将后继节点的前驱指向新节点
        if(node.next != null){
            node.next.prev = newNode;
        }
        //将指定节点的后继指向新节点，完成插入操作
        node.next = newNode;
    }

    //在链表中查找节点
    public Node find(int data){
        //从链表的头结点开始查找
        Node current = head;
        while (current != null){
            //如果找到了节点数据与目标数据匹配，则返回该节点
            if(current.data == data){
                return current;
            }
            current = current.next; //否则，继续查找下一个节点
        }
        return null;
    }

  

    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }


}


package com.maweiqi.DoublyLindked;

/**

 */
public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

//        list.print();

//        //查找节点
        Node foundNode = list.find(5);
        if(foundNode != null){
            System.out.println("找到了节点: "+ foundNode.data);
        }else{
            System.out.println("未找到节点");
        }
//
//        //在指定节点后插入新节点
        list.insertAfter(foundNode,5);
        System.out.println("插入节点后的链表为:");
        list.print();

    }
}

5．删除

删除一个节点，实际上是把这个节点跳过去。在单向链表中，必须先找到第i-1个节点，才能把第i个节点跳过去。双向链表不必如此，只要直接找到第i个节点，然后修改指针即可，如图

在这里插入图片描述
p->prior->next=p->next：将p的后继节点的地址赋值给p的前驱节点的next指针域。即p的前驱节点的next指针指向p的后继节点。

注意：等号的右侧是节点的地址，等号的左侧是节点的指针域。

p->next->prior =p->prior：将p的前驱节点的地址赋值给p的后继节点的prior指针域，即p的后继节点的prior指针指向p的前驱节点。此项修改的前提是p的后继节点存在，如果不存在，则不需要此项修改。

这样就把p节点跳过去了，然后用delete p释放被删除节点的空间。删除节点修改指针没有顺序，先修改哪个都可以。

package com.maweiqi.DoublyLindked;

/**
 * 双向链表类
 */
public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }


    //在制定节点后面插入新节点
    public void insertAfter(Node node , int data){
        if(node == null){
            System.out.println("指定节点为空，插入失败");
            return;
        }

        //创建新节点
        Node newNode = new Node(data);
        //将新节点的前驱指向指定节点
        newNode.prev = node;
        //将新节点的后继指向指定节点的后继
        newNode.next = node.next;
        //如果指定节点有后继，则将后继节点的前驱指向新节点
        if(node.next != null){
            node.next.prev = newNode;
        }
        //将指定节点的后继指向新节点，完成插入操作
        node.next = newNode;
    }

    //在链表中查找节点
    public Node find(int data){
        //从链表的头结点开始查找
        Node current = head;
        while (current != null){
            //如果找到了节点数据与目标数据匹配，则返回该节点
            if(current.data == data){
                return current;
            }
            current = current.next; //否则，继续查找下一个节点
        }
        return null;
    }

    //从链表中删除节点
    public void delete(int data){
        //从链表的头结点开始查找
        Node current = head;
        while (current != null){
            //如果我们找到删除的节点
            if(current.data == data){
                //如果是非头节点
                if(current.prev != null){
                    //将要删除的节点的前驱的后继指向要删除节点的后继
                    current.prev.next = current.next;
                }else{
                    //如果是头节点,则更新头结点为要删除节点的后继
                    head = current.next;
                }
                if(current.next != null){
                    //将要删除节点的后继的前驱指向要删除节点的前驱
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next; //每次循环寻找下一个元素
        }
    }

    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }


}


package com.maweiqi.DoublyLindked;

/**

 */
public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

//        list.print();

//        //查找节点
//        Node foundNode = list.find(5);
//        if(foundNode != null){
//            System.out.println("找到了节点: "+ foundNode.data);
//        }else{
//            System.out.println("未找到节点");
//        }
//
//        //在指定节点后插入新节点
//        list.insertAfter(foundNode,5);
//        System.out.println("插入节点后的链表为:");
//        list.print();
//
//        //删除节点
        list.delete(2);
        System.out.println("删除节点后的链表");
        list.print();
    }
}
小怪兽打葫芦娃
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研408数据结构算法背诵
01-02
考研408数据结构算法背诵，4087中常用算法合集。包含常用的线性表、树、查找、排序的各种操作。（例如树，包含建树、遍历。。。）大部分是最基本的操作，对于应付考试应该是够了。还有整理的快排精简版，背诵更加...
数据结构算法背诵
digui4912的博客
03-17 1195
一、线性表 1.逆转顺序表中的所有元素 算法思想：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，……，依此类推。 View Code void Reverse(int A[], int n){ int i, t; for (i=0; i < n/2; i++) { t = A[i]; A[i] = A[n-...
数据结构与算法：408考研算法经典题目大总结（不断更新）
weixin_50690285的博客
08-24 8015
1. 合并两个有序顺序表为一个有序顺序表。2. 删除有序顺序表中所有值重复的元素。3. 顺序表中删除给定值之间的元素。1. 删除线性表中所有值为x的元素。一. 线性表——顺序表部分。
数据结构手写算法整理（考研）
永恒之蓝的博客
08-16 992
数据结构手写代码
【数据结构学习记录4】—— 双向链表
康娜喵的原创博客
10-28 281
双向链表一.简述二.思路图解2.1 节点2.2 链表结构2.3 链表的初始化2.4 链表的遍历2.5 链表的插入2.6 链表的删除2.7 链表的修改/查询 一.简述 双向链表的含义就是，一个节点除了下一个节点的地址，还要额外储存上一个节点的地址。 这样，假设你知道其中一个节点的地址的话，我们可以很方便的“向前”和“向后”遍历，而不是单链表的只能“向后”遍历。 所以，双链表比单链表更灵活，遍历的话，会花稍微更少的时间，但是会额外花费的储存空间。有些题可能比较离谱，会“进进退退”，所以单链表也无法完成这些功能。
考研心得：考研数据结构算法大全
热门推荐
PCGuo999的博客
04-22 1万+
本人考研的算法笔记，包含考研数据结构会涉及到的算法，全部掌握让你考研算法题稳稳拿下！！
考研408数据结构算法合集.zip
最新发布
12-29
数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 ...
竟成408-数据结构-部分试读
12-15
竟成408-数据结构-部分试读，考研计算机408，真题，模拟题，考研408必备用书。
408计算机考研 -- 计算机数据结构学习课件
12-24
众所周知计算机专业课考研分四门课程，数据结构，计算机网络，计算机组成原理，操作系统。本资料是计算机数据结构学习课件，是考研必备资料
王道考研-数据结构笔记
09-16
计算机考研专业课——数据结构学习笔记
贼全面的计算机考研数据结构算法题集合（408+自命题均可）
克克克克业业的学习记录
07-15 8045
一篇很全面的题集合！按考研大纲顺序排列，题源leetcode！
408数据结构考点总结
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
02-20 2386
定义：将算法中基本运算的执行次数的数量级作为时间复杂度，记为O(n)O(n)O(n)。计算原则计算方法定义：指算法运行过程中所使用的辅助空间的大小，记为S(n)S(n)S(n)。算法原地工作是指算法所需辅助空间是常量，即O(1)O(1)O(1)。定义：指用一组连续的存储单元，依次存储线性表中的各个元素，从而使得逻辑上相邻的元素在物理位置上也相邻，因此可以随机存取（根据首元素地址和元素序号）表中任何一个元素。基本操作结构插入若表长为nnn,下标从0开始，则在第iii位置插入元素eee，则从ana_nan​到a
考研数据结构算法题总结
热心上单小张的博客
10-18 4463
考研数据结构100天 Day1：在带头结点的单链表L中，删除所有值为X的节点，并释放其空间，假设值为的X节点不唯一，试编写算法以实现上述操作 void Del-X(LinkList &L,int x){ LNode *p=L->next; LNode *pre=L; LNode *q; while(p!=NULL){ if(p->data==x){ q=p; p=p->next; pre->next=p; free(q); }else{
数据结构算法题（考研）
小白白O快起来
01-03 4467
1、利用结点右孩子指针将一棵二叉树的叶子结点按照从左往右的顺序串成一个单链表（head初值为NULL,定义两个指针head和tail分别指向第一个叶子结点和最后一个叶子结点）？ void link(BTNode *p, BTNode *&head, BTNode *&tail) { if(p != NULL) { if(p-lchild==NULL && p->rchild==NULL) { if(head==NULL) //head刚开
南邮数据结构考研常用算法
拧发条鸟的博客
01-09 749
时间复杂度 O(|V|^2) 空间复杂度O(|V|)思路：找出入度为零的节点即可。图的深度优先遍历（非递归）
C语言巩固+数据结构考研算法总结1（顺序表＋单链表）
m0_59502137的博客
07-30 564
希望可以仔细理解每一道题的代码逻辑！
数据结构与算法（考研和期末）
hk3245393838的博客
10-31 117
算法(Algorithm)：就是定义良好的计算过程，他取一个或一组的值 输入，并产生一个或一组值作为输出。时间复杂度的概念：算法的时间复杂度是一个函数（数学函数），他描述了该算法的运行时间。一个算法所耗费的时间，算法中的基本操作的执行次数，为算法的时间复杂度。实际中我们计算的时间复杂度，其实并不一定计算准确的执行次数，而只需要大概率执行次数，那么我们可以用大O的渐进表示法（估算）。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法所需要的额外空间。N和M差不多大时 ->O(M)/O(N)
【考研必背】数据结构基本算法汇总 二叉树基础
qq_45596525的博客
10-27 358
考研数据结构 代码题必背 二叉树算法总结
408考研数据结构与算法之数组、链表、队列、栈知识点和算法详细教程（更新中）
唤醒手腕的博客
10-12 1847
静态顺序表（SeqList）基本概念概念：用一组地址连续的存储单元依次存储线性表的数据元素，这种存储结构的线性表称为顺序表。特点：逻辑上相邻的数据元素，物理次序也是相邻的。只要确定好了存储线性表的起始位置，线性表中任一数据元素都可以随机存取，所以线性表的顺序存储结构是一种随机存取的储存结构，因为高级语言中的数组类型也是有随机存取的特性，所以通常我们都使用数组来描述数据结构中的顺序储存结构，用动态分配的一维数组表示线性表。
考研数据结构经典算法
09-11
数据结构和算法是考研计算机科学与技术专业的重要内容之一，以下是一些经典的数据结构和算法，供你参考： 数据结构： 1. 数组 (Array) 2. 链表 (Linked List) 3. 栈 (Stack) 4. 队列 (Queue) 5. 树 (Tree) 6. 图 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值