单链表

头结点：单链表前面附设的一个结点 头指针：从头指针开始，指向第一个结点的指针 首节点：第一个包含元素的结点 单链表的存储结构： typedef struct Node { ElemType data ; struct Node * next ; } Node ; typedef struct Node * LinkList ; //定义LinkList 单链表的读取实现： /*获得链表第i个数据 操作结果：用e返回L中第i个元素的值*/ Status GetElem ( LinkList L , int i , ElemType * e ){ int j ; LinkList p ; //声明一个结点p p = L -> next ; //让p指向链表的第一个结点 j = 1 ; //j为计数器 while ( p && j < i ){ //*p不为空或者计数器j没有等于i时，循环继续 p = p -> next ; //p指向下一个结点 ++ j ; } if (! p || j > i ) return ERROR ; //第i个元素不存在 * e = p -> data ; //取第i个元素的数据 return OK ; } 单链表的插入实现： // 两步实现 s -> next = p -> next ; p -> next = s ; /*初始条件：顺序表已经存在，

c++单链表的创建及相关操作 # include "iostream" using namespace std ; //*********************************定义链表结点****************************** typedef int Elemtype ; struct LNode { Elemtype data ; LNode * next ; } ; typedef LNode * Linklist ; //***************************创建单链表*************************************** void input ( Elemtype * ep ) { cin >> * ep ; } void creatlink ( Linklist * L , int n , void ( * input ) ( Elemtype * ) ) { Linklist p , s ; p = * L = new LNode ; for ( ; n > 0 ; n -- ) { s = new LNode ; input ( & s -> data ) ; p -> next = s , p = s ; } p -> next = NULL ; } //********************

概述 链表：通过一组任意的存储单元来存储线性表的数据，这组存储单元可以是连续或不连续的。 每个节点包括: 1）数据域（当前节点的数值） 2）指针域（存储下一个节点的位置） 各个节点通过指针域串起来，像一条链子，所以叫“链表”。 单链表：每个节点只有一个指向直接后继节点的指针，所以叫“单链表”。 链表是一种常见的基础数据结构，它是一种线性表，但在内存中它并不是顺序存储的，它是以链式进行存储的，每一个节点里存放的是下一个节点的“指针”。在Java中的数据分为引用数据类型和基础数据类型，在Java中不存在指针的概念，但是对于链表而言的指针，指的就是引用数据类型的地址。 链表和数组都是线性的数据结构，对于数组而言其长度是固定的，由于在内存中其是连续的，因此更适合做查找与遍历，而链表在内存中是并不是顺序存储的，但是由于其是通过“指针”构成的，因此在插入、删除时比较数组更为的方便。 下面的代码通过内部类并结合递归的方式来实现了一个简单的用Java语言描述的链表的数据结构。 链表数据结构的定义 首先来看一下，链表数据结构的定义，代码如下： class NodeManager { private Node root; // 根节点 private int currentIndex = 0; // 节点的序号，每次操作从0开始 public void add(int data) {} public

《C语言》单链表――内存管理 Main.c MemList.h MemList.h Main.c # include "MemList.h" # define malloc MyMalloc void main ( ) { void * p1 = malloc ( 100 ) ; void * p2 = malloc ( 1002 ) ; void * p3 = malloc ( 5002 ) ; Show ( Memory ) ; # if 0 MyFree ( p1 ) ; MyFree ( p2 ) ; MyFree ( p3 ) ; # endif ClearMemory ( & Memory ) ; Show ( Memory ) ; system ( "pause" ) ; } MemList.h # pragma once # ifdef __cplusplus extern "C" { # endif # include <stdio.h> # include <stdlib.h> typedef struct MemInfo { void * P_MemAddr ; unsigned int MemSize ; } MemInfo ; typedef struct MemList { MemInfo * Mem ; struct MemList * P_Next

单链表是一种常见的数据结构，由一个个节点通过指针方式连接而成，每个节点由两部分组成：一是数据域，用于存储节点数据。二是指针域，用于存储下一个节点的地址。在Java中定义如下： public class Node { private Object data;//数据域 private Node next;//指针域 public Node(Object data){ this.data = data; } public Node(Object data,Node next){ this.data = data; this.next = next; } public Object getData() { return data; } public void setData(Object data) { this.data = data; } public Node getNext() { return next; } public void setNext(Node next) { this.next = next; } } public static Node reverseListNode(Node head){ //单链表为空或只有一个节点，直接返回原单链表 if (head == null || head.getNext() == null){ return head; } /

java单链表的实现及常见操作 首先简单介绍一下链表： 链表是一种最基本的数据结构，是一种线性表，是一种物理存储单元上不连续、非顺序的存储结构，但是逻辑上相连。 不需要连续的内存空间，这点和数组相反。链表分为单链表，双向链表以及循环链表之类的，这里仅讨论单链表，别问为什么，因为其他的我还没学到，hhhh～ ok，直接看代码： public class LinkedList { private Node head ; //头节点 //新增节点,在尾部新增 public void addHead ( Node node ) { //头节点是否存在 if ( head == null ) { head = node ; return ; } Node currentNode = head ; while ( currentNode . next != null ) { currentNode = currentNode . next ; } currentNode . next = node ; } //新增节点，在头部新增 public void addTail ( Node node ) { node . next = head ; head = node ; } //删除下标为k的节点 public boolean delete ( int k ) { if ( k < 0 ||

队列学习-单链表队列 1. 单链表队列定义 # define MAXSIZE 5 //队列的最大容量 typedef int DataType ; //int的别名(队列中的元素类型) //单链表(结点结构) typedef struct _QNode { DataType data ; //数据域(相当于 int data) struct _QNode * next ; //指针域 } QNode ; typedef QNode * QueuePtr ; //QNode的指针变量(QNode * 的别名) //队列 typedef struct Queue { int length ; //队列的长度 QueuePtr front ; //队头指针(相当于 QNode *front) QueuePtr rear ; //队尾指针(相当于 QNode *rear) } LinkQueue ; 2. 单链表队列初始化 //队列初始化,将队列初始化为空队列 void InitQueue ( LinkQueue * LQ ) { if ( ! LQ ) return ; LQ - > length = 0 ; LQ - > front = LQ - > rear = NULL ; //打队头和队尾指针同时置零 } 3. 判断单链表队列是否为空 //判断队列为空 int IsEmpty (

刷LeedCode时使用单链表频出错误，于是花时间总结了一下单链表的基本操作，把所写代码和详细注释贴在这里，以备后用。 #include <stdio.h> #include <stdlib.h> /*定义结构体链表节点： 该结构体有两个属性，一个是int类型的数据域data，另一个是这个结构体本身类型的指针next； 最后给这个结构体定义了一个别名Node，一个指针别名pNode； Node a; 就等价于struct NODE a; 都是声明一个struct NODE结构体类型的结构体变量a； pNode p; 就等价于struct NODE* p; 等价于Node* p; 声明一个struct NODE结构体类型的指针变量p；*/ typedef struct NODE{ int data; //数据域 struct NODE* next; //指针域，指向下一个节点 }Node, *pNode; //初始化一个链表节点 pNode init_node(int data) { pNode node = (Node*)malloc(sizeof(Node)); node->data = data; node->next = NULL; //next为空 return node; } //遍历链表，打印输出每个节点的信息 void traverse_linkList(pNode

单链表是一种常见的数据结构，由一个个节点通过指针方式连接而成，每个节点由两部分组成：一是数据域，用于存储节点数据。二是指针域，用于存储下一个节点的地址。 public class Node { private Object data;//数据域 private Node next;//指针域 public Node(Object data){ this.data = data; } public Node(Object data,Node next){ this.data = data; this.next = next; } public Object getData() { return data; } public void setData(Object data) { this.data = data; } public Node getNext() { return next; } public void setNext(Node next) { this.next = next; } } 所谓的单链表反转，就是把每个节点的指针域由原来的指向下一个节点变为指向其前一个节点。但由于单链表没有指向前一个节点的指针域，因此我们需要增加一个 指向前一个节点的指针pre ，用于存储每一个节点的前一个节点。此外，还需要 定义一个保存当前节点的指针cur，以及下一个节点的next

顺序表 python中的list和tuple就采用了顺序表的实现技术 tuple是不变的表，因此不支持改变其内部状态的任何操作 list是一种元素个数可变的线性表，可以加入和删除元素，在各种操作中维持已有元素的顺序 list对象无法设置容量的操作 if __name__ == '__main__': lt = list([1, 3, 2]) print(len(lt)) # 3 print(lt) # [1, 3, 2] # 元素顺序倒置 lt.reverse() print(lt) # [2, 3, 1] # 排序 lt.sort() print(lt) # [1, 2, 3] # 清除表中所有元素 lt.clear() print(len(lt)) # 0 单链表： 单链表头部添加元素： class LNode: """表节点""" # next_防止与标准函数next重名 def __init__(self, elem, next_=None): self.elem = elem self.next = next_ class LinkedListUnderflow(ValueError): pass class LList: """单链表""" def __init__(self): self._head = None def is_empty(self): ""