栈的实现（附含经典例题）

已于 2023-05-20 13:45:49 修改
阅读量690 收藏 34
点赞数 39
分类专栏： 数据结构与算法 数据结构刷题练习 文章标签： 链表 数据结构
于 2023-05-18 11:09:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65662221/article/details/130734142
版权

🍉博客主页：阿博历练记
📖文章专栏：数据结构与算法
🚍代码仓库：阿博编程日记
🍥欢迎关注：欢迎友友们点赞收藏+关注哦🌹

在这里插入图片描述

文章目录

🍀前言

上期阿博给友友们介绍了双链表,下面阿博再来给友友们介绍一种新的数据结构栈.
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In FirstOut）的原则。
在这里插入图片描述
在这里插入图片描述
压栈(进栈/入栈)：栈的插入操作。入数据在栈顶.
出栈：栈的删除操作。出数据也在栈顶.
栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小.

🏄‍♂️数组栈

🔍1.栈的结构框架

typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

友友们注意，这里top是标识栈顶的位置.

🔍2.栈的初始化

void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}

📢初始化数组指针为空

这里有很多友友们可能会有疑问：我们初始化的时候不应该给它在堆区上动态开辟一块空间吗，为什么初始化为空呢？
在这里插入图片描述

📢top不同的初始化

1.top初始化为0
在这里插入图片描述
2.top初始化为-1
在这里插入图片描述
⭐友友们注意了，对应不同的top值，栈的判空条件也是不一样的

1.top初始化为0，判空方式就是top == 0，这种方式是：top指向栈顶元素的下一个位置.
2.top初始化为-1，判空方式是top == -1,这种方式是：top指向栈顶元素的位置.

🔍3.栈的释放

void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

🔍4.栈的插入数据

void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}

友友们这里一定要注意当我们扩容成功之后，要把新地址传给我们的pst->a指针，如果忘记，那么它还是指向空的，因为我们的top就是指向栈顶元素的下一个位置，所以当我们插入数据的时候，直接就可以把数据放在下标为pst->top的位置上.

🔍5.栈的删除数据

void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}

这里要注意我们的栈为空之后，即top为0，就不要在减减top了

🔍6.取栈顶元素

STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}

这里要注意的是我们的top是指向栈顶元素的下一个位置，所以当我们要取栈顶元素的时候，我们要让top减1，如果栈为空，就不要再取了，因为如果空栈，pst->top-1就变成-1了，就会出现越界访问.一定要注意越界在不同的编译器上它们的处理是不一样的，因为它们的版本可能不一样.在这里插入图片描述

🔍7.栈的判空

bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}

⛳⛳友友们注意这里不能写成return pst->top，这里我们要理解栈空的概念就是pst->top等于0为真，所以这里我们用一个判断式，如果我们那样写的话，pst->top等于0的话，0就是假，我们就需要反一下，return ！pst->top,就是当pst->top为0的时候，取非就为真，但是这样代码的可读性就不是很高了.

🔍8.返回栈空间元素的个数

int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

如果我们把top初始化为-1，那么这里的size就是top+1.

🚣Stack.h代码

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);

🏂Stack.c代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity= pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a,newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

🏊‍♂️Test.c代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
void  TestStack1()
{
	ST st;
	STInit(&st);
	STPush(&st, 1);
	STPush(&st, 2);
	STPush(&st, 3);
	STPush(&st, 4);   
	while (!STEmpty(&st))     //因为栈是后进先出，所以我们不能随便访问
	{
		printf("%d ", STTop(&st));
		STPop(&st);
	}
	STDestroy(&st);
}                          

int main()
{
	TestStack1();
	return  0;
}

⭐⭐⭐友友们，这里注意一下

因为栈具有后入先出的特性，所以我们在访问的时候，不能随机访问.

🧋代码效果展示

在这里插入图片描述

🖋题目描述

在这里插入图片描述

💡逻辑分析

因为题目要保证左括号必须以正确的顺序闭合和每个右括号都有一个相同类型的左括号
在这里插入图片描述

❌错误案例1

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);
void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

bool isValid(char * s){
      ST q;
      STInit(&q);
      while(*s)
      {
      if(*s=='('||*s=='['||*s=='{')
      {
          STPush(&q,*s);
      }
      else
      {
          if(STTop(&q)=='('&&*s!=')'||STTop(&q)=='['&&*s!=']'||STTop(&q)=='{'&&*s!='}')
          {
              return  false;
          }
          else
          {
             STPop(&q);
          }
      }
      s++;
      }
      return  true;
}

友友们如果我们这里只输入了’[’，它入栈之后，s++走到\0的位置退出while循环，然后我们直接返回true了，这就会导致结果的错误，所以我们在退出while循环之后，我们需要判断一下栈是否为空，如果不为空，也返回false.

❌错误案例2

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);
void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

bool isValid(char * s){
      ST q;
      STInit(&q);
      while(*s)
      {
      if(*s=='('||*s=='['||*s=='{')
      {
          STPush(&q,*s);
      }
      else
      {
          if(STTop(&q)=='('&&*s!=')'||STTop(&q)=='['&&*s!=']'||STTop(&q)=='{'&&*s!='}')
          {
              return  false;
          }
          else
          {
             STPop(&q);
          }
      }
      s++;
      }
      if(!STEmpty(&q))
      return  false;
      return  true;
}

友友们，如果我们这里只输入了一个‘]’,它既没有入栈，然后它还调用了这个STTop函数，空栈就不能再用这个函数了，所以我们可以判断一下，如果栈为空，第一个肯定是右括号，这样它就不会有对应的左括号与它进行匹配，我们就直接返回false.栈不为空，我们才会进行后续的比较.

✔代码纠正

typedef  int  STDataType;
typedef struct  Stack
{
	STDataType* a;
	int top;                    //top指向栈顶的位置
	int capacity;
}ST;

void  STInit(ST* pst);
void  STDestroy(ST* pst);
void  STPush(ST* pst,STDataType x);
STDataType  STTop(ST* pst);
void  STPop(ST* pst);
bool  STEmpty(ST* pst);
int   STSize(ST* pst);
void  STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;    //如果我们初始化为0，top就指向栈顶元素的下一个位置，初始化为-1，top就是指向栈顶元素.
	pst->capacity = 0;
}
void  STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void  STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity==0 ? 4 : pst->capacity * 2 ;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	} 
	pst->a[pst->top] = x;
	pst->top++;
}
STDataType  STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	return pst->a[pst->top - 1];
}
bool  STEmpty(ST* pst)
{
	assert(pst);
	return  pst->top == 0;
}
void  STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
int   STSize(ST* pst)
{
	assert(pst);
	return   pst->top;
}

bool isValid(char * s){
      ST q;
      STInit(&q);
      while(*s)
      {
      if(*s=='('||*s=='['||*s=='{')
      {
          STPush(&q,*s);
      }
      else
      {
          if(STEmpty(&q))
          {
              return  false;
          }
          if(STTop(&q)=='('&&*s!=')'||STTop(&q)=='['&&*s!=']'||STTop(&q)=='{'&&*s!='}')
          {
              return  false;
          }
          else
          {
             STPop(&q);
          }
      }
      s++;
      }
      if(!STEmpty(&q))
      return  false;
      return  true;
}
阿博历练记
关注
专栏目录
栈和队列经典题目汇总
tttjp的博客
07-22 4994
1. 实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1) 2. 使用两个栈实现一个队列 3. 使用两个队列实现一个栈 4. 元素出栈、入栈顺序的合法性。如入栈的序列（1,2,3,4,5），出栈序列为（4,5,3,2,1） 5. 一个数组实现两个栈
利用栈实现的经典案例
Fire的博客
08-02 1018
1.用栈来实现任意进制进制转换//linklist.h#ifndef __LINKLIST_H__ #define __LINKLIST_H__typedef struct linklistnode { struct linklistnode *next; int item; }LinkListNode; //数据节点 typed
栈实例（转载）
ay_一起沉默 的博客
08-17 668
栈：只允许在一端进行插入和删除操作，（后进先出）
［算法学习］堆栈篇：7个案例带你玩转栈、队列、堆
最新发布
qq_53481114的博客
12-22 845
文章主要介绍了数据结构中栈、队列以及堆的基本使用方法，并通过几道例题加以练习
算法：栈的使用、原理及案例
Zok的博客
11-26 358
栈 特点：后进先出 （last-in，first-out） 进栈（压栈）：push 出栈：pop 取栈顶： gettop 运用：栈进行括号匹配 class Stack: def __init__(self): self.stack = [] def push(self, element): self.stack.append(elemen...
基础算法-递归与回溯思想&&解题思路&&解题模板(附经典例题)
LYFlied的博客
04-18 373
回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为 “回溯点”。 许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。 > 回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 ——LeetCode 解题模板总结 1.什么时候用 2.为什么这样用 3.怎么用 例题-全排列问题 例题-子集问题
【数据结构与算法拓展】二叉堆原理、实现与例题（C和java）
wayne_lee_lwc的博客
11-21 716
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
【数据结构与算法基础】并查集原理、封装实现及例题解析（C和java）
wayne_lee_lwc的博客
11-13 535
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
回溯算法以及剪枝技巧（内附通用构建模板，文末有C++、JAVA、Python的实现）
04-17 1592
将一个问题中所有可能出现的情况（穷举法）转化为解集树，然后逐一剔除剪枝找到符合条件的解又或者是解集（穷举的优化）
数据结构-严蔚敏-附答案
11-10
《数据结构》一书由严蔚敏教授编写，是该领域的经典教材，尤其在C语言实现方面具有广泛影响力。这本书深入浅出地讲解了各种基本的数据结构类型，如数组、链表、栈、队列、树、图等，以及与之相关的算法，如排序和...
用栈解决迷宫问题求出路径
sofency'Blog
12-06 1044
1.用栈解决迷宫问题，比较暴力，实际上是经过大量的试错才得出的路径 问题分析 a.首先画出图，我用1代表墙，用0代表非墙。 b.首先要规定入口的坐标位置 c.然后规定寻找的方向规则比如 先每到一个位置先看下该点的左侧是否非墙，如果是返回该点的坐标并将该点对应的下标（在之后要用该下标解析出对应的坐标）入栈，如果是墙的话，就看该点的下面是否非墙…总之我规定的顺序是左-下-右-上。(这个也是该代码...
栈的应用——深度优先搜索（走迷宫）
chenchen_fcj程序猿的博客
07-28 967
栈应用到走迷宫（寻路算法）的做法 迷宫就是下图所示的这种，这次主要是先用代码画出一个迷宫（利用二维数组），然后寻路走到出口 代码如下：(在C++中运行) mystack.h #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; struct Point  //这个就是显示的坐标点位置，其余都一样，只是data的类型变了，变为坐标 {    ...
迷宫小游戏最短路径的选择
sing_Hwang的博客
12-31 631
我们主要通过一个栈来实现一个迷宫，用压栈来记录路径 迷宫我们定义66大小的迷宫这个走法原则上是可以无限的，但是我们定义的我们必须需要考录这个我们用栈实现这个迷宫需要考虑的问题，首先来说栈是有大小的啊，所以在没有回溯的前提下，这个迷宫一直不走老路线也就是压栈，这个对于66迷宫来说绰绰有余了 我们定义的这个迷宫在计算x,y坐标时候的逻辑是x向下的，y向右的为正 时候越界以及我们怎么样才算是走到出口了...
python栈迷宫路径搜索_深度优先搜索（DFS）
热门推荐
HYSliuliuliu的博客
11-04 1万+
python链栈算法，DFS深度优先搜索 算法通过尝试四个方向（上、下、左、右）来探索迷宫。它使用一个栈来记录当前路径。如果到达终点，它会打印路径并返回True。如果找不到路径，它会打印"走不通！"并返回False。 # 1. 当前所在节点四个方向分别为 x+1,y; x-1,y; x,y+1; x,y-1 # 2. 当前节点，也就是栈里的最后一个节点 stack[-1] # 3. 当走到终点时，就可以输出栈了 # 4. 没走到终点并且下一节点能走时，把该下一节点加入栈并标记为2，表示走过了
队列和栈的综合案例
温建平的博客
01-10 802
1、需求 现在有小明和小红两个人，他们在玩一个打牌游戏，规则是这样的：每个人6张牌，每人每次打出一张牌放在桌子上，如果哪次打出的牌跟桌子上的牌相同，则把这之间相同的牌收回放到自己牌的末尾。谁的牌先打完，代表谁先输。前提是我们的牌只有1-9这9张。 2、分析 两个人的牌，我们用两个队列表示，打牌就是出队，赢牌收到自己手中就是入队。打出的牌放在桌子上我们用一个栈表示，用一个数组记录桌子上已经有的
栈的几个实例应用
heitong_fu的博客
08-25 4537
简单括号匹配 问题描述：括号的使用必须遵循 “平衡”规则，即 首先，每个开括号要恰好对应一个闭括号； 其次，每对开闭括号要正确的嵌套 正确的括号：(()()()())，(((())))， (()((())())) 错误的括号：((((((())，()))，(()()(() 对括号是否正确匹配的识别，是很多语言编译器的基础算法 解题思路：从左到右扫描括号串，最新打开的左括号，应该匹配最先遇到的右括号 这样，第一个左括号（最早打开），就应该匹配 最后一个右括号（最后遇到） 这种次序反转的识别，正好符合栈的特性
栈的使用实例No.10
蒙强的博客
05-17 954
一、栈实现综合计算器（3+2*6-2） 创建两个栈numStack和operStack numStack存放数，operStack存放符号 计算表达式是一个字符串，头开始位置是0 如果发现扫描的是一个数字直接入数栈。 如果发现是一个运算符 如果operStack是一个空栈直接入栈如果operStack不是一个空栈 ...
三.栈与栈的实例——汉诺塔
知识宫殿
09-12 5799
1.栈 First In Last Out，顺序栈和链栈，六种方法，声明使用方式。 1.1 概论 栈，是一个先进先出的一个数据结构。如图： 1.2 顺序栈和链栈 顺序栈就是一般的栈。 链栈就是使用链表将栈存储起来的由上一元素的节点指向下一元素。 如图所示： 1.3 六种基本方法 构造空栈：初始化一个栈。 InitStack(S) 判断空：判断是否为空。StackEmpty(S) 判断满：判断是否
数据结构与算法之二（栈常见案例）
kkae8643150的专栏
02-07 2642
栈是一种常用数据结构，其特性是FILO（first in last out），其基本概念这里不做介绍，相信都学过了。直接食用java中已经封装好Stack<>类。栈的效率：入栈出栈复杂度为O(1)，不需要比较和移动操作。案例1：单词逆序 比如，输入alphago，要求逆向输出其结果：ogahpla。可以用栈来解决这类问题。 String word = "alphago"; Stac
Java编程：经典例题解析与实现
"这是一个关于Java编程的经典程序例题集合，涵盖了递归求解斐波那契数列、素数判断以及水仙花数的实现。" 在这些Java程序中，我们涉及了几个重要的编程知识点： 1. **递归**：在程序1中，计算兔子数量的问题...
评论 57
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

阿博历练记

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

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

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

打赏作者

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

抵扣说明：

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

余额充值