【数据结构初阶】队列&&队列的面试题

已于 2022-09-05 17:01:49 修改
阅读量655 收藏 57
点赞数 78
分类专栏： 数据结构零基础学习 文章标签： 数据结构 链表 c语言 leetcode
于 2022-08-29 07:32:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68931081/article/details/126180345
版权

大家好我是沐曦希💕

队列

1.队列

1.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头。
在这里插入图片描述

1.2 队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
在这里插入图片描述

Queue.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;

}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;
// 初始化队列
void QueueInit(Queue* qp);
// 销毁队列
void QueueDestroy(Queue* qp);
// 队尾入队列
void QueuePush(Queue* qp, QDataType data);
// 队头出队列
void QueuePop(Queue* qp);
// 检测队列是否为空，如果为空返回true，如果非空返回false
bool QueueEmpty(Queue* qp);
// 获取队列头部元素
QDataType QueueFront(Queue* qp);
// 获取队列队尾元素
QDataType QueueBack(Queue* qp);
// 获取队列中有效元素个数
int QueueSize(Queue* qp);

test.c

#include"Queue.h"
void test1()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);
	printf("%d\n", QueueFront(&q));
	printf("%d\n", QueueBack(&q));
	printf("%d\n", QueueSize(&q));
	QNode* cur = q.head;
	while (cur)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	printf("%d\n", QueueFront(&q));
	printf("%d\n", QueueBack(&q));
	printf("%d\n", QueueSize(&q));
	cur = q.head;
	while (cur)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
	QueueDestroy(&q);
}
int main()
{
	test1();
	return 0;
}

Queue.c

#include"Queue.h"
void QueueInit(Queue* qp)
{
	qp->head = NULL;
	qp->tail = NULL;
	qp->size = 0;
}
void QueueDestroy(Queue* qp)
{
	assert(qp);
	QNode* cur = qp->head;
	while (cur)
	{
		QNode* dele = cur;
		cur = cur->next;
		free(dele);
		dele = NULL;
	}
	qp->head = NULL;
	qp->tail = NULL;
	qp->size = 0;
}
void QueuePush(Queue* qp, QDataType data)
{
	assert(qp);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("perror fail");
		exit(-1);
	}
	else
	{
		newnode->val = data;
		newnode->next = NULL;
	}
	if (qp->tail == NULL)
	{
		qp->head = newnode;
		qp->tail = newnode;
	}
	else
	{
		qp->tail->next = newnode;
		qp->tail = newnode;
	}
	++qp->size;
}
void QueuePop(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	if (qp->head->next == NULL)
	{
		free(qp->head);
		qp->head = NULL;
		qp->tail = NULL;
		qp->size = 0;
	}
	else
	{
		QNode* cur = qp->head;
		qp->head = qp->head->next;
		free(cur);
		cur = NULL;
		--qp->size;
	}
}
bool QueueEmpty(Queue* qp)
{
	assert(qp);
	return qp->head == NULL && qp->tail == NULL;
}
QDataType QueueFront(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	return qp->head->val;
}
QDataType QueueBack(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	return qp->tail->val;
}
int QueueSize(Queue* qp)
{
	assert(qp);
	/*QNode* cur = qp->head;
	int n = 0;
	while (cur)
	{
		n++;
		cur = cur->next;
	}
	return n;*/
	return qp->size;
}

在这里插入图片描述

1.3 循环队列

扩展了解一下，实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。
在这里插入图片描述
在这里插入图片描述

2.队列的面试题

2.1 用队列实现栈

题目链接：223.用队列实现栈
在这里插入图片描述
在这里插入图片描述
因为C语言没有队列，那么就需要手动写一个队列出来。
因为要求两个队列，那么可以定义一个结构体，结构体成员是两个队列结构体。

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

要实现栈的性质：后入先出，而队列的性质：先入先出。
那么可以保持一个队列为空，要出数据时候，把有数据的队列的数据导入（n-1）个数据到没有数据的队列中，返回最后一个数据，并pop该数据。从而实现栈的后入先出。
在这里插入图片描述

代码

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
//队列函数的声明
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;

}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;
// 初始化队列
void QueueInit(Queue* qp);
// 销毁队列
void QueueDestroy(Queue* qp);
// 队尾入队列
void QueuePush(Queue* qp, QDataType data);
// 队头出队列
void QueuePop(Queue* qp);
// 检测队列是否为空，如果为空返回true，如果非空返回false
bool QueueEmpty(Queue* qp);
// 获取队列头部元素
QDataType QueueFront(Queue* qp);
// 获取队列队尾元素
QDataType QueueBack(Queue* qp);
// 获取队列中有效元素个数
int QueueSize(Queue* qp);

//队列的实现
void QueueInit(Queue* qp)
{
	qp->head = NULL;
	qp->tail = NULL;
	qp->size = 0;
}
void QueueDestroy(Queue* qp)
{
	assert(qp);
	QNode* cur = qp->head;
	while (cur)
	{
		QNode* dele = cur;
		cur = cur->next;
		free(dele);
		dele = NULL;
	}
	qp->head = NULL;
	qp->tail = NULL;
	qp->size = 0;
}
void QueuePush(Queue* qp, QDataType data)
{
	assert(qp);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("perror fail");
		exit(-1);
	}
	else
	{
		newnode->val = data;
		newnode->next = NULL;
	}
	if (qp->tail == NULL)
	{
		qp->head = newnode;
		qp->tail = newnode;
	}
	else
	{
		qp->tail->next = newnode;
		qp->tail = newnode;
	}
	++qp->size;
}
void QueuePop(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	if (qp->head->next == NULL)
	{
		free(qp->head);
		qp->head = NULL;
		qp->tail = NULL;
		qp->size = 0;
	}
	else
	{
		QNode* cur = qp->head;
		qp->head = qp->head->next;
		free(cur);
		cur = NULL;
		--qp->size;
	}
}
bool QueueEmpty(Queue* qp)
{
	assert(qp);
	return qp->head == NULL && qp->tail == NULL;
}
QDataType QueueFront(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	return qp->head->val;
}
QDataType QueueBack(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	return qp->tail->val;
}
int QueueSize(Queue* qp)
{
	assert(qp);
	/*QNode* cur = qp->head;
	int n = 0;
	while (cur)
	{
		n++;
		cur = cur->next;
	}
	return n;*/
	return qp->size;
}


//创建一个结构体成员为两个队列的结构体
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* obj = (MyStack*) malloc (sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    //在非空的队列中入数据
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    //从非空队列向空队列导入(n-1)个数据。
    int top = 0;
    if(!QueueEmpty(&obj->q1))
    {
        //q1为非空，q2为空，从q1向q2导入(n-1)数据，同时pop
        while(QueueSize(&obj->q1)>1)
        {
            QueuePush(&obj->q2,QueueFront(&obj->q1));
            QueuePop(&obj->q1);
        }
        //q1最后一个数据为top，同时pop该数据
        top = QueueFront(&obj->q1);
        QueuePop(&obj->q1);
    }
    else
    {
        //q2为非空，q1为空，从q2向q1导入(n-1)数据，同时pop
        while(QueueSize(&obj->q2)>1)
        {
            QueuePush(&obj->q1,QueueFront(&obj->q2));
            QueuePop(&obj->q2);
        }
        //q2最后一个数据为top，同时pop该数据
        top = QueueFront(&obj->q2);
        QueuePop(&obj->q2);
    }
    return top;
}
//求栈的top数据
int myStackTop(MyStack* obj) {
    //判断哪个队列不为空，输出该队列的最后一个数据即为栈的top
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    //判断栈是否为空，就需要判断两个队列是否同时为空
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    //要释放队列的动态空间再释放obj的空间，否则内存泄漏
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

在这里插入图片描述

2.2 用栈实现队列

题目链接:232.用栈实现队列

因为C语言没有栈，那么就需要手动写一个栈出来。
因为要求两个栈，那么可以定义一个结构体，结构体成员是两个栈结构体。
一个栈专门用来将数据入栈pushST，另一个专门用来将数据出栈popST。

typedef struct {
    ST pushST;
    ST popST;
} MyQueue;

要实现队列的性质：先入先出。，而栈的性质：先入后出。
那么可以指定一个栈pushST专门入栈数据，要出栈时候，先判断popST是否为空，为空则将pushST中的数据导入到popST中;如果不为空，则先popST先出空。
在这里插入图片描述

代码

#include<stdio.h>
#include<stdbool.h>
#include<assert.h>
#include<stdlib.h>
//栈函数的声明
typedef int STDataType;
typedef struct stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
// 初始化栈
void StackInit(ST* ps);
//销毁栈
void StackDestory(ST* ps);
// 入栈
void StackPush(ST* ps, STDataType data);
// 出栈
void StackPop(ST* ps);
//检测栈是否为空
bool StackEmpty(ST* ps);
// 获取栈顶元素
STDataType StackTop(ST* ps);
// 获取栈中有效元素个数
int StackSize(ST* ps);

//栈的实现
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = 0;
	ps->top = 0;
	ps->a = NULL;
}
void StackPush(ST* ps, STDataType data)
{
	assert(ps);
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
	ps->a[ps->top] = data;
	++ps->top;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	--ps->top;
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

//创建一个结构体成员为两个栈的结构体
typedef struct {
    ST pushST;
    ST popST;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushST);
    StackInit(&obj->popST);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    //向pushST入栈数据
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    //先判断popST是否为空
    //popST为空，则将pushST的数据入栈进popST，同时pop一下，最后进入的即为top，同时pop一下
    //popST不为空，则popST的最后一个数据即为top，同时pop一下
    int top = 0;
    if(!StackEmpty(&obj->popST))
    {
        top = StackTop(&obj->popST);
        StackPop(&obj->popST);
        return top;
    }
    else
    {
        while(StackSize(&obj->pushST)>0)
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
        top = StackTop(&obj->popST);
        StackPop(&obj->popST);
        return top;
    }
}

int myQueuePeek(MyQueue* obj) {
    //先判断popST是否为空，如果popST为空,则将pushST的数据导入到popST中
    //popST最后一个数据即为top
    if(StackEmpty(&obj->popST))
    {
        while(StackSize(&obj->pushST)>0)
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) {
    //判断队列是否为空，就需要判断两个栈是否同时为空
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    //要释放两个栈的动态空间再释放obj的空间，否则内存泄漏
    StackDestory(&obj->pushST);
    StackDestory(&obj->popST);
    free(obj);
}

2.3 设计循环队列

题目链接：622.设计循环队列
循环链表特点是长度固定，空间满了就不能加入数据，空间可以重复利用。
在这里插入图片描述
front指向队列的头，back指向队尾的下一个位置。

在这里插入图片描述

代码

typedef struct {
    int* a;
    int front;
    int back;
    int N;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->N = k+1;
    obj->front = 0;
    obj->back = 0;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->back;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return ((obj->back+1)%obj->N) == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->back] = value;
    obj->back++;
    obj->back = obj->back%obj->N;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->front = (obj->front+1)%obj->N;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[(obj->back-1+obj->N)%obj->N];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

3.概念选择题

3.循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。
经过一系列正常的入队与退队操作后， front=rear=99 ，
则循环队列中的元素个数为（ ）
A 1
B 2
C 99
D 0或者100

答案：D

4.以下( )不是队列的基本运算？
A 从队尾插入一个新元素
B 从队列中删除第i个元素
C 判断一个队列是否为空
D 读取队头元素的值

队列是先入先出，不能直接删除中间任意一个数据
答案:B

5.现有一循环队列，其队头指针为front，队尾指针为rear；
循环队列长度为N。其队内有效长度为？(有一个空间不存储数据)
A (rear - front + N) % N + 1
B (rear - front + N) % N
C ear - front) % (N + 1)
D (rear - front + N) % (N - 1)

答案:B

4.写在最后

那么队列就到这里结束啦！
在这里插入图片描述

沐曦希
关注
专栏目录
[05数据结构](初阶)二叉树的基本理解、堆的概念和结构及二叉树OJ面试题
再吃一个橘子
11-16 977
满二叉树是特殊的完全二叉树
【数据结构与算法】详解 “清华大学（考研）OJ题(1)
2401_84181340的博客
04-27 917
✨综上：就是层序遍历啦~➡️相信大家对新的遍历方式有不一样的看法了吧🧡。
面试题：设计循环队列
陌上人如玉，公子世无双。
04-26 449
原题链接：https://leetcode-cn.com/problems/design-circular-queue/ 代码如下： //设计循环队列 class MyCircularQueue { public: int *array; int capacity; int size; int front; // 队首下标 int rear; // 队尾下标 /*在这里初始化...
面试题精选:循环队列
xindoo
05-10 1401
近期在面试找工作的小伙伴们很多啊，我周围就有好几个认识的朋友在找工作，于是我突发奇想在CSDN开了一个面试题精选的专栏，主要会关注一些算法题、设计题，次要会补充一些java面试相关的题(比较本博主是java出身)。其实在此之前已经写过一些相关的文章了，已经整理到专栏里的，后续会持续更新，希望对大家有所帮助，有兴趣的旁友可以关注下。 今天分享的面试题是循环队列，我对这道题记忆深刻，因为我在14年参加来校招面试的时候，二面面试官就问了这道题，当时我没有完全答上来(不过面试官居然给我过了)，后来我当面试官的时候也
环形队列介绍与实现
热门推荐
tt 博客
05-29 2万+
环形队列可以使用数组实现，也可以使用循环链表实现。 package www.bittech; public class MyCircularQueue { private int front;//队列头 private int rear;//队列尾 private int usedSize;//数据个数 private int[] elem;//数组 ...
数据结构与算法学习三：单链表的增加（添加到链尾，按顺序添加）、删除、查询、修改。
冯安晨
12-25 1028
文章目录前言一、稀疏数组二、数组队列 前言 一、稀疏数组 二、数组队列
【数据结构初阶】栈&&栈的面试题
m0_68931081的博客
08-24 435
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端A称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。.........
非常全的vue面试题最新前端vue面试题合集适合各阶段开发同学
05-06
本文将深入探讨Vue.js的核心概念和技术，帮助前端开发者，无论初阶还是高阶，都能在面试中展现出扎实的Vue知识。 1. **Vue基本概念** - **虚拟DOM**：Vue使用虚拟DOM来提高性能，它通过计算差异并只更新必要的部分...
2021中高级前端面试题合集，大厂内部资料
qq_60099172的博客
07-21 717
第一个阶段，开发环境和工具准备 浏览器 （Google，FireFox，…） 下载，安装前端开发工具vscode， 下载、安装 node、npm、webpack、webpack-cli、cnpm，配置前端开发环境 下载、配置PHP和MySQL 第二个阶段，前端入门，网页制作 1，HTML： 常用标签（div标签，p标签，span标签，a标签，img标签） 锚点 列表标签（有序列表，无序列表，自定义列表） 表单标签 表格标签 标签分类 标签语义化 注释 字符实体 2，CSS： CSS介绍 全局
九章算法——面试题思路
一路前行的专栏
07-29 4232
面试题1 落单的数 题目描述： 有2n+1个数，其中2n个数两两成对，1个数落单，找出这个数。要求O(n)的时间复杂度，O(1)的空间复杂度。进阶问题：如果有2n+2个数，其中有2个数落单，该怎么办？ 答： 初阶：将2n+1个数异或起来，相同的数会抵消，异或的答案就是要找的数。 进阶：假设两个不同的数是a和b，并且a!=b，将2n+2个数异或起来就会得到c=a
Java实现循环队列
tangtj的专栏
11-30 5713
import java.io.*;public class QueueArray {       Object[] a; //对象数组，队列最多存储a.length-1个对象       int front;  //队首下标       int rear;   //队尾下标       public QueueArray(){           this(10); //调用其它构造方法     
C语言实现环形队列
沉醉不知归路的博客
04-23 9497
因为最近几天在看线程池，所以顺便复习了一下环形队列，贴出来代码，供大家参考。因为没有特殊需求，所以只写了最简单的几个功能。 #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;string.h&amp;gt; #define elem int typedef struct queue { elem *data; ...
Leetcode：662.Design Circular Queue 设计循环队列
Coding
09-18 1041
Design Circular Queue 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存...
栈和队列的经典例题（括号匹配，用栈实现队列，用队列实现栈，设计循环队列）
身在边城 心在编程
04-19 549
栈和队列的基础接口实现 链接：https://blog.csdn.net/qq_43763344/article/details/89386829 .============================================================ 头文件： #include <iostream> #include <stdio.h> #include...
数据结构之树
x6886_57的博客
11-03 607
树的定义，树的逻辑表示方法，树的基本术语，树的性质，树的存储结构
数据结构---链表实现栈
最新发布
Dragonlongbo的博客
11-04 255
/用链表作为底层数据结构实现-栈。
插入排序和希尔排序
b123321888的博客
11-04 549
定义：插入排序是一种简单且直观的排序算法，适用于小规模数据的排序。基本思想：通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。实现特点：使用双层循环，外层循环遍历每个元素，内层循环负责将当前元素插入到正确的位置。定义：希尔排序是一种基于插入排序的排序算法，但它通过将原始列表分割成多个子列表来改进性能，每个子列表使用插入排序进行排序。基本思想：通过比较相距一定间隔的元素来进行排序，逐步减少间隔，直到间隔为1，此时整个列表基本有序，最后进行一次插入排序。
数据结构---链表实现双端队列
Dragonlongbo的博客
11-04 298
/链表实现双端队列。
评论 73
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沐曦希

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值