双向链表

基于双向循环链表实现的学生管理系统，包括初始化，插入，删除，查抄，保存，自动按照姓名排序功能，退出并保存功能。 实现思想是将程序的各个部分划分为三个层次。主函数为界面层，即客户端层；其中后缀为Student的一般是某个功能的调度函数，属于逻辑层的内容；在调度函数之下有相应的被调度的函数，也就是相应功能的实现函数，一般后缀名为Node，意思就是这个函数直接操作链表中的结点，可以简单的划分为实现层； 这样分层实现呢有利于代码维护和个功能之间对包含或者重叠功能的直接调用，从而提高代码重用度，而降低代码冗余，并且最低成的实现函数也可以用于别的项目中对双向循环链表的操作。 本次学生管理系统的实现是先用一个初始化文件函数将一些学生信息先存入磁盘中，然后用初始化函数读出到链表中进行各种操作，保存功能和退出功能可以将链表中操作了的内容，也就是内存中的内容写入磁盘中，其中对文件的操作采用二进制读写文件，读写对象为学生结构体。 以下是代码实现： #include<stdio.h> #include<stdlib.h> #include<string.h> #pragma warning (disable:4996) //定义学生信息结点 struct SNode{ char name[50]; char sex; int math; int chinese; int history; };

面试考察频率：⭐⭐⭐⭐ 什么是双向链表？ 在单向链表的前提下，增加了前驱指针，可以跟轻松的访问一个节点的前驱与后继节点 双向链表优缺点？ 优点：可以更便捷的访问一个节点的前驱与后继。 缺点：需要占用更多一些的内存。删除节点操作变得更加复杂。 如何来实现？ 构建思路如下 当前节点的next指向下一个节点。当前节点的pre指向上一个节点如此循环。 （注：头节点的pre始终指向最后一个节点，为了方便遍历，具体的在后面会讲） 。基本的样子就入下图所示（绘制粗糙0.0） 基础结构表示： public class LinkedListNode { public LinkedListNode pre ; public LinkedListNode next ; public int val ; } 初始化： private void InitList ( int c , LinkedListNode node ) { node = new LinkedListNode ( ) ; node . pre = node ; node . next = null ; node . val = - 1 ; } 就是创建一个头节点，该节点不进行数据记录只是为了方便操作。初始只有一个节点时pre要指向自己。 尾插入： public void Add_Back ( LinkedListNode node ,

①LinkedList简单介绍 是一个继承于AbstractSequentialList的双向链表。它可以被当成堆栈、队列或双端队列进行操作。 实现了List接口，能对它进行队列操作。 实现了Deque接口，能当作双端队列使用。 实现了Cloneable接口，覆盖了clone(),能克隆。 实现了java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。 是非同步的 ②LinkedList构造函数 // 默认构造函数 LinkedList() // 创建一个LinkedList，保护Collection中的全部元素。 LinkedList(Collection<? extends E> collection) ③AbstractSequentialList简介 介绍一下AbstractSequentialList。毕竟，LinkedList是AbstractSequentialList的子类。 1）AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数。这些接口都是随机访问List的，LinkedList是双向链表

双向链表和我们前面讲的单链表最大的区别就是多了一个前驱结点 我们第一步还是定义Sequence接口，它里面都是双向链表一些基本的操作，增删查改等 Sequence接口定义如下： public interface Sequence { /** * 向线性表中添加元素 * @param date 要存储的元素 */ void add(Object date); /** * 线性表中删除元素 * @param index 要删除的元素下标 * @return 是否删除成功 */ boolean remove(int index); /** * 在线性表中查找指定下标的元素 * @param index 要查找的索引 * @return */ Object get(int index); /** * 判断线性表中是否有指定元素 * @param data 要查找的元素内容 * @return */ boolean contains(Object data); /** * 修改线性表中指定索引的内容 * @param index 要修改元素下标 * @param newData 修改后的内容 * @return */ Object set(int index,Object newData); /** * 返回当前线性表的长度 * @return */ int size(); /** *

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } } */ ///？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？ public class Solution { TreeNode head = null; TreeNode realHead = null; public TreeNode Convert(TreeNode pRootOfTree) { ConvertSub(pRootOfTree); return realHead; } private void ConvertSub(TreeNode pRootOfTree) { if(pRootOfTree==null) return; ConvertSub(pRootOfTree.left); if (head == null) { head = pRootOfTree; realHead = pRootOfTree; } else { head.right = pRootOfTree;

设一带头结点的双向循环链表表示的线性表：L =（a1, a2, …… , an） 请写出一个时间复杂度为O(n)的算法，将L改造为：L =（a1, a2, ……, an-1, an, an-1, ……, a2, a1） 测试输入： 1 2 3 4 5 -1 测试输出： Link next:5,4,3,2,1, Link prior:1,2,3,4,5, NewL next:5,4,3,2,1,2,3,4,5, NewL prior:5,4,3,2,1,2,3,4,5, # include <stdio.h> # include <stdlib.h> typedef int ElemType ; typedef struct DuLNode { ElemType data ; // 数据域 struct DuLNode * prior ; // 指向前驱的指针域 struct DuLNode * next ; // 指向后继的指针域 } DuLNode , * DuLinkList ; // 函数原型 void out_next ( DuLinkList ) ; void out_prior ( DuLinkList ) ; void rcopy ( DuLinkList ) ; //这是你要编写的函数 // 函数定义 void out_next ( DuLinkList DHead

题目在这里 ’代码如下： # include <iostream> using namespace std ; const int N = 100010 ; int l [ N ] , r [ N ] , idx , e [ N ] ; void init ( ) { idx = 2 ; r [ 0 ] = 1 ; l [ 1 ] = 0 ; } void dele ( int k ) { l [ r [ k ] ] = l [ k ] ; r [ l [ k ] ] = r [ k ] ; } void add ( int k , int x ) { e [ idx ] = x ; l [ r [ k ] ] = idx ; r [ idx ] = r [ k ] ; l [ idx ] = k ; r [ k ] = idx ; idx ++ ; } int main ( ) { init ( ) ; int n ; cin >> n ; while ( n -- ) { int k , x ; string a ; cin >> a ; if ( a == "L" ) { cin >> x ; add ( 0 , x ) ; } if ( a == "D" ) { cin >> k ; dele ( k + 1 ) ; } if ( a == "R" ) { cin >> x

#include #include using namespace std; typedef struct List { int date; struct List next; struct List front; }List; void Init_List(List &Head)//创建双向链表头 { Head = (List )malloc(sizeof(List)); if (Head == NULL) return; Head->date = NULL; Head->front = NULL; Head->next = NULL; } void Set_List(List* &Head,int length)//创建链表 { if (Head == NULL) return; for (int i = 0;i < length;i++) { List tmp = (List )malloc(sizeof(List)); if (tmp == NULL) return; if (Head->next == NULL) { tmp->date = i; tmp->next = Head->next; Head->next = tmp; tmp->front = Head; } else { tmp->date = i; tmp->next = Head->next; Head-

#include<iostream> using namespace std; const int N = 100010; int val[N],le[N],ri[N]; int idx; int n,m; //初始化 ri[0] 和 le[1]分别为双链表的左右端点 void init(){ ri[0] = 1, le[1] = 0; idx = 2; } //在节点k的右侧插入一个数 void add(int k,int x){ val[idx] = x; ri[idx] = ri[k]; le[idx] = k; le[ri[k]] = idx; ri[k] = idx; idx++; } //删除节点k void del(int k){ le[ ri[k] ] = le[k]; ri[ le[k] ] = ri[k]; } int main(){ cin>>n; string ch; init(); int k,x; while(n--){ cin>>ch; if(ch == "L"){ cin>>x; add(0,x); } if(ch == "R"){ cin>>x; add(le[1],x); } if(ch == "D"){ cin>>x; del(x+1); } if(ch == "IL"){ cin>>k>>x; add(le[k+1],x); } if(ch

题目描述： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表，要求不能创建任何新的结点，只能调整结点的指向。例如： 思路： 由于转换后的双向链表中的结点的顺序与二叉树的中序遍历的顺序相同，所以可以对二叉树的中序遍历算法进行修改，通过在中序遍历的过程中修改结点的指向来转换成一个排序的双向链表。实现思路如下图所示： 假设当前遍历的结点为 root，root的左子树已经被转换为双向链表（如下图(1)所示），使用两个变量 pHead 与 pEnd 分别指向链表的首结点与尾结点。那么在遍历 root 结点的时候，只需要将 root 结点的 lchild (左) 指向 pEnd，把 pEnd 的 rchild (右) 指向 root；此时 root 结点就被加入到双向链表里了，所以 root 变成了双向链表的尾结点。对于所有的结点都可以通过同样的方法来修改结点的指向。所以可以采用递归的方法来求解。在求解的时候需要特别注意递归的结束条件以及边界情况(l例如双向链表为空的时候)。 算法性能分析： 此方法与二叉树的中序遍历有着相同的时间复杂度O(n)； 此外，这种方法只用了两个额外的变量 pHead 与 pEnd 来记录双向链表的首尾结点，所以空间复杂度为O(1)； 代码实现： #!/usr/bin/env python3 # -*- coding: utf-8 -*- # @Time :