（第四章）堆栈

最新推荐文章于 2023-04-12 23:00:29 发布
最新推荐文章于 2023-04-12 23:00:29 发布
阅读量796 收藏 3
点赞数
分类专栏： 数据结构与算法 文章标签： 堆栈 线性结构 操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42072280/article/details/83661447
版权

目录

1.堆栈基本概念

2.堆栈的实现（线性存储方式）

3.堆栈的基本操作

（1）初始化堆栈

（2）销毁堆栈

（3）判栈空/满

（4）入栈

（5）出栈

（6）读栈顶元素的值

1.堆栈基本概念

堆栈是一种逻辑线性结构。其数据的操作是在一端进行的；其特点是：先进后出；堆栈具有“记忆性”，被广泛使用在操作系统软件、各种应用软件中，是一种非常常用且重要的数据结构。对于递归程序的非递归化，通常也是通过堆栈完成的。

 

如图所示：

                                            

malloc是在堆里面实现的

为了使堆栈的操作更加完整，更加符合系统堆栈的基本原则，不使用链的形式实现，依然选择数组来实现。

 

从上图可知，堆栈是由堆栈区域（存储区）和两个指针（栈顶指针、栈底指针）组成；如果用物理线性存储结构实现，则，栈顶和栈底指针实质上是数组下标。

 

对堆栈的数据操作只能在栈顶一端执行，且有两个操作：入栈、出栈。

堆栈的特点是先进后出，可见下图：

入栈过程：

                        

出栈过程：

明显的，B必须先出栈，A才能出栈；这就是先入后出！

2.堆栈的实现（线性存储方式）

typedef struct STACK{
    USER_TYPE *stack;
    int maxRoom;
    int top;
}STACK;

    

 

3.堆栈的基本操作

（1）初始化堆栈

考虑的问题：有没有参数、有几个参数、有没有返回值、返回值类型是什么

initStack()

 

问题1：形参STACk类型用*还是**

我们在定义了堆栈的数据结构之后，在主函数中引用堆栈时有两种方式：

 

initStack(STACK *head);

 

void main(void){
    STACK stack1;                //这种方式不符合以后各种语言的常态，Java所有类的对象都是指针。
 }

 

initStack(STACK **head);

void main(void){
     STACK *stack1 = NULL;        

    //别让它乱指，指向内存最开始的地方
    //这种方式的优势：想保护整个堆栈的方方面面，让思路和面向对象的思路保持一致，和C++很一致（以后都用这个）

}

问题2：有无返回值

 

STACK *initStack(STACK **head);

 

void main(void){
     STACK *stack1 = NULL;        
                                 

     stack1 = initStack(&stack1);  //这种方式会造成内存泄露，stack1先指向一个指针，后面初始化又指向另外一个指针
     stack1 = initStack(&stack1); //则第一块无法被操作，会造成内存泄露
}

 

void initStack(STACK **head);   //以后用这种方式

 

void main(void){
     STACK *stack1 = NULL;        
                                 

     initStack(&stack1);
     initStack(&stack1);
}

问题3：initStack(stack1) / initStack(&stack1)

 

 

问题4：形参个数一个够吗？

老师说不够，要再加一个个数   initStack(&stack1， 30)

此处，在课本和各种实验指导书上是用宏定义一个最大个数

自己理解：用宏定义的话申请空间申请的可能太多，所以自己加参数，按照自己的需要来，可以尽量节省空间。

 

问题5：每次申请都会成功吗？

不一定 如果是这样的话返回值就用boolean类型 

失败的情况：initStack(&stack1， -30)

理解：系统内部是会-30理解成一个很大的数，会按照那个很大的数申请一个很大的空间，故要对此进行控制

所以：boolean initStack(STACK **head, int maxRoom);  

 

此处一个小知识点：

boolean initStack(STACK **head, int maxRoom)；

主函数中：initStack(...);

不用         ok = initStack(...);

 

 

 

//经过各种考虑之后的最终代码

boolean initStack(STACK **head, int maxRoom){
    if(maxRoom <= 0 || *head != NULL){ //把下面那两个合并了
        return FALSE;
    }

/*
    if(*head != NULL){    //说明stack1这个指针已经指向一个堆栈了
        return FALSE;
    }
    
    if(maxRoom <= 0){
        return FALSE;
    }
*/

    (*head) = (STACK *)malloc(sizeof(STACK)); //申请控制头 

    (*head)->stack = (USER_TYPE *)malloc(sizeof(USER_TYPE) * maxRoom);
    (*head)->maxRoom = maxRoom;
    (*head)->top = 0;

 

    return TRUE;
}

 

void main(void){
    STACK *stack1 = NULL;        


    initStack(&stack1, 30);
}

 

 

（2）销毁堆栈

 

destroyStack(STACK *head);

 

void main(void){
    STACK *stack1 = NULL;       


    initStack(&stack1, 30);
    destroyStack(stack1);  //这样做可以释放stack1所指向的空间，但是stack1的值是不会变化的
}

 

destroyStack(STACK **head);

 

void main(void){
    STACK *stack1 = NULL;       


    initStack(&stack1, 30);
    destroyStack(&stack1);  //建议用这种形式
}

//经过各种考虑之后的最终代码

void destroyStack(STACK **head){
    if(*head == NULL || (*head)->stack == NULL){  //把下面那两个合并了
        return;
    } 
    //此处涉及短路运算
    //若前面那个成立(即*head == 0)，则不再进行后面的运算(如果还要操作的话，就会造成非法内存访问)

 

/*    
    if(*head == NULL){  //说明stack1哪都没有指向(说明没有初始化)，那就不用释放了
        return;
    }

    if((*head)->stack == NULL){  //说明控制头中的stack成员为空，没有指向，也就不用释放了
        return;
    }
*/

 

    free((*head)->stack);
    free(*head);

    *head = NULL;      //保证这个指针不再乱指
}

 

void main(void){
    STACK *stack1 = NULL;        


    initStack(&stack1, 30);

    //...各种操作

    destroyStack(&stack1); //建议用这种类型
}

 

 

 

 

（3）判栈空/满

boolean isStackFull(STACK head){
    return (head.top == head.maxRoom);  //return (head.top >= head.maxRoom);  
}

 

boolean isStackEmpty(STACK head){
    return head.top == 0;  
    //return head.top <= 0;  怕写错了,可以写成这种形式，因为不一定每次都可以写成两个等于
    //return !head.top;   这种形式应该也可以
    
/*
    if(head.top == 0){
        return TRUE;
    }
    return FALSE;
*/
}

 

（4）入栈

 

 

 

boolean push(STACK *head, USER_TYPE value){
//关于此处是用STACK head   STACK *head   STACK **head  如何考虑
//最根本的是要考虑需要修改哪一块的值，然后主函数传递该块的指针，子函数形参的指类就是该块
//此处首先要修改stack指针所指向的空间(因为要push数据)，其次要修改top的值，所以主函数应该传递STACK类型的地址，而子函数应该是STACK *

 

   if(head == NULL || isStackFull(*head)){  //把下面那两个合并了
        return FALSE;
    } 

/*    
    if(head == NULL){  //说明没有初始化
        return FALSE;
    }

    if(isStackFull(*head)){  //说明堆栈已经满了，无法进行push操作
        return FALSE;
    }
*/
    head->stack[head->top++] = value;
    return TRUE;
}

 

 

 

（5）出栈

 

 

//正确形式

boolean pop(STACK *head, UESR_TYPE *valuePoint){  //我们是想通过这个操作取一个值

    if(head == NULL || isStackEmpty(*head)){  //把下面那两个合并了
        return FALSE;
    } 


    *valuePoint = head->stack[--head->top];

}

 

void main{

   STACK *stack1 = NULL;
    POINT point = {1, 1};

    initStack(&stack1, 30);
    push(stack1, point);    //把这个点放进堆栈里 push的时候把point的值复制一份，把复制本给value
    pop(stack1, &point);   //  目的：通过pop操作把这个点取出来
  }

 

//错误形式

boolean pop(STACK *head, UESR_TYPE valuePoint){  //我们是想通过这个操作取一个值

    if(head == NULL || isStackEmpty(*head)){  //把下面那两个合并了
        return FALSE;
    } 


    valuePoint = head->stack[--head->top];

}

 

void main{

   STACK *stack1 = NULL;
    POINT point = {1, 1};

    initStack(&stack1, 30);
    push(stack1, point);    //把这个点放进堆栈里  push的时候把point的值复制一份，把复制本给value
    pop(stack1, point);   //  目的：通过pop操作把这个点取出来
  }

 

说明为什么此处用UESR_TYPE *类型
假设用 pop(stack1, point); 
pop的时候如果不加&，则valuePoint的值是point值的复制本，这两个空间没有任何关系，所以取出来的值放到valuePoint里，根本就无法放进point里，故要通过传址的方式来进行。

 

//经过各种考虑之后的最终代码

boolean pop(STACK *head, USER_TYPE *valuePoint){    //我们是想通过这个操作取一个值
//关于boolean类型如何理解：pop操作可能失败
    if(head == NULL || isStackEmpty(*head)){  //把下面那两个合并了
        return FALSE;
    } 

/*    
    if(head == NULL){  //说明没有初始化
        return FALSE;
    }

    if(isStackEmpty(*head)){  //说明堆栈是空的，无法进行pop操作
        return FALSE;
    }
*/
    *valuePoint = head->stack[--head->top]; //把取出来的值放到valuePoint所指向的空间
    return TRUE;

}

 

 

 

 

（6）读栈顶元素的值

 

问题：考虑用什么返回值类型

 

USER_TYPE readTop(STACK head){

    if(栈非空){
        return head.stack[top-1];
    }
    if(栈为空){
        //一般思维是返回一个非正常值 但是该值无法确定用什么合适，故不用此种类型
    }
}

 

 

boolean readTop(STACK head, USER_TYPE *valuePoint){
    //此处不用做像前面的那样考虑是否为NULL，
    //因为前面考虑是因为参数传入的是指向控制头的指针，我们判断其是否为空来判断是否初始化
    //此处直接传的就是控制头，所以必定已经初始化了

    if(isStackEmpty(head)){
        return FALSE;
    }

    *valuePoint = head.stack[head.top - 1];
    return TRUE;
    //*valuePoint = head.stack[--head.top];  
    //这样写也可以，因为形参里面传的是控制头的复制本，并不会改变原来控制头的值(机智如你)
}


/*
堆栈的基本操作:
1、初始化（构造）堆栈；
2、销毁（析构）堆栈；
3、判栈空；
4、判栈满；
5、入栈；
6、出栈；
7、读栈顶元素。
*/

#include<stdio.h>
#include<malloc.h>

typedef unsigned char boolean;
#define  TRUE   1
#define  FALSE  0

//typedef unsigned int size_t;

//定义USER_TYPE
typedef struct POINT{   
	int row;
	int col;
}POINT, USER_TYPE;

//定义数据结构
typedef struct STACK{
	USER_TYPE *stack;
	int maxRoom;
	int top;
}STACK;

boolean initStack(STACK **head, int maxRoom);
void destroyStack(STACK **head);
boolean isStackEmpty(STACK head);
boolean isStackFull(STACK head);
boolean push(STACK *head, USER_TYPE value);
boolean pop(STACK *head, USER_TYPE *valuePoint);
//USER_TYPE readTop(STACK head);
boolean readTop(STACK head, USER_TYPE *valuePoint);
void showStackElement(STACK head);


void showStackElement(STACK head){
	int i;

	if(isStackEmpty(head)){
		return;
	}
	for(i = 0; i < head.top; i++){
		printf("(%d,%d) ", head.stack[i].row, head.stack[i].col);
	}
	printf("\n");

}


boolean readTop(STACK head, USER_TYPE *valuePoint){
	//此处不用做像前面的那样考虑是否为NULL，
	//因为前面考虑是因为参数传入的是指向控制头的指针，我们判断其是否为空来判断是否初始化
	//此处直接传的就是控制头，所以必定已经初始化了

	if(isStackEmpty(head)){
		return FALSE;
	}

	*valuePoint = head.stack[head.top - 1];
	return TRUE;
	//*valuePoint = head.stack[--head.top];  
	//这样写也可以，因为形参里面传的是控制头的复制本，并不会改变原来控制头的值(机智如你)

/*
USER_TYPE readTop(STACK head){

	if(栈非空){
		return head.stack[top-1];
	}
	if(栈为空){
		//一般思维是返回一个非正常值 但是该值无法确定用什么合适，故不用此种类型
	}
}
*/
}

boolean pop(STACK *head, USER_TYPE *valuePoint){  //我们是想通过这个操作取一个值
//关于boolean类型如何理解
//pop操作可能失败
	if(head == NULL || isStackEmpty(*head)){  //把下面那两个合并了
		return FALSE;
	} 

/*	
	if(head == NULL){  //说明没有初始化
		return FALSE;
	}

	if(isStackEmpty(*head)){  //说明堆栈是空的，无法进行pop操作
		return FALSE;
	}
*/
	*valuePoint = head->stack[--head->top];
	return TRUE;

}

boolean push(STACK *head, USER_TYPE value){
//关于此处是用STACK head   STACK *head   STACK **head  如何考虑
//最根本的是要考虑需要修改哪一块的值，然后主函数传递该块的指针，子函数形参的指类就是该块
//此处首先要修改stack指针所指向的空间(因为要push数据)，其次要修改top的值，所以主函数应该传递STACK类型的地址，而子函数应该是STACK *

	if(head == NULL || isStackFull(*head)){  //把下面那两个合并了
		return FALSE;
	} 

/*	
	if(head == NULL){  //说明没有初始化
		return FALSE;
	}

	if(isStackFull(*head)){  //说明堆栈已经满了，无法进行push操作
		return FALSE;
	}
*/
	head->stack[head->top++] = value;
	return TRUE;
}

boolean isStackFull(STACK head){
	return (head.top == head.maxRoom);  //return (head.top >= head.maxRoom);  
}

boolean isStackEmpty(STACK head){
	return head.top == 0;  
	//return head.top <= 0;  怕写错了,可以写成这种形式，因为不一定每次都可以写成两个等于
	//return !head.top;   这种形式应该也可以
	
/*
	if(head.top == 0){
		return TRUE;
	}
	return FALSE;
*/
}

void destroyStack(STACK **head){
	if(*head == NULL || (*head)->stack == NULL){  //把下面那两个合并了
		return;
	} 
	//此处涉及短路运算
	//若前面那个成立(即*head == 0)，则不再进行后面的运算(如果还要操作的话，就会造成非法内存访问)

/*	
	if(*head == NULL){  //说明stack1哪都没有指向(说明没有初始化)，那就不用释放了
		return;
	}

	if((*head)->stack == NULL){  //说明控制头中的stack成员为空，没有指向，也就不用释放了
		return;
	}
*/

	free((*head)->stack);
	free(*head);

	*head = NULL;      //保证这个指针不再乱指
}

boolean initStack(STACK **head, int maxRoom){
	if(maxRoom <= 0 || *head != NULL){ //把下面那两个合并了
		return FALSE;
	}

/*
	if(*head != NULL){
		return FALSE;
	}
	
	if(maxRoom <= 0){
		return FALSE;
	}
*/

	(*head) = (STACK *)malloc(sizeof(STACK)); //申请控制头 

	(*head)->stack = (USER_TYPE *)malloc(sizeof(USER_TYPE) * maxRoom);
	(*head)->maxRoom = maxRoom;
	(*head)->top = 0;

	return TRUE;
}


void main(void){
	//STACK stack1;                //这种方式不符合以后各种语言的常态，Java所有类的对象都是指针。
	STACK *stack1 = NULL;         //别让它乱指
	                              //这种方式的优势：想保护整个堆栈的方方面面，让思路和面向对象的思路保持一致，和C++很一致
	USER_TYPE point1 = {1, 1};    //push进去的值
	USER_TYPE point2 = {2, 2};    //push进去的值
	USER_TYPE point3;             //读栈顶的值
	USER_TYPE point4;             //pop出来的值


	initStack(&stack1, 30);
	printf("初始化后堆栈里面的元素有：\n");
	showStackElement(*stack1);

	push(stack1, point1);
	printf("push操作之后堆栈里面的元素有：");
	showStackElement(*stack1);

	push(stack1, point2);
	printf("push操作之后堆栈里面的元素有：");
	showStackElement(*stack1);

	readTop(*stack1, &point3);
	printf("栈顶的元素为：(%d,%d)\n", point3.row, point3.col);

	pop(stack1, &point4);
	printf("pop操作之后堆栈里面的元素有：");
	showStackElement(*stack1);

	destroyStack(&stack1); //建议用这种类型




}
//sizeof运算符返回的是一个无符号整型 系统定义了一个unsigned int 型的类型，叫size_t

 

安安csdn
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【c++】——函数的堆栈调用详细过程
qq_43412060的博客
03-19 2212
这篇文章，主要在汇编的角度为大家详细讲解函数的堆栈调用过程，首先我们引人一段程序，主要由此程序作为例子分析~ #include<iostream> #include<string.h> using namespace std; int sum(int a, int b) { int temp = 0; temp = a + b; return temp; } int ...
解析函数的堆栈调用过程
magic_world_wow的博客
06-17 804
关于函数的调用堆栈有如下几个问题： 函数调用函数的栈桢开辟及回退过程是什么？ 主调函数在调用被调函数的中间过程做了什么？ 被调函数执行完成后是怎样回到主调函数的？ 在回到主调函数后是怎么知道要运行哪一条代码（指令）？ 要解决这些问题，我们就要从汇编的角度切入。通过汇编代码能够使我们更加清晰地掌握函数的堆栈调用。 汇编分为两种形式inter x86 （从右向左看） 和 AT&amp...
函数的调用堆栈过程
iMEANT的博客
04-03 516
代码块 int sum(int a,int b) { int temp=0; temp=a+b; return temp; } int main() { int x=10; int y=20; int ret=sum(x,y); printf(“ret=%d\n”,ret); return 0; } ...
函数的调用堆栈详细过程
qq_55185342的博客
10-30 917
函数的调用堆栈详细过程
堆栈的详细讲解
ky_zhang的博客
03-08 4795
堆栈是一个先进后出的数据结构，栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程，以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定，这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的，前者由被调函数调整堆栈，后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这段代码...
单片机第四章选择.docx
12-14
本章节主要讲解了单片机的第四章选择相关知识点，涵盖了单片机的基本知识、寄存器、地址锁存器、EPROM、堆栈、程序计数器、加法器寄存器、运算器控制器、运算器寄存器、运算器指令译码器、串行数据缓冲器、加法器...
微型计算机原理第四章完整.pptx
11-17
微型计算机原理第四章汇编语言程序设计 微型计算机原理第四章汇编语言程序设计讲解了汇编语言的基本概念和结构。汇编语言是一种用助记符表示指令，用标号或符号代替地址、常量和变量的符号化语言。汇编语言源程序需...
计算机系统结构第四章PPT资料.pptx
11-30
"计算机系统结构第四章PPT资料.pptx" 计算机系统结构第四章主要讲述了存贮体系的基本概念、并行主存系统的组成、虚拟存贮器的原理、Cache存贮器的原理、虚实地址的映象和变换、替换算法、影响性能的因素分析等。 1...
计算机组成原理完整第4章PPT课件.ppt
11-15
"计算机组成原理完整第4章PPT课件.ppt" 计算机组成原理是计算机科学中的一门基础课程，本章节主要讲述指令系统的相关知识点。 4.1 指令系统的发展和性能要求 指令系统是计算机系统的核心部分，它直接影响着计算机...
数据结构第三章作业答案参考（C语言）
02-06
1.下面的算法是将一个整数e压入堆栈S，请在空格处填上适当的语句实现该操作。 typedef struct{ int *base; int *top; int stacksize; }SqStack; int Push(SqStack S,int e) { if ( S.top- S.base>= S.stack...
堆栈的原理解析学习笔记
jacklin_01的博客
08-13 1252
每一个使用c语言的都应该知道栈的重要性，我们能够使用C/C++语言写出诸多复杂的程序，很大功劳一部分有归于栈的实现，因为它可以帮助我们实现函数间的嵌套调用。 汇编程序的运行是不需要栈的，所以注定它函数的嵌套层数不会太多，一般是父函数调用子函数，然后在子函数就返回了，很少见到子函数还会调用孙子函数的情况。这是由它的语言特性决定的。因为每当汇编语言调用子函数时，就会将返回的PC地址保存在LR中， 如果子函数还要调用孙子函数，那么执行时也会将子函数的返回地址保存在LR中，这时如果要返回父函数，就需要将返回父PC
从汇编指令角度掌握函数调用堆栈详细过程
weixin_73567058的博客
04-12 1428
函数调用堆栈是计算机科学中的重要概念，它用于存储函数调用和返回的过程中的临时数据。在本篇博客中，我们将从汇编指令角度来详细介绍函数调用堆栈的过程，并通过汇编代码和图示来帮助您更好地理解。
堆栈详解
热门推荐
大西瓜不甜的博客
11-10 3万+
一 首先介绍下堆和堆栈（堆栈）的是什么，区别是什么？ 注意，其实堆栈本身就是栈（stack）。通俗易懂说，堆栈==栈， 堆==堆（heap） 1.堆：什么是堆？又该怎么理解呢？ 答：1，堆（heap）是一种数据结构，堆控制一段自己的存储空间，叫做堆空间。 2，堆是在程序运行时申请的动态内存，而不是在程序编译时，申请某个大小的内存空间。 3，堆是应用程序在运行的时候请求操作系统分配给自己内存，一般是申请/给予的过程。 2. 栈（堆栈）：什么是堆栈？又该怎么理解呢？ ...
堆栈的基本操作
教主的博客
10-11 916
堆栈的基本操作 typedef int Stack_ElemType; typedef struct Stack{ Stack_ElemType *base; Stack_ElemType *top; int stack_size; // stack_size represents the max number of elements that can be stored in the stack, which equals to the STACK_INIT_SIZE int stack_length;
堆、栈的概念及使用特性
fengdijiang的专栏
07-03 1477
堆和栈是一个统称，可以有很多的实现方式。计算机程序通常有一个栈叫做调用栈，用来存储当前函数调用相关的信息（比如：主调函数的地址，局部变量），因为函数调用之后需要返回给主调函数。栈通过扩展和收缩来承载信息。实际上，程序不是由运行时来控制的，它由编程语言、操作系统甚至是系统架构来决定。堆是在任何内存中动态和随机分配的（内存的）统称；也就是无序的。内存通常由操作系统分配，通过应用程序调用 API 接口去实现分配。在管理动态分配内存上会有一些额外的开销，不过这由操作系统来处理。 它们的大小由什么决定？ 　　依赖
堆栈的概念
程序猿养成记
10-20 930
堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场。要点：堆，队列优先,先进先出（FIFO—first in first out）。栈，先进后出(FILO—First-In/Last-Out)。 堆栈空间分配  栈（操作系统）：由操作系统自动分配释放 ，存放
堆栈概念
闪星的博客
12-08 1046
堆栈是两种数据结构，堆栈都是一种数据项按序排列的数据结构，只能在一端对数据项进行插入和删除。堆，队列优先,先进先出（FIFO—first in first out） 。栈，先进后出(FILO—First-In/Last-Out)。堆栈空间分配： 栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。 堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS
堆栈概念及区别
风起云涌Hal的专栏
10-02 665
在计算机领域，堆栈是一个不容忽视的概念，堆栈是两种数据结构。堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场。 　　堆栈是一个在计算机科学中经常使用的抽象数据类型。堆栈中的物体具有一个特性： 最后一个放入堆栈中的物体总是被最先拿出来， 这个特性通常称为后进先出(L
堆栈介绍.
LQ20001202的博客
07-31 369
堆是一块内存区域，在堆里可以分配大块的内存用于存储某种类型的数据对象。与栈不同，堆里的内存。引用类型的变量存储对其数据（对象）的引用，而值类型的变量直接包含其数据。而类的方法是所有的对象共享的，方法是存在方法区的，值类型作为方法中的局部变量时，在栈中分配，而作为类的成员变量时，在堆中分配；中只要是成员变量，一旦它所在类被实例化后，都是作为一个整体放在堆内存的，不管它是值类型。个变量都具有其自己的数据副本，对一个变量执行的操作不会影响另一个变量（某些类型变量的值、程序当前的执行环境、传递给方法的参数。...
第四章-算法思维-4.2 递归函数
最新发布
05-12
此外，递归函数可能会导致栈溢出的问题，因为每一次递归调用都会将函数栈帧压入堆栈中，如果递归的深度太大，就会导致堆栈溢出。 因此，在编写递归函数时，需要考虑好递归的出口条件，并且需要测试递归函数的性能和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

安安csdn

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

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

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

打赏作者

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

抵扣说明：

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

余额充值