【每天学习亿点点系列】——重温栈和队列

最新推荐文章于 2021-09-18 16:38:10 发布
最新推荐文章于 2021-09-18 16:38:10 发布
阅读量201 收藏 2
点赞数 7
分类专栏： 每天学习亿点点系列 数据结构 文章标签： 数据结构 链表 队列 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IamGreeHand/article/details/119803400
版权

💥【每天学习亿点点系列】——重温栈和队列

栈的实现

在这里插入图片描述

栈的结构并不复杂，但是问题来了，我们应该怎样实现栈了，到底是用顺序表还是链表了，哪个更好了？
顺序表：入栈更加方便，直接在size的位置插入即可，出栈也方便，直接出对应的下标就行
但如果你用单链表就没不是这样了，首先你每次入栈的时候都必须要找到尾节点；出栈的时候出的是尾节点，但此时你还必须记录尾节点的前一个节点，因为如果你要继续出栈的话，就要把栈顶的元素删除，此时你为了保证链表的结构，必须让尾节点的前一个节点指向空
下面来看看栈的代码实现，我分别用顺序表和单链表各实现了一下，大家可以比较一下优劣。

顺序表实现栈

头文件以及测试部分代码

stack.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>

//顺序表实现栈
typedef int SDataType;
typedef struct Stack
{
	SDataType* a;
	int sz;
	int cap;
}Stack;

//将顺序表初始化
void Stackinit(Stack* cc);
//栈的插入
void StackPush(Stack* cc, SDataType x);
//栈的删除
void StackPop(Stack* cc);
//栈顶取出数据
SDataType Stacktake(Stack* cc);
//栈里面元素的打印
void StackPrint(Stack* cc);
//记录栈里面元素的个数
int StackSize(Stack* cc);
//判断是否为空
bool StackEmpty(Stack* cc);
//栈的销毁
void StackDestory(Stack* cc);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"
//顺序表实现栈
void test()
{
	Stack c;
	Stackinit(&c);
	StackPush(&c, 1);
	StackPush(&c, 2);
	StackPush(&c, 3);
	StackPush(&c, 4);
	StackPush(&c, 5);
	printf("%d\n", Stacktake(&c));
	printf("%d\n", Stacktake(&c));
	StackPrint(&c);
	StackPop(&c);
	StackPop(&c);
	StackPop(&c);
	//StackPop(&c);
	StackPrint(&c);
	printf("%d\n", StackSize(&c));
	printf("%d\n", StackEmpty(&c));
}

int main()
{
	test();
	return 0;
}
各个接口的实现
1.初始化
void Stackinit(Stack* cc)
{
	assert(cc);
	cc->cap = 4;
	SDataType* new = (SDataType*)malloc(sizeof(SDataType)*cc->cap);
	if (new == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{
		cc->a = new;
	}
	cc->sz = 0;
}
2.栈的插入
void StackPush(Stack* cc, SDataType x)
{
	assert(cc);
	if (cc->sz == cc->cap)
	{
		cc->cap *= 2;
		cc->a = BuySList(cc);
		cc->a[cc->sz] = x;
		cc->sz++;
	}
	else
	{
		cc->a[cc->sz] = x;
		cc->sz++;
	}
}
3.栈的删除
void StackPop(Stack* cc)
{
	assert(cc);
	assert(!StackEmpty(cc));
	//任何要删除的地方都要这个断言，因为如果顺序表为空就不能删除了
	cc->sz--;
}
4.栈顶取出数据
SDataType Stacktake(Stack* cc)
{
	assert(cc);
	assert(!StackEmpty(cc));
	return cc->a[cc->sz - 1];
}
5.栈里面元素的打印
void StackPrint(Stack* cc)
{
	assert(cc);
	int i = 0;
	for (i = 0; i < cc->sz; i++)
	{
		printf("%d ", cc->a[i]);
	}
	printf("\n");
}
6.记录栈中元素个数
int StackSize(Stack* cc)
{
	assert(cc);
	return cc->sz;
}
7.判空
bool StackEmpty(Stack* cc)
{
	return cc->sz == 0;
}
8.栈的销毁
void StackDestory(Stack* cc)
{
	assert(cc);
//因为顺序表空间是连续的，所以可以这样释放
	free(cc->a);
	cc->a = NULL;
	cc->sz = cc->cap = 0;
}

单链表实现

头文件以及测试部分代码

stack.h

#include<string.h>
#include<stdlib.h>
#include<stdbool.h>



//单链表实现栈
typedef int stackDataType;
typedef struct stack
{
	struct stack* next;
	stackDataType data;
}stack;

//栈的插入
void stackPush(stack** cc,stackDataType x);

//栈里面元素的打印
void stackPrint(stack* cc);

//栈里面删除栈顶元素
void stackPop(stack** cc);

//取出栈顶的数据
stackDataType stacktake(stack** cc);

//判断栈是否为空
bool stackEmpty(stack* cc);

//记录栈中元素的个数
int stackSize(stack* cc);

//销毁
void stackDestory(stack** cc);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"

void test()
{
	stack* c=NULL;
	stackPush(&c,1);
	stackPush(&c,2);
	stackPush(&c,3);
	stackPop(&c);
	printf("%d\n", stacktake(&c));
	stackPrint(c);
	printf("%d\n", stackSize(c));
	stackDestory(&c);
	stackPrint(&c);
}
int main()
{
	test();
	return 0;
}
各个接口的实现
1.栈的插入
void stackPush(stack** cc,stackDataType x)
{
	assert(cc);
	//一个节点也没有的情况
	if ((*cc) == NULL)
	{
		(*cc) = BuyNode(x);
		(*cc)->next = NULL;
	}
//有节点的情况,注意由于栈是后进先出的，所以头插比较方便，拿出来时
//的时间复杂度为O（1）,如果尾插复杂度为O（n）
	else
	{
		stack* newnode = BuyNode(x);
		newnode->next = (*cc);
		(*cc) = newnode;
	}
}
2.栈里面元素的打印
void stackPrint(stack* cc)
{
	while (cc)
	{
		printf("%d ", cc->data);
		cc = cc->next;
	}
	printf("\n");
}
3.删除栈顶的节点
void stackPop(stack** cc)
{
	assert(cc);
	assert(*cc);
    stack* tailpre= *cc;
	while (tailpre->next->next)
	{
		  tailpre = tailpre->next;
	}
	free(tailpre->next);
	tailpre->next = NULL;
}
4.取出栈顶的数据
stackDataType stacktake(stack** cc)
{
	assert(cc);
	assert(*cc);
	return (*cc)->data;
}
5.判空
bool stackEmpty(stack* cc)
{
	return cc == NULL;
}
6.记录栈中元素个数
int stackSize(stack* cc)
{
	int n = 0;
	while (cc)
	{
		n++;
		cc = cc->next;
	}
	return n;
}
7.销毁
void stackDestory(stack** cc)
{
	assert(cc);
	while (*cc)
	{
		struct stack* next = (*cc)->next;
		free(*cc);
		*cc = next;
	}
}

队列

在这里插入图片描述

队列的结构也并不复杂，和栈很像，栈是后进先出，而队列是先进先出，那么问题又来了，队列的实现使用顺序表好还是链表好了？
单链表：插入的话，每次要在尾节点后插入，需要遍历找尾，但是如果出队列的话，只要出头节点就可以了，然后将头节点的下一个节点变为头就可以了。
顺序表：插入的话很简单，每次只要在size为下标的位置插入即可，但如果出队列的话，只能出下标为0的位置，此时出了之后还需要把后面的元素往前移，也并不简单

我们发现其实这两者并没有哪个更优的说法，并不像实现栈的时候有明显的差距，那有没有其他方法可以提高效率了？
肯定是有的：我们发现单链表效率地的原因是它每次都要找尾，那我们能不能不找尾了，我用一个指针来记录尾的位置不就行了吗，前提是这个指针要一直都在，所以我们一开始就将它定义为结构体成员，这种方法叫做结构体包裹。
下面同样，我用两中方法都实现了一下，大家可以对比一下优劣。

单链表（没有用结构体包裹）来实现

头文件以及测试部分

Queue.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<stdlib.h>

typedef int QueueDataType;
typedef struct Queue
{
	struct Queue* next;
	QueueDataType x;
}Queue;

//因为我是用单链表实现的队列，插入就相当于初始化了，所以没必要去初始化
void QueuePush(Queue** cc,QueueDataType x);
//取出数据，因为队列是先进先出，所以应该取队列顶的数据，也就是头节点
QueueDataType Queuetake(Queue** cc);
//删除，删除取出来的数据，也就是队列头部的数据，也就是头节点
void QueuePop(Queue** cc);
//判断是否为空
bool QueueEmpty(Queue* cc);
//记录队列的节点个数
int QueueSize(Queue* cc);
//打印队列中的节点
void QueuePrint(Queue* cc);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
void test1()
{
	Queue *c=NULL;
	QueuePush(&c, 1);
	QueuePush(&c, 2);
	QueuePush(&c, 3);
	QueuePush(&c, 4);
	printf("%d\n", Queuetake(&c));
	QueuePop(&c);
	printf("%d\n", Queuetake(&c));
	QueuePop(&c);
	QueuePop(&c);
	QueuePop(&c);
	QueuePop(&c);
	QueuePrint(c);
}

int main()
{
	*test1();
	return 0;
}
各个接口的实现
1.队列的插入
//插入
void QueuePush(Queue** cc, QueueDataType x)
{
	assert(cc);
	//当没有节点的情况
	if (*cc == NULL)
	{
		Queue* newnode = BuyNode(x);
		newnode->next = NULL;
		*cc = newnode;
	}
	//当有节点的情况
	else
	{
		Queue* newnode = BuyNode(x);
		//找尾
		Queue* tail = (*cc);
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
		newnode->next = NULL;
//其实这一步写了等于没写，因为你下一次调用这个接口的时候，你tail又被赋值为*cc了
		tail = newnode; 
	}
}
2.出队列
//取出数据，因为队列是先进先出，所以应该取栈顶的数据，也就是头节点
QueueDataType Queuetake(Queue** cc)
{
	assert(cc);
	assert(*cc);   //这句话和52行起到的是相同的效果
	assert(!QueueEmpty(*cc));
	return (*cc)->x;
}
3.删除
//删除，删除取出来的数据，也就是队列头部的数据，也就是头节点
void QueuePop(Queue** cc)
{
	assert(cc);
	assert(!QueueEmpty(*cc)); //这句话和下一行起到的是相同的效果
	assert(*cc);
	Queue* newnode = (*cc)->next;
	(*cc) = newnode;
}
4.判空
//判断是否为空
bool QueueEmpty(Queue* cc)
{
	return cc == NULL;
}
5.记录节点个数
//记录队列的节点个数
int QueueSize(Queue* cc)
{
	int n = 0;
	while (cc)
	{
		n++;
		cc = cc->next;
	}
	return n;
}
6.打印队列中的节点
void QueuePrint(Queue* cc)
{
	while (cc)
	{
		printf("%d ", cc->x);
		cc = cc->next;
	}
	printf("\n");
}
7.销毁
//销毁
void QueueDestory(Queue** cc)
{
	assert(cc);
	while (*cc)
	{
		Queue* next = (*cc)->next;
		free(*cc);
		*cc = next;
	}
}

单链表实现（结构体包裹的方式）

头文件以及测试部分

Queue.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<stdlib.h>


typedef int QueueDataType;
typedef int SListDataType;
typedef struct SList
{
	struct SList* next;
	SListDataType x;
}SList;
typedef struct Queue
{
	SList* head;
	SList* tail;
}Queue;

//这种结构体包裹的写法是要初始化的，因为你队列里面包含了两个指针
void Queueinit(Queue* cc);

void QueuePush(Queue** cc, QueueDataType x);
//取出数据，因为队列是先进先出，所以应该取队列顶的数据，也就是头节点
QueueDataType Queuetake(Queue** cc);
//删除，删除取出来的数据，也就是队列头部的数据，也就是头节点
void QueuePop(Queue** cc);
//判断是否为空
bool QueueEmpty(Queue* cc);
//记录队列的节点个数
int QueueSize(Queue* cc);
//打印队列中的节点
void QueuePrint(Queue* cc);
//销毁
void QueueDestory(Queue* cc);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

void test2()
{
	Queue c;
	Queueinit(&c);
	QueuePush(&c, 1);
	QueuePush(&c, 2);
	QueuePush(&c, 3);
	QueuePush(&c, 4);
	printf("%d\n", Queuetake(&c));
	QueuePop(&c);
	printf("%d\n", Queuetake(&c));
	QueuePop(&c);
	QueuePop(&c);
	QueuePop(&c);
	//QueuePop(&c);
	QueuePrint(&c);
}
int main()
{
	test2();
	return 0;
}
各个接口的实现
1.初始化
//这种结构体包裹的写法是要初始化的，因为你队列里面包含了两个指针
void Queueinit(Queue* cc)
{
	assert(cc);
	cc->head = cc->tail = NULL;
}
2.入队列
void QueuePush(Queue* cc, QueueDataType x)
{
	assert(cc);
	//没有节点的情况
	if (cc->tail == NULL)
	{
		SList* newnode = BuyNode(x);
		newnode->next = NULL;
		cc->head = cc->tail = newnode;
	}
	//有节点的情况
	else
	{
		//这就是结构体包裹这种写法的好处，这样你就不需要找尾节点了
		//因为我一开始定义队列的时候，就定义了一个指向尾的指针，这样
		//的想法可以大大提高效率
		SList* newnode = BuyNode(x);
		cc->tail->next = newnode;
		newnode->next = NULL;
		cc->tail = newnode;
	}
}
3.判空
bool QueueEmpty(Queue* cc)
{
	assert(cc);
	return cc->head == NULL;
}
4.出队列
QueueDataType Queuetake(Queue* cc)
{
	assert(cc);
	assert(!QueueEmpty(cc));
	return cc->head->x;
}
5.删除队列头部节点
void QueuePop(Queue* cc)
{
	assert(cc);
	assert(!QueueEmpty(cc));
	SList* newhead = cc->head->next;
	cc->head = newhead;
}
6.记录队列节点个数
int QueueSize(Queue* cc)
{
	assert(cc);
	int n = 0;
	while (cc->tail)
	{
		n++;
		cc->tail = cc->tail->next;
	}
	return n;
}
7.打印队列元素
void QueuePrint(Queue* cc)
{
	assert(cc);
	SList* cur = cc->head;
	while (cur)
	{
		printf("%d ", cur->x);
		cur=cur->next;
	}
	printf("\n");
}
8.销毁
void QueueDestory(Queue* cc)
{
	assert(cc);
	while (cc->head)
	{
		SList* next = cc->head->next;
		free(cc->head);
		cc->head = next;
	}
	cc->tail = NULL;
}
一个数学不怎么好的程序员
关注
  • 7
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
量化交易系统开发步骤策略/功能需求/案例设计/源码出售/详细
2301_79125431的博客
04-26 1569
金山办公投递2023-03-19NLP算法工程师-面向24届春招笔试2024-03-2320道选择，时间线：4.6投简历，4.18做行测，4.25一面面试官很礼貌，一来就介绍了自己的岗位，部门和名字，1 美团优选，后端开发java，发的是最早的，当时就签了2 腾讯pcg大数据平台，岗位是推荐架构cp。小弟北方人，对工作地方没什么大的要求，也没有在北上定居的打算，工作几年润二线城市。暑期实习求选个人情况：之前实习全都是数据科学相关，秋招想冲算法，保数据科学，偏好建模和技术性强一点的。
重温JavaScript中的正则表达式 js学习笔记
01-19
一、创建正则表达式 创建正则表达式和创建字符串类似 ， 创建正则表达式提供了两种方法 ， 一种是采用 new运算符，另一个是采用字面量方式。 代码如下: var dog = new RegExp(‘dog’); // 第一个参数字符串 var dog...
算法刷题重温(六)： 深度优先(DFS)和广度优先(BFS)
Miracle8070
03-07 1628
1. 写在前面 今天复习深度优先和广度优先遍历，这两个也是非常重要的思想，应用最多的就是对树和图的相关遍历了。 深度优先遍历DFS解决的是连通性的问题，即给定两个点，一个是起始点，一个是终止点，判断是不是有一条路径从起点到终点（这里的起点和终点也可以指起始状态和最终状态）。问题的要求并不在乎是长还是短，只在乎有没有，有时候题目也会要求把找到的路径完整的打印出来 广度优先遍历BFS一般用来解决最短路径的问题。和深度优先搜索不同，广度优先的搜索是从起始点出发，一层一层地进行，每层当中的点距离起始点的步数都是相
【浏览器】1022- 47 张图带你走进浏览器的世界！
pingan8787
07-18 1445
大家好，我是零一，每个开发者（尤其是前端工程师）或多或少会跟浏览器打交道，那么你们有没有想过去深入了解浏览器呢？无论是因为好奇还是为了面试，相信你们一定在网上搜过不少关于浏览器相关的知识和...
oi大佬经验分享
ddeneijvu948663112的博客
08-26 890
凭什么我得了信息学奥赛国家一等奖 （有删节） 山东省莱州一中 姚 远 2005年5月中旬，在犹豫了几个月后，我终于决定退出信息学奥赛。随后我交还了手中所有的图书资料，搬出了601宿舍，停下了所有的辅导课……脑袋空下来之后，过去的事开始不断闯进我的脑海——那不明白的许多事情，还有悬而未决的问题——我真想解决它们啊。至少我也要弄明白有些事为什么会发生，为什么会变...
重拾数据结构
weixin_45044097的博客
05-06 122
重拾数据结构算法与数据结构数组&链表面试题：反转一个单链表&判断链表是否有环栈 Stack、队列Queue面试题：判断括号字符串是否有效如何改变文本的样式插入链接与图片生成一个适合你的列表创建一个表格新的甘特图功能，丰富你的文章UML 图表 最近遇到一些烦心事，想重温些简单的知识，希望可以有新的理解，让自己不要胡思乱想。学习的知识包括Java的基础部分，参考书籍《Java核心技术》卷一 / 卷二；以及以下提到的数据结构。 下图是区块链的一个结构，可以很容易看出上面是一个基础的单向链表结构，下
为什么我们信息学奥赛出了国家一等奖 by:山东省莱州一中 姚 远
weixin_30883271的博客
07-11 720
　　　　　　　　　　　　　　　　　　　　　　 为什么我们信息学奥赛出了国家一等奖 　 　　2005年5月中旬，在犹豫了几个月后，我终于决定退出信息学奥赛。随后我交还了手中所有的图书资料，搬出了601宿舍，停下了所有的辅导课……脑袋空下来之后，过去的事开始不断闯进我的脑海——那不明白的许多事情，还有悬而未决的问题——我真想解决它们啊。至少我也要弄明白有些事为什么会发生，为什么会变...
程序员修炼之道（跨年阅读）-----精彩---经典---（待整理）
Chatopera
01-01 6094
程序员修炼之道 1 我的源码让猫给吃了 2 软件的熵 3 石头汤与煮青蛙  4 足够好的软件 5 你的知识资产6 交流！ 7 重复的危害 8 正交性 9 可撤消性 10 曳光弹 11 原型与便笺 12 领域语言 13 估算14 纯文本的威力 15 shell游戏 16 强力编辑 17 源码控制 18 调试 19 文本操纵
《Effective.Java》 阅码草堂笔记 一
qq_42236003的博客
11-25 211
首先来一个开宗明义 查理论吸引客户的关键是把手头的事情做好。把已经拥有的客户照顾好,其他的自然会来找你，这一种说法我觉得不只是商业，投资…放之四地皆适之，这里我只是想告诫自己，对于现在的自己来说，我可能不能做很多事情，但是我应该把每一件事情尽可能的做好，我可以不那么快，但是我应该要那么好，刘慈欣用彻夜赶工的妓女来形容程序员，是二百多年前的码头背起重负的搬运工，说我们是「技术无产阶级」，确实在马云爸爸给我们争取的九九六的福报下好像确实是这样，顺应互联网的洪流，代码作为程序员的一种谋生手段，已经祛魅，因为不在神
算法竞赛入门竞赛 入门经典 第六章 个人记录
没什么卵用的学习记录
09-13 765
  UVa 210 并行程序模拟（放弃 || 待补） 没看懂题意，但是有百度了一下duque 算是对duque有了一个大致的认识和了解 当然也有尝试。 本来想着去hdu找一些duque的题 结果 好像可以用上duque题目都比较高端 畏难而退orz   UVa 514 铁轨（待补） 再次败在题意 没懂 为什么 54321 可以Yes 而54123会是No 按照我的理解 54可以先在...
轻量级光流CNN——重温数据保真度和正则化
01-30
随着机器学习的发展，最近的一些工作试图利用卷积神经网络（CNN）来解决这个问题，并取得了令人满意的结果。FlowNet2[1]是最先进的CNN，需要超过160M的参数才能实现准确的流量估计。我们的LiteFlowNet2在Sintel和...
重温经典——AVR单片机串口ISP下载器.docx
11-01
AVR单片机串口ISP下载器是一种常用的编程工具，用于通过串行接口对AVR微控制器进行在线编程（In-System Programming）。该文档“重温经典——AVR...通过不断的DIY和学习，可以更深入地掌握单片机的开发和调试技巧。
指向深度学习的“学历案”应用与思考——以《打开编程之门》为例.pdf
08-19
“指向深度学习的‘学历案’应用与思考——以《打开编程之门》为例” 本资源摘要信息是在信息技术课的背景下，探讨“学历案”的应用与思考，以《打开编程之门》一课为例。该资源涵盖了深度学习、数据分析、数据研究...
重温经典——AVR单片机串口ISP下载器
08-27
在AVR单片机的学习过程中，ISP编辑下载器是一个必不可少的调试工具。在Atmel官方网站也分布并开源了简易ISP下载器的原理图与BOM。
八大排序 （万字总结）(详细解析，建议收藏！！！）
热门推荐
IamGreeHand的博客
09-18 1万+
文章目录直接插入排序代码实现复杂度的计算希尔排序希尔排序的预排序代码实现选择排序代码实现堆排序冒泡排序代码实现快速排序递归实现Hoare版本代码实现递归图解挖坑法代码实现递归图解前后指针法代码实现递归图解非递归实现Hoare版本挖坑法前后指针法非递归快排代码实现图解代码快速排序的两个优化1.三数取中代码实现2.小区间的优化代码实现归并排序递归实现递归图解区间划分要注意（死递归）非递归实现代码实现递归图解计数排序绝对映射和相对映射代码实现八大排序性能测试 ???? 注：以下排序都是以排升序为例。 直接插入
带你图解二叉树的多种递归遍历（建议收藏！！）
IamGreeHand的博客
09-05 6762
文章目录二叉树的构建结点类型的定义构建二叉树之间的关系深度优先遍历前序遍历代码实现图解递归（由于图片大小问题，建议用手机客户端查看，以下图解也是）中序遍历代码实现图解递归后序遍历代码实现图解递归广度优先遍历层序遍历代码实现 二叉树的构建 为了实现二叉树的遍历，我们要先构建一个二叉树，这里就先简单构建一个。 结点类型的定义 既然是链式二叉树，那必须得有自己的结点类型，以下是链式二叉树结点类型的定义 typedef char BTDataType; typedef struct BinaryNode {
Topk问题的三种求解方法
IamGreeHand的博客
09-02 5905
Topk问题的三种求解方法什么是Topk问题方法一：堆排序法方法二：把N个数建堆，取出前k个方法三：建一个k个数的堆 什么是Topk问题 其实顾名思义，这个问题也就是在N个数中找出前k个最值。在我们的日常生活中，很多地方都有Topk问题的影子，例如我们在点外卖时，总会说这家店是某某市的多少名，其实这些都是用Topk问题的解决方法得出来的。 方法一：堆排序法 这也是最容易想到的一种方法：我们可以将N个数排成有序的，然后输出前k个最值，而在我们已学过的排序算法中，堆排序的时间复杂度又是最快的（O（n*lo
排序算法学习（2）（快速排序，归并排序，计数排序）（详细解析，建议收藏！！！）
IamGreeHand的博客
09-18 1778
文章目录快速排序递归实现Hoare版本代码实现递归图解挖坑法代码实现递归图解前后指针法代码实现递归图解非递归实现Hoare版本挖坑法前后指针法非递归快排代码实现图解代码快速排序的两个优化1.三数取中 快速排序 快速排序是公认的排序之王，其基本思想为： 任取待排序元素序列中的某元素作为基准值，按照该基准值将待排序列分为两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后左右序列重复该过程，直到所有元素都排列在相应位置上为止。 对于如何按照基准值将待排序列分为两子序列，常见的方式
"JAVA面试题目精选：完善学习路径，重温核心知识点。
本手册收集了Java相关技术栈的面试题，旨在帮助大家找到心仪的工作。内容大部分来自互联网，由公众号：Java专栏进行整理汇总。整个手册共计24W字，涵盖了Java的各个方面，包括基础知识、面向对象、集合框架、多线程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一个数学不怎么好的程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值