精华内容
下载资源
问答
  • 循环链表表示队列

    千次阅读 2021-10-24 11:52:41
    假设以带头结点的循环链表表示列队,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的置空队、判队空、入队出队等算法。 该算法使用循环链表表示列队。 在算法中只设一个指向队尾元素的指针...

    假设以带头结点的循环链表表示列队,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的置空队、判队空、入队和出队等算法。


    该算法使用循环链表表示列队。

    在算法中只设一个指向队尾元素的指针rear,在进行置空队,判队空等操作之前先将队列初始化;

    置空队则是将队尾指针指向头结点;

    入队则是在队尾插入元素,即在尾结点处插入元素,先申请一个新结点,再将新结点初始化并链入队列最后将尾指针移至新结点;

    出队是先判断队列是否为空,不为空则继续接下来的出队操作。


    该算法设计了个函数:

    函数initQueue()用来初始化列队;

    函数emptyQueue()用来将队置空;

    函数enqueue()用来将元素链入列队;

    函数delqueue()用来将元素出队;


    算法流程图

     

    源代码

    /*********
    date:2021-10-23
    author:sy
    version:1.0
    Description: 以带头结点的循环链表表示列队,只设一个指针指向队尾元素(不设头指针) 
    ***********/
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef int elemType;
    /*定义结点类型*/ 
    typedef struct queuenode
    {
    	elemType data;
    	struct queuenode *next;
    }queuenode,*LinkQueue;
    
    typedef struct
    {
    	LinkQueue rear;  //只设一个指向队尾元素的指针 
    	int length;
    }sqqueue;
    
    /*初始化列队*/
    void initQueue(sqqueue &Q)
    {
    	Q.rear=(LinkQueue)malloc(sizeof(Q));
    	Q.rear->next=Q.rear;
    }
    /*置空队*/ 
    int emptyQueue(sqqueue &Q)
    {
    	if(Q.rear->next==Q.rear)  //将队尾指针指向头结点 
    		return 1;
    	else
    		return 0;
    }
    /*入队*/
    int enqueue(sqqueue &Q,elemType e)
    {   /*在尾结点处插入元素*/
    	LinkQueue p;
    	p=(LinkQueue)malloc(sizeof(Q));  //申请新结点 
    	if(!p)
    		return 0;
    	/*初始化新结点并链入*/ 
    	p->data=e;
    	p->next=Q.rear->next;
    	Q.rear->next=p;
    	Q.rear=p;  //将尾指针移至新结点 
    	return 1;
    }
    /*出队*/
    int delqueue(sqqueue &Q,elemType &e)
    {
    	LinkQueue p;
    	if(Q.rear->next==Q.rear)
    		return 0;  //若队列为空返回0
    	p=Q.rear->next->next;  //循环链表队列队尾指针下一结点(也即头结点)的下一结点(即队头指针)赋给p 
    	e=p->data;  // 保存结点中的数据 
    	Q.rear->next->next=p->next;  //摘下结点p 
    	free(p);   //释放被删结点 
    	return 1;
    }
    
    int main()
    {
    	sqqueue m;
    	elemType num;
    	initQueue(m);
    	if(emptyQueue(m))
    		printf("该队列目前为空!\n");
    	else
    		printf("该队列不为空!\n");
    	for(int i=1;i<=10;i++)
    		{
    			if(enqueue(m,i))
    			printf("元素%d成功入列!\n",i);
    		}
    	printf("\n\n");
    	for(int j=1;j<=10;j++)
    		{
    			if(delqueue(m,num))
    			printf("元素%d成功出列!\n",num);
    		}
    	if(emptyQueue(m))
    		printf("该队列目前为空!\n");
    	else
    		printf("该队列不为空!\n");
    	return 0;
    }
    

    函数delete()与函数free()函数 均可用来释放节点

    展开全文
  • C语言实现 循环链表实现队列

    多人点赞 2021-03-18 21:40:24
    C语言实现 循环链表实现队列 #include <stdio.h> #include "stdlib.h" typedef struct queuenode{ int data; struct queuenode * next; }QueueNode; typedef struct { QueueNode * rear; }...

    C语言实现 循环链表实现队列

      • #include <stdio.h>
        #include "stdlib.h"
        typedef struct  queuenode{
        	int data;
        	struct queuenode * next;
        	
        }QueueNode;
        typedef  struct {
        	QueueNode * rear;
        	
        }linkQueue;
        void insertNode(linkQueue *Q,int x){
        	QueueNode * p = malloc(sizeof(QueueNode));
        	p->data = x;
        	p ->next = Q ->rear ->next;
        	Q->rear ->next  = p;
        	Q ->rear = p;
        	
        }
        int emptyQueue(linkQueue *Q){
        	return Q->rear ->next->next == Q->rear->next;
        }
        linkQueue * initQueue(void){
        	linkQueue * L = malloc(sizeof(linkQueue));
        	QueueNode * node = malloc(sizeof(QueueNode));
        	//注意malloc一个node然后再让link的指向
        	L->rear = node;
        	L->rear->next = L->rear;//指向自己
        	return L;
        }
        void printqueue(linkQueue * Q){
        	QueueNode *p;
        	p = Q->rear ->next->next;
        	//从节点开始遍历,p=p->next 指向,那个表头节点空节点时,刚好遍历完最后一个标为节点,rear,所以应该在rear->next时候停下
        	while (p!=Q->rear->next) {
        		printf("%d ",p->data);
        		p=p->next;
        	}
        	
        }
        int deleteQueue(linkQueue *Q){
        	QueueNode *p;
        	p = Q ->rear ->next->next;
        	//先判空,然后从表头删除,指向表头节点的位置
        	if(emptyQueue(Q)){
        		printf("link NULL");
        		return -1;
        	}
        	int x = p->data;
        	
        	if(p == Q->rear){
        		//最后一个节点
        		//要移动指针和rear的位置,使rear的位置停留在表头节点(空节点),指向也好指向自己
        		Q->rear = Q ->rear->next;
        		Q->rear->next = Q->rear;
        	}else {
        		Q ->rear ->next->next = p->next;
        		//改变指向,确定了新的头节点
        	}
        	
        	free(p);
        	return x;
        }
        int main(int argc, char *argv[]) {
        	linkQueue * Q;
        	Q = initQueue();
        	insertNode(Q, 1);
        	insertNode(Q, 2);
        	insertNode(Q, 3);
        	deleteQueue(Q);
        	printqueue(Q);
        }
        
      • 插入结构

      • 代码注意点,首先是初始化,和整体的循环链表,循环链表因为首位相连,可以在O(1)时间访问头节点和尾巴节点,选用头节点要找尾节点就要遍历整个链表,选用尾节点作为链表的开始就可以轻易的找到头节点

      • 尾节点和头节点之间有一个不存储数据的节点,这个概念能方便在“表头节点”,就是图中标记null节点的左边或右边进行插入和删除,向下图的四个图一样,中间的“表头节点”这个概念节点是不存储数据的,rear和head中间隔开了一个表头节点,队列在head删除,在rear后插入
        1

    展开全文
  • 循环链表实现队列

    2021-04-11 22:51:04
    // 新结点的指针域指向头结点,构成循环 rear->next = p; // 加入队尾 rear = p; // 队尾指针后移 return 1; } // 出队函数 bool DeQueue(QueuePtr &Q, QElemType &e) { QueuePtr p; if(Q->next==Q) // 队空 return...

    AC代码:

    #include <iostream>
    #define Status int
    #define QElemType int
    using namespace std;
    
    // 链队结点数据结构
    typedef struct QNode
    {
        QElemType data; // 数据域
        struct QNode *next; // 指针域
    }QNode, *QueuePtr;
    struct QNode *rear;  // 队尾指针
    //*****************************基本操作函数******************************//
    //初始化函数
    Status InitQueue(QueuePtr &Q)
    {
        Q = new QNode;  // 生成新结点Q作为头结点,队尾指针指向它
        rear = Q;
        Q->next = Q;     // 头结点指向自己,队列为空
    }
    // 入队函数
    Status EnQueue(QueuePtr &Q, QElemType e)
    {
        QNode *p;
        p = new QNode; // 生成新结点
        p->data = e;  // 赋值
        p->next = Q;   // 新结点的指针域指向头结点,构成循环
        rear->next = p; // 加入队尾
        rear = p; // 队尾指针后移
        return 1;
    }
    // 出队函数
    bool DeQueue(QueuePtr &Q, QElemType &e)
    {
        QueuePtr p;
        if(Q->next==Q) // 队空
            return false;
        e = Q->next->data;
        p = Q->next; // 复制指针,一会释放空间
        Q->next = p->next;
        if(rear==p)
            rear = Q;   // 如果最后一个元素出队,尾指针指向头结点
        free(p);
        return true;
    }
    //取队头函数
    bool GetHead(QueuePtr &Q, QElemType &e)
    {
        if(Q->next==Q) // 队空
            return false;
        e = Q->next->data;
        return true;
    }
    // **********************************功能实现函数************************//
    // 入队功能函数,调用EnQueue函数
    void EnterQueue(QueuePtr &Q)
    {
        int n; QElemType e; int flag;
        cout<<"请输入入队元素个数(>=1):"<<endl;
        cin>>n;
        for(int i = 0; i<n; i++)
        {
            cout<<"请输入第"<<i+1<<"个元素的值:"<<endl;
            cin>>e;
            flag = EnQueue(Q, e);
            if(flag)
                cout<<e<<"已入队"<<endl;
        }
    }
    // 出队功能函数 调用DeQueue函数
    void OutQueue(QueuePtr &Q)
    {
        int n; QElemType e; int flag;
        cout<<"请输入出队元素个数(>=1):"<<endl;
        cin>>n;
        for(int i = 0; i<n; i++)
        {
            flag = DeQueue(Q, e);
            if(flag)
                cout<<e<<"已出队"<<endl;
            else
            {
                cout<<"队列已空!"<<endl;
                break;
            }
        }
    }
    // 取队头功能函数 调用GetHead函数
    void GetHeadOfQueue(QueuePtr &Q)
    {
        QElemType e; bool flag;
        flag = GetHead(Q, e);
        if(flag)
            cout<<"队头元素为:"<<e<<endl;
        else
            cout<<"队列已空!"<<endl;
    }
    // 菜单
    void menu()
    {
        cout<<"********1.入队            2.出队********"<<endl;
        cout<<"********3.取队头       4.退出********"<<endl;
    }
    int main()
    {
        QueuePtr Q;
        int choice;
        InitQueue(Q);
        while(1)
        {
            menu();
            cout<<"请输入菜单序号:"<<endl;
            cin>>choice;
            if(choice==4)
                break;
            switch(choice)
            {
                case 1: EnterQueue(Q); break;
                case 2: OutQueue(Q); break;
                case 3: GetHeadOfQueue(Q); break;
                default : cout<<"输入错误!"<<endl;
            }
        }
        return 0;
    }
    
    
    展开全文
  • 双向链表的基本操作与单链表基本一样,除了插入删除的时候需要更改两个指针变量,需要注意的是修改的顺序很重要,插入如图3-14-5,删除如图3-14-6。由于引入了prev指针,insertdelete函数中都有一些特殊情况需要...

    一、双向链表(double linked list)是在单链表的每个结点中,再设置一个指向其前驱结点的指针域。双向链表的基本操作与单链表基本一样,除了插入和删除的时候需要更改两个指针变量,需要注意的是修改的顺序很重要,插入如图3-14-5,删除如图3-14-6。

    b9ad5e9a3029b7bc89cc94366d9076f3.png

    0bf5532ec11cb19c3a1b4765bc3dc6a4.png

    由于引入了prev指针,insert和delete函数中都有一些特殊情况需要用特殊的代码处理,不能和一般情况用同样的代码处理,这非常不爽,如果在表头和表尾各添加一个Sentinel节点(这两个节点只用于界定表头和表尾,不保存数据),就可以把这些特殊情况都转化为一般情况了。如图26.6

    dadb9d71319ee7faba78a24fa31a73b1.png

    在《队列的链式存储结构》中我们使用单链表实现队列的尾进头出,下面我们演示使用双向链表实现队列的头进尾出。

    参考:《Linux C编程 一站式学习》

    C++ Code

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    /*************************************************************************

    > File Name: doublylinkedlist.h

    > Author: Simba

    > Mail: dameng34@163.com

    > Created Time: Fri 28 Dec 2012 08:02:35 PM CST

    ************************************************************************/

    #ifndef DOUBLYLINKEDLIST_H

    #define DOUBLYLINKEDLIST_H

    typedef

    struct node

    {

    unsigned

    char item;

    struct node *prev;

    struct node *next;

    } node;

    typedef node *link;

    link make_node(

    unsigned

    char item);

    void free_node(link p);

    link search(

    unsigned

    char key);

    void insert(link p);

    void deletep(link p);

    void traverse(

    void (*visit)(link));

    void destroy(

    void);

    void enqueue(link p);

    link dequeue(

    void);

    #endif

    C++ Code

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

    80

    81

    82

    83

    84

    85

    86

    87

    88

    89

    90

    91

    92

    93

    94

    95

    96

    97

    98

    99

    100

    101

    102

    103

    104

    /*************************************************************************

    > File Name: doublylinkedlist.c

    > Author: Simba

    > Mail: dameng34@163.com

    > Created Time: Fri 28 Dec 2012 08:07:21 PM CST

    ************************************************************************/

    #include

    #include

    #include

    "doublylinkedlist.h"

    node tailsentinel;

    node headsentinel = {

    0,

    NULL, &tailsentinel};

    node tailsentinel = {

    0, &headsentinel,

    NULL};

    static link head = &headsentinel;

    static link tail = &tailsentinel;

    link make_node(

    unsigned

    char item)

    {

    link p =  malloc(

    sizeof(node));

    p->item = item;

    p->prev = p->next =

    NULL;

    printf(

    "make node from Item %d\n", item);

    return p;

    }

    void free_node(link p)

    {

    printf(

    "free node ...\n");

    free(p);

    }

    link search(

    unsigned

    char key)

    {

    link p;

    printf(

    "search by key %d\n", key);

    for (p = head->next; p != tail; p = p->next)

    if (p->item == key)

    return p;

    return

    NULL;

    }

    void insert(link p)

    {

    printf(

    "insert node from head ...\n");

    p->next = head->next;

    head->next->prev = p;

    head->next = p;

    p->prev = head;

    }

    void deletep(link p)

    {

    printf(

    "delete node from ptr ...\n");

    p->prev->next = p->next;

    p->next->prev = p->prev;

    }

    void traverse(

    void (*visit)(link))

    {

    link p;

    printf(

    "doublylinkedlist traverse ...\n");

    for (p = head->next; p != tail; p = p->next)

    visit(p);

    printf(

    "\n");

    }

    void destroy(

    void)

    {

    link q, p = head->next;

    printf(

    "destory doublylinkedlist ...\n");

    head->next = tail;

    tail->prev = head;

    while (p != tail)

    {

    q = p;

    p = p->next;

    free_node(q);

    }

    }

    void enqueue(link p)

    {

    printf(

    "enqueue from head ...\n");

    insert(p);

    }

    link dequeue(

    void)

    {

    if (tail->prev == head)

    return

    NULL;

    else

    {

    link p = tail->prev;

    printf(

    "dequeue from tail ...\n");

    deletep(p);

    return p;

    }

    }

    C++ Code

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    /*************************************************************************

    > File Name: main2.c

    > Author: Simba

    > Mail: dameng34@163.com

    > Created Time: Fri 28 Dec 2012 08:18:57 PM CST

    ************************************************************************/

    #include

    #include

    "doublylinkedlist.h"

    void print_item(link p)

    {

    printf(

    "print item %d \n", p->item);

    }

    int main(

    void)

    {

    link p = make_node(

    10);

    insert(p);

    p = make_node(

    5);

    insert(p);

    p = make_node(

    90);

    insert(p);

    p = search(

    5);

    deletep(p);

    free_node(p);

    traverse(print_item);

    destroy();

    printf(

    "..................\n");

    p = make_node(

    100);

    enqueue(p);

    p = make_node(

    200);

    enqueue(p);

    p = make_node(

    250);

    enqueue(p);

    while ((p = dequeue()))

    {

    print_item(p);

    free_node(p);

    }

    return

    0;

    }

    输出为:

    48fa802e97c39bfe605deee7b856acd3.png

    解决的error:

    关于错误 error C2275: “XXX”: 将此类型用作表达式非法

    在移植c++代码到c的时候,经常会出现一个奇怪的错误, error C2275: “XXX”: 将此类型用作表达式非法,这个错误是由于c的编译器要求将变量的定义放在所有函数调用语句之前,而c++没有这样的要求造成的。解决的办法就是把变量的定义全部放在变量的生存块的开始。

    ------------------------------------------------------------------------------------------------------------------------------------

    二、将单链表中终端结点的指针端由空指针改为指向头结点,就使整个单链表形成一个环,这种头尾相接的单链表就称为单循环链表,简称循环链表(circular linked list)。如下图所示。

    d0c0007c4392fd388533384ee0567959.png

    其实循环链表和单链表的主要差异就在于循环的判断条件上,原来是判断p->next是否为空,现在则是p->next不等于头结点,则循环未结束。

    我们在《队列的顺序存储结构(循环队列)》中使用数组实现了环形队列,我们还要“假想”它是首尾相接的,而如果基于链表实现环形队列,我们本来就可以用指针串成首尾相接的。把上面的程序改成双向环形链表也非常简单,只需要将

    把doublylinkedlist.c中的

    node tailsentinel;

    node headsentinel = {0, NULL, &tailsentinel};

    node tailsentinel = {0, &headsentinel, NULL};

    static link head = &headsentinel;

    static link tail = &tailsentinel;

    改成:

    node sentinel = {0, &sentinel, &sentinel};

    static link head = &sentinel;

    再把doublylinkedlist.c中所有的tail替换成head即可,相当于把head和tail合二为一了。如图26.7:

    a5e08c7c1578c37fb94f15557bb1caea.png

    展开全文
  • 循环链表存储实现循环队列类 """ class CircularQueue: """Queue implementation using circularly linked list for storage.""" class _Node: """lightweight, nonpublick class for storing a singly ...
  • 观察单向链表单向循环链表的区别: 显然,循环链表和普通链表的区别在于,尾节点的next指针指向了头节点。而对于这条指向的维护也只在于addremove方法,因此循环链表仅仅在这个方法上有所不同。(普通链表的...
  • 若是不清楚链表的结构,该篇文章不适合观看,这里只做文字说明,没有链表结构的图示
  • 以不带头结点的循环链表表示队列,并且队列只设一个队尾指针,不设头指针,实现入队出队操作并验证操作(队列); 设计 底层为带有尾指针的单循环链表,在我的程序中,头结点不带元素,它的存在仅是为了便利循环...
  • 队列 循环链表表示队列 假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),请完成下列任务: 1: 队列初始化,成功返回真,否则返回假: bool init_queue(LinkQueue *LQ); 2...
  • 基于循环链表队列的基本操作 描述 用带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(不设头指针)。实现该队列的入队出队以及判断队列是否为空操作。 输入 多组数据,每组数据有两行。第一行为两...
  • 在前面两篇博客中,我分别使用了静态数组动态数组来模拟循环队列。...当我们使用数组的时候创建循环队列是为了节省存储空间,而来到链表中时,每一个节点都是动态申请释放的,不会造成空间的浪费,所以就不需要...
  • 双向链表 class Node(object ): def __init__(self,item): self.elem = item self.next = None self.prev = None class DoubleLinkList(object): '''单链表''' def __init__(self,node = None): self.__...
  • 约瑟夫问题描述  编号为1 到 N 的 N 个士兵围坐在一起形成一个圆圈,从编号为 1 的士兵开始依次报数(1,2,3…这样依次报),数到 m 的 士兵会被杀死出列,之后的... 本文分别用循环链表队列、递归函数的方式实现。
  • 说明 相比Linux内核链表宿主结构可有多个链表结构的优点,本函数集侧重封装性易用性,而灵活性效率有所降低. 可基于该函数集方便地构造栈或队列集. 本函数集暂未考虑并发保护. 一 概念 链表是一种物理存储单元上非...
  • 什么是双向循环链表在了解双向循环链表之前,如果对链表还没有一个清晰的概念,建议你看看单链表单向循环链表,这有利于你更好的理解下面的内容。(废话有点多[逃]相比单链表,双向循环链表是一个更加复杂的结构。...
  • 1、单项循环列表单向循环链表是单链表的另一种形式,其结构特点是链表中最后...2、单向循环链表和单链表相同,循环单链表也有带头结点结构不带头结点结构两种,带头结点的循环单链表实现插入删除操作时,算法实...
  • 假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),请完成下列任务: 1: 队列初始化,成功返回真,否则返回假:bool init_queue(LinkQueue *LQ); 2: 入队列,成功返回真,...
  • 假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的置空队、判空对、入队出队等算法。 步骤: 1.算法分析: 要写出置空队、判空队、入队出队的算法之前...
  • 循环链表作为队列,设有队尾指针,带头节点,入队与出队的算法 */ typedef struct Node{ int info;//数据信息 Node *NextNode;//下个节点的指针 } Node,*LNode; typedef struct { int lenth;//数据长度 LNode ...
  • 前言 先复习一下几种数据结构吧。 链表,就是一个个结点,用指针的方式来连接起来,因为py的语言特点,我们只需要将next赋值为下一个...循环队列,之前是list实现的,这里我们用一次node,结构基于循环链表。 双向链
  • #ifndef _LIST_H#define _LIST_Hstruct listrec;typedef struct listrec *list;list listinit( );void print( list L );void insert( list L, int abc );void deleteall( list L );#endifstruct listrec{int elem;...
  • 假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点,试编写相应的初始化队列、判空队、入队出队算法。(队中元素均为整数)
  • 双向链表、循环链表和静态链表 上节我们实现了单链表的基本操作,在实现过程中可以发现,单链表的逻辑关系仅由一个单向指针表示,指向其后继结点,使得单链表只能从头向后地顺序遍历。这个缺点让单链表使用起来不太...
  • 队列和循环队列

    2021-10-27 14:47:45
    2、编写函数,实现循环队列的基本操作。 创建两个指针(命名为 top rear)分别指向链表中队列的队头元素队尾元素 typedef struct QNode { /* 结点类型*/ QElemType data; struct QNode *next; } ...
  • 注意看带头结点的双向链表,他的时间效率,不管哪种操作,都是O(1),实际上是利用了空间提高时间
  • 队列--双向循环链表实现 通过对线性表的插入删除操作在异端完成 比如: 头插入对应的是尾删除 尾插入对应的是头删除 出数据的一端是队头,进数据的是队尾 栈: 先进后出 队列: 先进先出 */ // ...
  • 循环链表和约瑟夫环循环链表的实现单链表只有向后结点,当单链表的尾链表不指向NULL,而是指向头结点时候,形成了一个环,成为单循环链表,简称循环链表。当它是空表,向后结点就只想了自己,这也是它与单链表的主要...
  • 以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(不设头指针), 实现队列的初始化,入队出队。 */ #include <stdio.h> #include <malloc.h> #define N 10 typedef struct node{...
  • 双向循环队列

    2021-05-16 00:10:39
    最近一段时间,自己虽然不是什么大佬,但是教一下大一的链表还是可以的,因为女朋友考试没考好,手糊了一个双向循环队列,想帮助让不太懂指针的人理解一下指针的作用 双向循环队列 主要包括这几个元素,我们的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,871
精华内容 43,948
关键字:

循环链表和循环队列