devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

栈和队列oj详解_ojpq

作者：笔触狂放9 | 2024-05-25 06:37:43

赞

踩

ojpq

 

目录

一、有效的括号

二、用栈实现队列

三、用队列实现栈

四、设计循环队列

①数组的方式：

②链表的方式


 

声明：因为本次oj详解是用纯C来写的，所以说我们本期的题目需要手写栈和队列，为了代码的可读性增强也为了减少冗余，博主直接把本期oj题需要导入的栈和队列源码放在下面，在写题目的时候就不导入了，感谢谅解。

1、栈

  1. typedef int STDataType;
  2.  
  3. typedef struct Stack
  4. {
  5. 	STDataType* a;
  6. 	int top;
  7. 	int capacity;
  8. }ST;
  9. void StackInit(ST* ps);
  10. void StackDestory(ST* ps);
  11. void StackPush(ST* ps,STDataType x);
  12. void StackPop(ST* ps);
  13. STDataType StackTop(ST* ps);
  14. bool StackEmpty(ST* ps);
  15. int StackSize(ST* ps);
  16.  
  17. void StackInit(ST* ps)
  18. {
  19. 	assert(ps);
  20. 	ps->a = NULL;
  21. 	ps->top = ps->capacity = 0;
  22. }
  23. void StackDestory(ST* ps)
  24. {
  25. 	assert(ps);
  26. 	free(ps->a);
  27. 	ps->a = NULL;
  28. 	ps->capacity = ps->top = 0;
  29. }
  30. void StackPush(ST* ps, STDataType x)
  31. {
  32. 	assert(ps);
  33. 	//只能尾插
  34. 	if (ps->top==ps->capacity)
  35. 	{
  36. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  37. 		STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
  38. 		if (tmp == NULL)
  39. 		{
  40. 			perror("realloc fail");
  41. 			exit(-1);
  42. 		}
  43. 		ps->a = tmp;
  44. 		ps->capacity = newCapacity;
  45. 	}
  46. 	ps->a[ps->top] = x;
  47. 	ps->top++;
  48. }
  49. void StackPop(ST* ps)
  50. {
  51. 	assert(ps);
  52. 	assert(!StackEmpty(ps));
  53. 	--ps->top;
  54. }
  55. STDataType StackTop(ST* ps)
  56. {
  57. 	assert(ps);
  58. 	assert(!StackEmpty(ps));
  59. 	return ps->a[ps->top - 1];
  60. }
  61. bool StackEmpty(ST* ps)
  62. {
  63. 	assert(ps);
  64. 	return ps->top == 0;
  65. }
  66. int StackSize(ST* ps)
  67. {
  68. 	assert(ps);
  69. 	return ps->top;
  70. }

2、队列

  1. typedef int QDataType;
  2. typedef struct QueueNode
  3. {
  4. 	struct QueueNode* next;
  5. 	QDataType data;
  6. }QNode;
  7.  
  8. typedef struct Queue
  9. {
  10. 	QNode* head;
  11. 	QNode* tail;
  12. 	int size;
  13. }Queue;
  14.  
  15. void QueueInit(Queue* pq);//把头和尾放到结构体里面就可以不用二级指针而对头和尾进行修改
  16. void QueueDestory(Queue* pq);
  17. void QueuePush(Queue* pq, QDataType x);
  18. void QueuePop(Queue* pq);
  19.  
  20. QDataType QueueFront(Queue* pq);
  21. QDataType QueueBack(Queue* pq);
  22. bool QueueEmpty(Queue* pq);
  23. int QueueSize(Queue* pq);
  24.  
  25.  
  26.  
  27. void QueueInit(Queue* pq)
  28. {
  29. 	assert(pq);
  30. 	pq->head = pq->tail = NULL;
  31. 	pq->size = 0;
  32. }
  33. void QueueDestory(Queue* pq)
  34. {
  35. 	assert(pq);
  36. 	QNode* cur = pq->head;
  37. 	while (cur)
  38. 	{
  39. 		QNode* del = cur;
  40. 		cur = cur->next;
  41. 		free(del);
  42. 	}
  43. 	pq->head = pq->tail = NULL;
  44. 	pq->size = 0;
  45. }
  46. void QueuePush(Queue* pq, QDataType x)
  47. {
  48. 	assert(pq);
  49. 	QNode* newnode = (QNode*)malloc(sizeof(QNode));
  50. 	if (newnode == NULL)
  51. 	{
  52. 		perror("malloc fail");
  53. 		exit(-1);
  54. 	}
  55. 	else
  56. 	{
  57. 		newnode->next = NULL;
  58. 		newnode->data = x;
  59. 	}
  60. 	if (pq->tail == NULL)
  61. 	{
  62. 		pq->head = pq->tail = newnode;
  63. 	}
  64. 	else
  65. 	{
  66. 		pq->tail->next = newnode;
  67. 		pq->tail = newnode;
  68. 	}
  69. 	pq->size++;
  70. }
  71. void QueuePop(Queue* pq)
  72. {
  73. 	assert(pq);
  74. 	assert(!QueueEmpty(pq));
  75. 	//head为null,tail为野指针
  76. 	if (pq->head->next == NULL)
  77. 	{
  78. 		free(pq->head);
  79. 		pq->head = pq->tail = NULL;
  80. 	}
  81. 	else
  82. 	{
  83. 		QNode* del = pq->head;
  84. 		pq->head = pq->head->next;
  85. 		free(del);
  86. 		del = NULL;
  87. 	}
  88. 	pq->size--;
  89. }
  90.  
  91. QDataType QueueFront(Queue* pq)
  92. {
  93. 	assert(pq);
  94. 	assert(!QueueEmpty(pq));
  95. 	return pq->head->data;
  96. }
  97.  
  98. QDataType QueueBack(Queue* pq)
  99. {
  100. 	assert(pq);
  101. 	assert(!QueueEmpty(pq));
  102. 	return pq->tail->data;
  103. }
  104. bool QueueEmpty(Queue* pq)
  105. {
  106. 	assert(pq);
  107. 	return pq->head == NULL && pq->tail == NULL;
  108. }
  109. int QueueSize(Queue* pq)
  110. {
  111. 	assert(pq);
  112. 	//求size
  113. 	/*QNode* cur = pq->head;
  114. 	int size = 0;
  115. 	while (cur)
  116. 	{
  117. 		++size;
  118. 		cur = cur->next;
  119. 	}
  120. 	return size;*/
  121. 	return pq->size;
  122. }
  123.

注意：博主放的栈和队列的源码所存储的数据类型都是int类型，对于不同的题目有不同的数据类型要求需要更改注意一下。

一、有效的括号

来源：leetcode：20、有效的括号

1、题目概述

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例：

输入：s = "()"
输出：true

输入：s = "()[]{}"
输出：true
输入：s = "(]"
输出：false

2、题目分析

总共有三对括号："()" "[]" "{}"。

如果刚开始入的是右括号，显然不可能凑成一对括号，如果是左括号我们需要去存下来，如果下一个还是左括号显然不可能凑成一对括号，如果是右括号则要判断是否配对。

总结：

1、我们需要一个容器去存左括号，然后当遇到右括号我们需要去拿这个容器的最后一个元素去和它配对。

2、比较适合的就是用栈去存左括号，遇到右括号就取出栈顶元素去配对。

3、代码编译

  1. bool isValid(char * s)
  2. {
  3.     ST STMatch;
  4.     StackInit(&STMatch);
  5.     while(*s)
  6.     {
  7.         if(StackEmpty(&STMatch))//空的时候右括号绝对不能遇到
  8.         {
  9.              if(*s!='('&&*s!='{'&&*s!='[')
  10.             {
  11.             return false;
  12.             }
  13.             else
  14.             {
  15.                 StackPush(&STMatch,*s);
  16.             }
  17.         }
  18.         //非空
  19.         else
  20.         {
  21.             if(*s==']'||*s==')'||*s=='}')
  22.             {
  23.                 //右括号就要取栈顶去配对，然后出栈
  24.                 if(*s==']'&&StackTop(&STMatch)=='['
  25.                 ||*s=='}'&&StackTop(&STMatch)=='{'
  26.                 ||*s==')'&&StackTop(&STMatch)=='(')
  27.                 {
  28.                     StackPop(&STMatch);
  29.                 }
  30.                 else
  31.                 {
  32.                     return false;
  33.                 }
  34.             }
  35.             else
  36.             StackPush(&STMatch,*s);
  37.         }
  38.         s++;
  39.     }
  40.     bool flag=StackEmpty(&STMatch);
  41.     StackDestory(&STMatch);
  42.     return flag;
  43.  
  44.  
  45. }

用C来写的话，比较麻烦的是我们需要去导入一个栈，理清思路这道题目并不困难。还有一点注意这里的数据类型是字符而不是整型，所以如果用博主上面的栈的话注意更改数据类型。

二、用栈实现队列

来源：leetcode：232、用栈实现队列

1、题目概述

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

这道题目就是让我们用两个后入先出的栈实现一个先入先出的队列。

2、题目分析

拿到这道题目不要慌，我们破解这道题目的关键在于明白栈的基本功能和接口有哪些，以及要我们实现的队列的接口有哪些。

题目要求我们用两个栈去实现队列的接口：

1、void myQueuePush(MyQueue* obj, int x) ：实现插入的功能，也就是尾插

2、int myQueuePop(MyQueue* obj) ：先入先出，pop出头。

3、int myQueuePeek(MyQueue* obj) ：返回队列开头的元素，也就是找到队列的头

4、bool myQueueEmpty(MyQueue* obj) ：判空

图示解析：

 

1、 左边是博主列出的栈的基本功能，其他功能的实现都好说，主要是如何实现队列的先入先出，这是一个问题，因为栈是后入先出的，只能出尾，所以我们需要借助另一个栈去倒数据，即把一个栈的数据Pop出，然后再push入另一个栈，这时原来的头就变成了尾，再pop出栈顶元素，就实现了先入先出。

2、那么解决了先入先出的问题，我们还有一个问题需要解决，就是在push的时候入哪个栈，以及每次Pop是否都需要去倒数据？

简单分析一下，我们就会发现，我们可以设定一个栈，栈1用于push，一个栈，栈2用于pop最优，只要push就直接入栈1，当栈2没有空的时候，我们是不需要去把栈1的数据倒入栈2的，当栈2空的时候，再去倒栈1入栈2.

3、代码编译

  1. typedef struct 
  2. {
  3.     ST st1;
  4.     ST st2;
  5. } MyQueue;
  6.  
  7.  
  8. MyQueue* myQueueCreate() 
  9. {
  10.     MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
  11.     StackInit(&obj->st1);
  12.     StackInit(&obj->st2);
  13.     return obj;
  14. }
  15.  
  16. void myQueuePush(MyQueue* obj, int x) 
  17. {
  18.     //因为它出栈时并不是找不空的出栈，所以这里指定一个栈用于push，一个栈用于pop
  19.     StackPush(&obj->st1,x);
  20. }
  21.  
  22. int myQueuePop(MyQueue* obj) 
  23. {
  24.     if(StackEmpty(&obj->st2))
  25.     {
  26.         while(!StackEmpty(&obj->st1))
  27.         {
  28.             StackPush(&obj->st2,StackTop(&obj->st1));
  29.             StackPop(&obj->st1);
  30.         }
  31.     }
  32.     int front=StackTop(&obj->st2);
  33.     StackPop(&obj->st2);
  34.     return front;
  35. }
  36.  
  37. int myQueuePeek(MyQueue* obj) 
  38. {
  39.     if(StackEmpty(&obj->st2))
  40.     {
  41.         while(!StackEmpty(&obj->st1))
  42.         {
  43.             StackPush(&obj->st2,StackTop(&obj->st1));
  44.             StackPop(&obj->st1);
  45.         }
  46.     }
  47.     return StackTop(&obj->st2);
  48. }
  49.  
  50. bool myQueueEmpty(MyQueue* obj) 
  51. {
  52.     return StackEmpty(&obj->st1)&&StackEmpty(&obj->st2);
  53. }
  54.  
  55. void myQueueFree(MyQueue* obj) 
  56. {
  57.     StackDestory(&obj->st1);
  58.     StackDestory(&obj->st2);
  59.     free(obj);
  60.     obj=NULL;
  61. }

三、用队列实现栈

来源：leetcode：225、用队列实现栈

1、题目概述

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

2、题目分析

这道题目和上面的用栈实现队列是姊妹题。也比较类似，我们需要注意的是Pop的实现，即先入先出的队列如何实现后入先出的问题。

 因为队列先入先出，也就是尾入头出，我们要想让尾先出，就要把尾调整到头，怎么调整呢？我们借助一个队列把它的元素一个一个pop出，再push到另一个队列中去，直到只剩一个元素，这时尾来到了头，拿到这个元素再pop就实现了后入先出。

需要注意的是，另一个队列的元素仍是原本的元素，有序的，只不过少了尾，而另一个队列已经空了。

所以每次push的时候我们需要去找非空的队列，每次pop的时候我们需要把非空的队列倒到另一个队列中。

 3、代码编译

  1. typedef struct 
  2. {
  3.     Queue q1;
  4.     Queue q2;
  5.  
  6. } MyStack;
  7.  
  8.  
  9. MyStack* myStackCreate() 
  10. {
  11.    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
  12.    QueueInit(&obj->q1);
  13.    QueueInit(&obj->q2);
  14.    return obj;
  15. }
  16.  
  17. void myStackPush(MyStack* obj, int x) 
  18. {
  19.     if(!QueueEmpty(&obj->q1))
  20.     {
  21.         QueuePush(&obj->q1,x);
  22.     }
  23.     else
  24.     {
  25.         QueuePush(&obj->q2,x);
  26.     }
  27.  
  28. }
  29.  
  30. int myStackPop(MyStack* obj) 
  31. {
  32.     Queue*  Empty=&obj->q1;
  33.     Queue* NonEmpty=&obj->q2;
  34.     if(!QueueEmpty(&obj->q1))//如果q1不空
  35.     {
  36.         Empty=&obj->q2;
  37.         NonEmpty=&obj->q1;
  38.     }
  39.     while(QueueSize(NonEmpty)>1)
  40.     {
  41.         QueuePush(Empty,QueueFront(NonEmpty));
  42.         //往空里面压
  43.         QueuePop(NonEmpty);
  44.     }
  45.     int tail=QueueFront(NonEmpty);//后入先出
  46.     QueuePop(NonEmpty);
  47.     return tail;
  48. }
  49.  
  50. int myStackTop(MyStack* obj) 
  51. {
  52.     if(!QueueEmpty(&obj->q1))
  53.         return QueueBack(&obj->q1);
  54.     else
  55.         return QueueBack(&obj->q2);
  56. }
  57.  
  58. bool myStackEmpty(MyStack* obj) 
  59. {
  60.     return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
  61. }
  62.  
  63. void myStackFree(MyStack* obj) 
  64. {
  65.     QueueDestory(&obj->q1);
  66.     QueueDestory(&obj->q2);
  67.     free(obj);
  68.     obj=NULL;
  69. }

1、因为用栈实现队列，和用队列实现栈很类似，它们在判空的时候都需要判断两个栈或者两个队列是否为空。

2、用队列实现栈这道题目在实现Pop这个接口的时候，博主利用了一点小技巧，因为这个接口需要先判断哪个队列非空，对于非空的队列倒数据，如果是队列1非空，需要倒数据，如果队列2非空，需要倒数据，而这么编写代码是比较冗余重复的，博主这里就假设队列1为空，队列2非空，如果实际相反再进行调换，这样转换成非空和空队列操作，代码量大大减少。

四、设计循环队列

来源：leetcode：622、设计循环队列

1、题目描述

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

2、题目分析

循环队列，本质还是实现一个队列，实现这个队列的基本几个接口，只不过这个队列是有限长度的，并且这个队列是循环的。

 这个循环在我们的理解大概是个环状，这里要怎么实现呢？用数组还是链表来实现呢？乍一看，这个循环队列和我们循环链表的概念很相似，是否链表就优于数组呢？别着急，我们再来细品一下：

我们先图解看一下使用链表和数组的图解：

 

结合这个图解，博主把每个接口需要的功能先大致分析一下：

1、Front(队首) 和Rear(队尾)这两个接口比较简单，就是直接使用两个指针指向队首和队尾，然后返回就可以了。队首两种方式都可以，队尾的话如果是数组，直接找下标就能找到队尾的下标然后返回，（不过这一点还有一点细节需要注意，如果没发现还是会出错，博主后面还会说）但是链表，因为链表的尾指针指向的位置是没有填数据的，也就是队尾的next，所以需要遍历找到尾指针的上一个位置，比较麻烦。

2、enQueue(value): 向循环队列插入一个元素，这个函数也比较简单，就是尾插，我们设有一个尾指针，插入然后++就可以了。数组唯一需要注意的就是

3、deQueue(value)：从循环队列删除一个元素，队列先入先出的功能，就是头删，头指针++。

4、isEmpty(): 检查循环队列是否为空。isFull():判断循环队列是否满了，这两个问题比较有趣

 分析一下我们就会发现，判空和判满无法区分，怎么解决呢？

我们创造性的提出了一种方式，类似于链表中增加一个哨兵位，我们多加一个位置，但是不填数据。比如：

 我们发现，当我们加了一个位置的时候，这时候为空和为满的情况是不相同的，这时候是可以区分开两种情况的，说明增加一个位置确实是可行的，而且这个位置是不断变化的。

上面的图是数组的情况，这里需要处理的细节就是back如何和front建立联系，以及当back在尾的时候怎么回到头，这一点也和博主上面说的插入的数组需要考虑的情况相符合。这些都是数组需要考虑的。我们再来设想链表的话，似乎就不需要考虑这些问题，只需要back的next指针是否为front即可。

3、代码编译

博主用数组和链表都实现了一遍，都可以，各有利弊吧。

①数组的方式：

  1. //数组去写
  2. typedef struct 
  3. {
  4.     int*a;
  5.     int front;
  6.     int back;
  7.     int capacity;
  8.  
  9. } MyCircularQueue;
  10. bool myCircularQueueIsFull(MyCircularQueue* obj);
  11. bool myCircularQueueIsEmpty(MyCircularQueue* obj);
  12.  
  13. MyCircularQueue* myCircularQueueCreate(int k) 
  14. {
  15.     MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
  16.     int* tmp=(int*)malloc(sizeof(int)*(k+1));
  17.     if(tmp==NULL)
  18.     {
  19.         perror("malloc fail");
  20.         return NULL;
  21.     }
  22.     else
  23.     {
  24.         obj->a=tmp;
  25.         obj->front=obj->back=0;
  26.         obj->capacity=k+1;
  27.     }
  28.     return obj;
  29. }
  30.  
  31. bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
  32. {
  33.     //插入元素
  34.     if(!myCircularQueueIsFull(obj))
  35.     {
  36.         //如果没满
  37.         obj->a[obj->back]=value;
  38.         obj->back++;
  39.         obj->back%=obj->capacity;//主要是要考虑到到了最后一个位置
  40.         return true;
  41.     }
  42.     else
  43.     {
  44.         return false;
  45.     }
  46.  
  47. }
  48.  
  49. bool myCircularQueueDeQueue(MyCircularQueue* obj) 
  50. {
  51.     if(!myCircularQueueIsEmpty(obj))
  52.     {
  53.         //没空才能删
  54.         obj->a[obj->front]=0;//虽然没啥意义
  55.         obj->front++;
  56.         obj->front%=obj->capacity;
  57.         return true;
  58.     }
  59.     else
  60.     {
  61.         return false;
  62.     }
  63. }
  64.  
  65. int myCircularQueueFront(MyCircularQueue* obj) 
  66. {
  67.     if(!myCircularQueueIsEmpty(obj))
  68.         return obj->a[obj->front];
  69.     else
  70.         return -1;
  71. }
  72.  
  73. int myCircularQueueRear(MyCircularQueue* obj) 
  74. {
  75.      if(!myCircularQueueIsEmpty(obj))
  76.         return obj->a[(obj->back-1+obj->capacity)%obj->capacity];//要考虑到back在第一个的情况
  77.     else
  78.         return -1;
  79. }
  80.  
  81. bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
  82. {
  83.     return obj->front==obj->back;
  84. }
  85.  
  86. bool myCircularQueueIsFull(MyCircularQueue* obj) 
  87. {
  88.     return (obj->back+1)%obj->capacity==obj->front;
  89. }
  90.  
  91. void myCircularQueueFree(MyCircularQueue* obj) 
  92. {
  93.     free(obj->a);
  94.     obj->front=obj->back=0;
  95.     obj->capacity=0;
  96.     free(obj);
  97.     obj=NULL;
  98.  
  99. }

理解了上面的图解，用数组的方式来实现代码还是比较简单的，不过需要注意颇多的细节，

博主认为这些地方都是不易想到，需要注意的，而且可以说是点睛之笔。

1、第一个%主要是，当最后一个位置被填之后，如何回到队首，这个%可以说十分巧妙，直接回到队首。

 

 

 

2、第二个front也是同理，删到队尾的时候怎么回到队首。

 

 

 

 3、而第三个找队尾元素，这样设计的原因是要考虑到，如果back在队首，那么队尾肯定是最后一个位置的元素，怎么找到呢？这种方式可以说很好的解决了这个问题。

 

 

 

4、而第四个则是为了解决判满的问题，当满的时候。back的下一个位置就是front，这样设计是为了解决back在最后一个位置，而front在第一个位置的情况。

 

 

这样操作不仅解决特殊情况，而且具有普适性，十分实用，但也不易被想到。

②链表的方式

  1. typedef struct MCQueue
  2. {
  3.     int data;
  4.     struct MCQueue* next;
  5. } MCQueue;
  6. typedef struct
  7. {
  8.     MCQueue* front;
  9.     MCQueue* back;
  10. }MyCircularQueue;
  11.  
  12. bool myCircularQueueIsEmpty(MyCircularQueue* obj);
  13. bool myCircularQueueIsFull(MyCircularQueue* obj);
  14. MCQueue* BuyNewnode()
  15. {
  16.      MCQueue* newnode=(MCQueue*)malloc(sizeof(MCQueue));
  17.     if(newnode==NULL)
  18.     {
  19.         perror("malloc fail");
  20.         exit(-1);
  21.     }
  22.     else
  23.     {
  24.         newnode->next=NULL;
  25.     }
  26.     return newnode;
  27. }
  28.  
  29. MyCircularQueue* myCircularQueueCreate(int k) 
  30. {
  31.     //初始化
  32.     MCQueue* CQueue=NULL;
  33.      MCQueue* tail=NULL;
  34.     int N=k+1;//多加一个位置
  35.     //构建链表
  36.     while(N--)
  37.     {
  38.          MCQueue* newnode=BuyNewnode();
  39.          if(CQueue==NULL)
  40.          {
  41.              CQueue=newnode;
  42.              //方便找尾
  43.              tail=CQueue;
  44.          }
  45.          else
  46.          {
  47.              //头插的一种方式
  48.              newnode->next=CQueue;
  49.              CQueue=newnode;
  50.          }
  51.          tail->next=CQueue;
  52.          //链接起来
  53.     }
  54.     MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
  55.     obj->front=CQueue;
  56.     obj->back=CQueue;
  57.     return obj;
  58. }
  59.  
  60. bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
  61. {
  62.     if(!myCircularQueueIsFull(obj))
  63.     {
  64.         obj->back->data=value;
  65.         //指向下一个
  66.         obj->back=obj->back->next;
  67.         return true;
  68.     }
  69.     else
  70.         return false;
  71.  
  72.  
  73. }
  74.  
  75. bool myCircularQueueDeQueue(MyCircularQueue* obj) 
  76. {
  77.     //删的前提是没空
  78.     if(!myCircularQueueIsEmpty(obj))
  79.     {
  80.         obj->front=obj->front->next;
  81.         return true;
  82.     }
  83.     else
  84.         return false;
  85.  
  86. }
  87.  
  88. int myCircularQueueFront(MyCircularQueue* obj) 
  89. {
  90.     if(!myCircularQueueIsEmpty(obj))
  91.     {
  92.         return obj->front->data;
  93.     }
  94.     else
  95.     {
  96.         return -1;
  97.     }
  98.  
  99. }
  100.  
  101. int myCircularQueueRear(MyCircularQueue* obj) 
  102. {
  103.     //这个比较麻烦，需要找到back的前一个
  104.     if(!myCircularQueueIsEmpty(obj))
  105.     {
  106.         MCQueue* cur=obj->front;
  107.         while(cur->next!=obj->back)
  108.         {
  109.             cur=cur->next;
  110.         }
  111.         //找到前一个
  112.         return cur->data;
  113.     }
  114.     else
  115.         return -1;
  116.  
  117. }
  118.  
  119. bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
  120. {
  121.     return obj->front==obj->back;
  122. }
  123.  
  124. bool myCircularQueueIsFull(MyCircularQueue* obj) 
  125. {
  126.     //如何判满？
  127.     return obj->back->next==obj->front;
  128. }
  129.  
  130. void myCircularQueueFree(MyCircularQueue* obj) 
  131. {
  132.     MCQueue* cur=obj->front->next;
  133.     while(cur!=obj->front)
  134.     {
  135.         MCQueue* next=cur->next;
  136.         free(cur);
  137.         cur=next;
  138.     }
  139.     free(cur);
  140.     free(obj);
  141. }

从逻辑上来讲，链表更符合循环链表的逻辑，不过用链表比较怪怪的，但是构建就比较麻烦，需要一个一个链表去开创，还要去链接起来，更古怪的是这些链表什么数据也不放，不太合习惯，而且用链表来实现比较恶心的有两点：

1、链表的初始化和链接，以及开创之后，因为这是一个环形链表，而且没有下标，那么哪个是头，哪个是尾需要你自己去定义。

2、在找尾的时候，需要再次遍历一下，时间复杂度是0(N)。

优点就是：

不需要去特殊处理数组需要处理的那些情况，初始化之后写起来很顺。

好了，本期的oj分享就到这里了，希望大家可以养成良好的编程习惯，多画图分析，争取一次过，而不是修修补补。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/620934
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号