数据结构--leetcode环形链表II、栈和队列

实验室里哈啤酒

已于 2022-01-23 13:18:13 修改

阅读量640

点赞数

分类专栏：数据结构学习文章标签：数据结构栈队列

于 2022-01-03 22:24:39 首次发布

本文链接：https://blog.csdn.net/weixin_47754029/article/details/122290395

版权

数据结构学习专栏收录该内容

5 篇文章 1 订阅

订阅专栏

继上，求环的入口点：

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *slow=head,*fast=head;
    while(fast && fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;

        if(slow==fast)
        {
            struct ListNode*meet=slow;
            while(head!=meet)
            {
                head=head->next;
                meet=meet->next;
            }
            return meet;
        }
    }
    return NULL;
}

总结前面所学链表和顺序表的区别连续：

顺序表：

空间连续，可进行随机访问。但插入删除操作困难，增容的代价较大。

链表：

物理空间不连续，插入删除方便，增容方便，但不支持随机访问。

栈与队列

一、栈

栈是一种收限定的线性表，既将线性表的插入和删除固定在表的一端进行。

允许进行插入删除操作的一端称为栈顶，另一端为栈底。栈顶是动态变化的，有一个指针来指示栈顶的位置。

值得注意的是，栈里的操作就像电梯一样，每次新进来的元素都会称为新的栈顶，先进后出，后进先出LIFO。

例题1：

分析：可能是进一个出一个，比如1先进，1再出，2再进，2再出这种情况，不可思维定势。

答案：C

1.重要顺序栈操作：

（1）入栈：

当栈为空时，栈底为-1，1入栈，做top+1操作，栈顶变为top=0，234依次入栈时，栈顶变为top=3

C代码为：

//入栈
//元素val进栈，A为数组，top为栈顶的位置
int push(int *a, int top, int val)
{
	a[++top] = val;//先++top,再将val给a[++top]
	return top;
}

（2）出栈：

出栈时，做top-1操作：

//出栈
int pop(int *a, int top)
{
	if (top == -1)
	{
		printf("NULL Stack");
		return -1;
	}
	else
	{
		printf("pop val:%d\n", a[top]);
		top--;
		return top;
	}
}

综合起来：

#include<stdio.h>


//入栈
//元素val进栈，A为数组，top为栈顶的位置
int push(int *a, int top, int val)
{
	a[++top] = val;//先++top,再将val给a[++top]
	return top;
}

//出栈
int pop(int *a, int top)
{
	if (top == -1)
	{
		printf("NULL Stack");
		return -1;
	}
	else
	{
		printf("pop val:%d\n", a[top]);
		top--;
		return top;
	}
}

int main()
{
	int a[10];
	int top = -1;
	top = push(a, top, 1);
	top = push(a, top, 2);
	top = push(a, top, 3);
	top = push(a, top, 4);
	top = pop(a, top);
	top = pop(a, top);
	top = pop(a, top);
	top = pop(a, top);
	top = pop(a, top);
	getchar();
	return 0;
}

运行结果：

2.重要链栈基本操作

链栈：用链表实现栈的存取结构。

插入数据元素时，需要从链表的头部插入，弹出数据元素时，需要从删除链表的首元结点。

（1）入栈：

//定义链表中的节点结构
typedef struct LineStack
{
	int data;
	struct LineStack *next;
}LineStack;

//stack表示链栈，val表示入栈元素
LineStack *push(LineStack *stack, int val)
{
	//创建存储新元素的节点
	LineStack *line = (LineStack*)malloc(sizeof(LineStack));
	line->data = val;
	line->next = stack;
	stack = line;
	return stack;
}

（2）出栈

//出栈
LineStack *pop(LineStack *stack)
{
	if (stack != NULL)
	{
		//声明一个新的指针将被移除元素存起来，以便后续操作
		LineStack *p = stack;
		stack = stack->next;
		printf("出栈元素：%d\n", p->data);

		if (stack != NULL)
		{
			printf("新栈顶为：%d\n", stack->data);
		}
		else
		{
			printf("空栈\n");
		}
		free(p);
	}

	else
	{
		printf("空栈");
		return stack;
	}
	return stack;
}

总的代码及运行结果：

#include<stdio.h>
#include<stdlib.h>


//定义链表中的节点结构
typedef struct LineStack
{
	int data;
	struct LineStack *next;
}LineStack;

//入栈
//stack表示链栈，val表示入栈元素
LineStack *push(LineStack *stack, int val)
{
	//创建存储新元素的节点
	LineStack *line = (LineStack*)malloc(sizeof(LineStack));
	line->data = val;
	line->next = stack;
	stack = line;
	return stack;
}

//出栈
LineStack *pop(LineStack *stack)
{
	if (stack != NULL)
	{
		//声明一个新的指针将被移除元素存起来，以便后续操作
		LineStack *p = stack;
		stack = stack->next;
		printf("出栈元素：%d\n", p->data);

		if (stack != NULL)
		{
			printf("新栈顶为：%d\n", stack->data);
		}
		else
		{
			printf("空栈\n");
		}
		free(p);
	}

	else
	{
		printf("空栈");
		return stack;
	}
	return stack;
}

int main()
{
	LineStack *stack = NULL;
	stack = push(stack, 1);
	stack = push(stack, 2);
	stack = push(stack, 3);
	stack = push(stack, 4);
	stack = pop(stack);
	stack = pop(stack);
	stack = pop(stack);
	stack = pop(stack);
	stack = pop(stack);
	getchar();
	return 0;
}

参考链栈基本操作（入栈和出栈）C语言详解 (biancheng.net)

二、队列

队列是允许一端进，一段出的数据结构，遵循“先进先出”原则。

1.顺序队列的基本操作：

进队：队列有两个指针，rear指向队头元素，top指向队尾元素，当队列为空时，top和rear是重叠的，如图：

进队：rear指向进栈的元素位置，top不动：

出队时，top向前移动，rear不动，知道所有的元素都出队列，rear和top又重合：

代码实现如下：

#include<stdio.h>
#include<stdlib.h>

//入队
int InQueue(int *a, int rear, int data)
{
	a[rear] = data;
	rear++;
	return rear;
}

//出队
void OutQueue(int *a, int top, int rear)
{
	while (top != rear)
	{
		printf("出队元素：%d\n", a[top]);
		top++;
	}
}

int main()
{
	int a[10];
	int top, rear;
	top = rear = 0;
	//入队
	rear = InQueue(a, rear, 1);
	rear = InQueue(a, rear, 2);
	rear = InQueue(a, rear, 3);
	//出队
	OutQueue(a, top, rear);
	getchar();
	return 0;
}

结果：

但是，运用此方法会发现，随着元素出队，rear和top的位置也会向后移动，造成了空间的浪费，其缺点是：

a.顺序队列之前的数组存储空间将无法再被使用，造成了空间浪费；

b.如果顺序表申请的空间不足够大，则直接造成程序中数组 a 溢出，产生溢出错误；

解决方法：环状顺序队列

当rear超过队列申请的大小时，又开始重新进队，直接将其从a[0]重新开始存储，如果rear+1和front重合，则表示数组已满。

代码实现如此下：

#include<stdio.h>
#include<stdlib.h>

#define max 5
//入队
int InQueue(int *a,int top, int rear, int data)
{
	//判断，rear超过max，重新开始排队
	//如果rear+1=top，队列已满
	if ((rear + 1) % max == top)
	{
		printf("空间已满");
		return rear;
	}
	a[rear%max] = data;
	rear++;
	return rear;
}

//出队
int OutQueue(int *a, int top, int rear)
{
	if (top == rear%max)
	{
		printf("队列为空");
		return top;
	}
	else
		printf("%d", a[top]);
	//top+1后与max取余，如果(top+1)%max=top,直接跳转到a[0]
	top = (top + 1) % max;
	return top;
}

int main()
{
	int a[max];
	int top, rear;
	top = rear = 0;
	//入队
	rear = InQueue(a,top, rear, 1);
	rear = InQueue(a, top,rear, 2);
	rear = InQueue(a, top,rear, 3);
	rear = InQueue(a,top, rear, 4);
	//出队
	top=OutQueue(a, top, rear);
	//再入队
	rear = InQueue(a, top, rear, 5);
	//再出队
	top = OutQueue(a, top, rear);
	//再入队
	rear = InQueue(a, top, rear, 6);
	//再出队
	top = OutQueue(a, top, rear);
	top = OutQueue(a, top, rear);
	top = OutQueue(a, top, rear);
	top = OutQueue(a, top, rear);

	getchar();
	return 0;
}

结果：

参考：顺序队列及其（C语言）实现详解 (biancheng.net)

2.链式队列基本操作

链式队列申请空间时与链表类似，新建节点时开辟空间，进行实时地申请空间。

链式队列：队列为空时，rear与top重合。

typedef struct LinkQueue
{
	int data;
	struct LinkQueue* next;
}LQ;

//
LQ * initQueue()
{
	//创建一个头结点
	LQ * queue = (LQ*)malloc(sizeof(LQ));
	//初始化头结点
	queue->next = NULL;
	return queue;
}

（1）链式队列入队

1入队，rear指向队尾1的位置，top指向队头，rear->next=NULL.

C代码实现如下：

//入队
LQ * inqueue(LQ* rear, int data)
{
	//结点
	LQ * inval = (LQ*)malloc(sizeof(LQ));
	inval->data = data;
	inval->next = NULL;
	//与rear建立逻辑关系
	rear->next = inval;
	//rear指向新节点
	rear = inval;
	return rear;
}

(2)链式队列出队

用p指向要出队的结点，将p结点从队列中摘除，释放p，回收空间。

C代码实现为：

LQ* dequeue(LQ *top, LQ *rear)
{
	LQ*p = NULL;
	if (top->next == NULL)
	{
		printf("队列为空");
		return rear;
	}
	//队头元素出队
	p = top->next;
	printf("%d", p->data);
	top->next = p->next;
	if (rear == p)//如果队列只有一个元素，出完为空
		rear = top;
	free(p);
	return rear;
}

总的代码及运行结果为：

#include<stdio.h>
#include<stdlib.h>

typedef struct LinkQueue
{
	int data;
	struct LinkQueue* next;
}LQ;

//
LQ * initQueue()
{
	//创建一个头结点
	LQ * queue = (LQ*)malloc(sizeof(LQ));
	//初始化头结点
	queue->next = NULL;
	return queue;
}

//入队
LQ * inqueue(LQ* rear, int data)
{
	//结点
	LQ * inval = (LQ*)malloc(sizeof(LQ));
	inval->data = data;
	inval->next = NULL;
	//尾插法入队
	rear->next = inval;
	rear = inval;
	return rear;
}

//出队
LQ* dequeue(LQ *top, LQ *rear)
{
	LQ*p = NULL;
	if (top->next == NULL)
	{
		printf("队列为空");
		return rear;
	}
	//队头元素出队
	p = top->next;
	printf("%d", p->data);
	top->next = p->next;
	if (rear == p)//如果队列只有一个元素，出完为空
		rear = top;
	free(p);
	return rear;
}

int main()
{
	LQ *queue, *top, *rear;
	queue = top = rear = initQueue();//创建头结点
	//向队列中添加节点，用尾插法入队
	rear = inqueue(rear, 1);
	rear = inqueue(rear, 2);
	rear = inqueue(rear, 3);

	//出队
	rear = dequeue(top, rear);
	rear = dequeue(top, rear);
	rear = dequeue(top, rear);
	rear = dequeue(top, rear);

	getchar();
	return 0;
}

参考：链式队列及基本操作（C语言）完全攻略 (biancheng.net)

实验室里哈啤酒

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构--leetcode环形链表II、栈和队列

栈：一种收限定的线性表，既将线性表的插入和删除固定在表的一端进行。允许进行插入删除操作的一端称为栈顶，栈顶是动态变化的，有一个指针来指示栈顶的位置。值得注意的是，栈里的操作就像电梯一样，每次新进来的元素都会称为新的栈顶，先进后出，后进先出。重要掌握顺序栈顺序存储结构的栈，占据连续的内存，必须附设一个位置指针来动态的指示栈顶元素的位置，top=-1指空栈。出栈：pop进栈：push判栈空：empty获得栈顶元素：getTop基本实现代码（C++）：#include&lt
复制链接

扫一扫