精华内容
下载资源
问答
  • 大体框架来自数据结构课本,本人稍做修改。废话不多说上代码。 #include<stdio.h> #include<windows.h> #define MAXSIZE 100 typedef int ElemType;... //栈空间 int top; //栈顶指示 ...
    	大体框架来自数据结构课本,本人稍做修改。废话不多说上代码。
    
    #include<stdio.h>
    #include<windows.h>
    #define MAXSIZE 100
    typedef int ElemType;
    
    typedef struct Stack
    {
    	ElemType data[MAXSIZE];  //栈空间
    	int top;				//栈顶指示
    }SeqStack;
    void Init_SeqStack(SeqStack* s);  //初始化顺序栈
    int Empty_SeqStack(SeqStack* s);  //判断顺序栈是否为空
    int Push_SeqStack(SeqStack *s,ElemType x); //顺序栈入栈
    void PrintStack(SeqStack *s);     //输出顺序栈操作
    int Pop_SeqStack(SeqStack* s,ElemType* x);    //顺序栈出栈操作
    
    int main()
    {
    	ElemType x;
    	SeqStack s;
    	Init_SeqStack(&s);
    	Push_SeqStack(&s,1);
    	Push_SeqStack(&s,2);
    	Push_SeqStack(&s,3);
    	printf("\n入栈后的顺序栈为:\n");
    	PrintStack(&s); 
    	printf("\n");
    	Pop_SeqStack(&s,&x);
    	Pop_SeqStack(&s,&x);
    	Pop_SeqStack(&s,&x);
    	printf("\n出栈后的顺序栈为:\n");
    	PrintStack(&s); 
    }
    
    
    /*======================
    函数功能:顺序栈空栈
    函数输入:顺序栈地址
    函数输出:无
    =======================*/
    void Init_SeqStack(SeqStack* s)
    {
    	s->top=-1;
    }
    /*======================
    函数功能:判断顺序栈是否为空
    函数输入:顺序栈地址
    函数输出:1——栈空;2——栈非空
    =======================*/
    int Empty_SeqStack(SeqStack* s)
    {
    	if(s->top==-1)
    		return 1;
    	else
    		return 0;
    }
    /*=======================
    函数功能:顺序进栈操作
    函数输入:数学栈地址,进栈元素值
    函数输出:0——栈上溢,操作失败;1——操作正常
    ========================*/
    int Push_SeqStack(SeqStack *s,ElemType x)
    {
    	if(s->top==MAXSIZE-1)	return 0;//栈满
    	else
    	{
    		s->top++;
    		s->data[s->top]=x;
    		printf("%4d入栈",s->data[s->top]);
    	}
    	return 1;
    }
    /*=======================
    函数功能:顺序栈输出
    函数输入:顺序栈地址
    函数输出:无
    ========================*/
    void PrintStack(SeqStack *s)
    {
    	int i;
    	if(Empty_SeqStack(s)==1)    //栈空不能输出
    	{
    		printf("顺序栈为空\n");
    		exit(1);
    	}
    	else
    	{
    		for(i=s->top;i>=0;i--)
    			printf("%4d",s->data[i]);
    	}
    }
    /*=======================
    函数功能:顺序出栈操作
    函数输入:顺序栈地址,出栈元素地址
    函数输出:0——栈下溢,操作失败;1——操作正常
    ========================*/
    int Pop_SeqStack(SeqStack*s,ElemType* x)
    {
    	if(Empty_SeqStack(s)==1)return 0;
    	else
    	{
    		printf("%4d出栈",s->data[s->top]);
    		*x=s->data[s->top];
    		s->top--;
    	}
    }
    

    运行结果
    在这里插入图片描述
    第一次写博客,有诸多不完善之处,若有误,斧正。

    展开全文
  • 顺序栈的函数源码 #include <stdio.h> #include <stdbool.h> #include <stdlib.h>...功能:顺序栈函数的使用 ...在顺序栈中:我们主要讨论顺序栈初始化,栈空,栈满,入栈,出栈,遍历

    顺序栈的函数源码

    #include <stdio.h>
    #include <stdbool.h>
    #include <stdlib.h>
    
    /*
    功能:顺序栈函数的使用
    栈的数据只能够通过栈顶去操作
    顺序栈是通过创建一个管理结构体的方式,去管理一个数组
    管理结构体中包含:指向数组首地址的指针*stack_arr, 数组的大小size, 栈顶相对于栈底的偏移量top(起始为-1,满为size-1)
    在顺序栈中:我们主要讨论顺序栈的 初始化,栈空,栈满,入栈,出栈,遍历
    */
    
    typedef int DATATYPE;
    
    typedef struct BOSS             //创建顺序栈的管理结构体
    {
    	DATATYPE *staff_arr;    //定义一个指向数组首地址的指针
    	DATATYPE size;          //定义数组的最大长度
    	DATATYPE top;		//定义栈顶相对于栈底的偏移量(起始为-1,满为size-1)
    	
    }Boss, *Boss_p;                 //为管理结构体创建一个别名,和指针类型别名
    
    
    Boss_p init(DATATYPE size);             // 1.初始化管理结构体
    bool is_empty(Boss_p s);		// 2.栈空判断
    bool is_full(Boss_p s);			// 3.栈满判断
    bool push(Boss_p s, DATATYPE n);        // 4.顺序栈入栈
    bool pop(Boss_p s, DATATYPE *n);        // 5.顺序栈出栈
    void display(Boss_p s);                 // 6.顺序栈的遍历
    
    
    int main(int argc, char const *argv[])
    {
    	/*int n,temp;
    	Boss_p boss = init(10);         //初始化栈的大小为10个整型空间
    	for (int i = 0; i < 10; ++i)
    	{
    		push(boss, i+1);        //初始化数据为1-10
    	}
    	display(boss);
    	printf("按1出栈\n");
    	scanf("%d",&n);
    	if (n == 1)
    	{
    		pop(boss, &temp);       //向出栈的函数中传入变量的地址,用于获取出栈元素
    		printf("出栈元素为:%d\n", n);
    	}
    	display(boss);*/
    	
    
    	printf("Cai_grass的博客--所有代码已验证,可直接运行\n");
    	return 0;
    }
    
    
    // 1.初始化管理结构体
    Boss_p init(DATATYPE size)
    {
    	Boss_p s = malloc(sizeof(Boss));     //为管理结构体申请空间
    	if (s != NULL)
    	{                                    //管理结构体空间申请成功后,再为数组申请空间
    		s->staff_arr = calloc(size, sizeof(DATATYPE));
    		s->size = size;              //size 表示数组的最大容纳量
    		s->top = -1;                 //偏移量为-1,表示指向栈底
    		return s;
    	}
    	return NULL;
    }
    
    // 2.栈空判断
    bool is_empty(Boss_p s)
    {
    	return (s->top == -1);
    }
    
    // 3.栈满判断
    bool is_full(Boss_p s)
    {
    	return (s->top == s->size-1);
    }
    
    // 4.顺序栈入栈
    bool push(Boss_p s, DATATYPE n)
    {
    	if (is_full(s))             //如果栈已经满了,入栈失败
    	{
    		return false;
    	}
    	s->top++;		    //栈没满的话,就栈顶往后移,为新的元素让出空间
    	s->staff_arr[s->top] = n;   //用数组的方式去赋值
    	return true;
    }
    // 5.顺序栈出栈
    bool pop(Boss_p s, DATATYPE *n)     //n是用来获取出栈元素的
    {
    	if (is_empty(s))            //如果栈空,出栈失败
    	{
    		return false;
    	}
    	*n = s->staff_arr[s->top];  //用传入的形参获取到出栈元素,也可以不用,直接打印
    	s->top--;                   //元素减少一个,栈顶指针偏移减一
    
    }
    
    // 6.顺序栈的遍历
    void display(Boss_p s)              //因为顺序栈管理的是数组,通过数组的方式去遍历即可
    {
    	for (int i = 0; i < s->top+1; ++i)      //栈顶指针的偏移量+1,就是元素的个数
    	{
    		printf("%d\t", s->staff_arr[i]);
    	}
    	printf("\n");
    
    }
    

     

    展开全文
  • 顺序栈-初始化栈顶指针-11.头文件及类型定义2.顺序栈类型定义3.函数声明4.基本操作4.1 初始化顺序栈4.2 判空4.3 入栈4.4 出栈4.5 读取栈顶元素4.6 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #...

    1.头文件及类型定义

    #include<stdio.h>
    #define MaxSize 10			//定义顺序栈中元素的最大个数
    #define ElemType int			
    

    2.顺序栈类型定义

    typedef struct {		
    	ElemType data[MaxSize];		//静态数组存放栈中元素
    	int top;					//栈顶指针,一般来说存放数组的下标
    }SeqStack;
    

    3.函数声明

    /*函数声明*/
    void InitStack(SeqStack& S);				//1.初始化顺序栈
    bool StackEmpty(SeqStack S);				//2.判空
    bool Push(SeqStack& S, ElemType x);			//3.入栈
    bool Pop(SeqStack& S, ElemType& x);			//4.出栈
    bool GetTop(SeqStack S, ElemType& x);		//5.读取栈顶元素
    

    4.基本操作

    4.1 初始化顺序栈

    //1.初始化栈
    void InitStack(SeqStack& S) {
    	S.top = -1;		//初始化栈顶指针为-1
    }
    

    4.2 判空

    //2.判空
    bool StackEmpty(SeqStack S) {
    	return (S.top == -1);
    }
    

    4.3 入栈

    //3.入栈操作:新元素入栈(先加再存)
    bool Push(SeqStack& S, ElemType x) {
    	if (S.top == MaxSize - 1)		//栈满,报错
    		return false;
    	S.top++;		//栈顶指针先加1
    	S.data[S.top] = x;	//新元素再入栈:在栈顶指针所指位置放入x
    	/*
    		以上两句与此句等价:S.data[++S.top] = x;
    		请注意是++S.top,而不是S.top++
    	*/
    	return true;
    }
    

    4.4 出栈

    //4.出栈操作:栈顶元素出栈(先取再减)-栈顶元素只是逻辑上被删除了,实际上还残留在内存中
    bool Pop(SeqStack& S, ElemType &x) {
    	if (S.top == -1)		//栈空,报错
    		return false;
    	x = S.data[S.top];		//栈顶元素先出栈:返回栈顶元素的值x
    	S.top--;				//指针指针再减1
    	/*
    		以上两句与此句等价:x = S.data[S.top--];
    		请注意是S.top--,而不是--S.top,注意与上面的入栈操作对比
    	*/
    	return true;
    }
    

    4.5 读取栈顶元素

    //5.读取栈顶元素操作
    bool GetTop(SeqStack S, ElemType &x) {
    	if (S.top == -1)		//栈空,报错
    		return false;
    	x = S.data[S.top];		//与出栈操作唯一的区别:仅返回栈顶元素,栈顶指针并不减1
    	return true;
    }
    

    4.6 main函数

    int main() {
    	SeqStack S;		//声明一个顺序栈(分配内存空间)
    
    	/*1、初始化栈*/
    	InitStack(S);	
    
    	/*2、判空*/
    	if (StackEmpty(S))
    		printf("当前栈空!\n");
    	else
    		printf("当前栈非空!\n");
    
    	/*3、入栈操作*/
    	ElemType e1;
    	printf("请输入入栈元素的值:");
    	scanf("%d", &e1);
    	if (Push(S, e1))
    		printf("新元素入栈成功!\n");
    	else
    		printf("栈已满,新元素入栈失败!\n");
    
    	/*4、读取栈顶元素*/
    	ElemType e2 = -1;
    	if (GetTop(S, e2))
    		printf("读取栈顶元素成功,当前栈顶元素值为:%d\n", e2);
    	else
    		printf("栈已空,读取栈顶元素失败!\n");
    
    	/*5、出栈操作*/
    	ElemType e3 = -1;
    	if (Pop(S, e3))
    		printf("栈顶元素出栈成功,出栈元素值为:%d\n", e3);
    	else
    		printf("栈已空,栈顶元素出栈失败!\n");
    
    	/*6、读取栈顶元素*/
    	ElemType e4 = -1;
    	if (GetTop(S, e4))
    		printf("读取栈顶元素成功,当前栈顶元素值为:%d\n", e4);
    	else
    		printf("栈已空,读取栈顶元素失败!\n");
    
    	return 0;
    }
    

    5.小结

    1. 栈的定义及操作特性
      (1)栈的本质仍然为线性表,只不过是一种操作受限的线性表,只允许在一端进行插入或者删除操作。同线性表类似,它也有两种存储方式:顺序存储链式存储,将在接下来的文章中继续讨论。
      (2)栈的操作特性为后进先出(LIFO,Last In First Out)
    2. 栈的基本操作
      因为操作受限,所以栈的操作相比于线性表来说也少一点,常用如下:
      (1)初始化
      (2)判空
      (3)入栈
      (4)出栈
      (5)获取栈顶元素
    3. 说明
      本文先介绍栈的顺序存储,即顺序栈。由于顺序栈是由数组实现的,所以在操作时要注意数组下标和和栈顶指针的关系,。另外,注意i++(先用再加)和++i(先加再用)的区别。
    展开全文
  • printf("请输入一个整数\n"); scanf("%d",&d); v[k]=d; *n=k; } else printf("空间已满!\n"); } //出栈函数 void pop_sq_LList(int* v,int m, int* n){ int k=*n; if(k) printf("栈为空!\...
  • 此代码可以正确运行,是实实在在的类C语言 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 typedef int SElemType; typedef struct { SElemType *base;... //空间大小 ...

    此代码可以正确运行,是实实在在的类C语言

    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 100
    typedef int SElemType;
    typedef struct
    {
    	SElemType *base;  //起始地址
    	SElemType *top;
    	int stacksize;  //空间大小  eg,a[100]
    }SqStack;
    enum Status{ERROR,OK};
    enum BOOL{FALSE,TRUE};
    
    //顺序栈初始化1
    Status InitStack(SqStack &S) //因为是顺序,单向传递,所以必须有&  LinkList 不一定有
    {
    	S.base=new SElemType[MAXSIZE];  //申请空间
    	//S.base = (SElemType *)malloc(MAXSIZE* sizeof(SElemType));
    	if(!S.base)  //申请失败
    		return ERROR;
       S.top=S.base;
       S.stacksize=MAXSIZE;
       return OK;
    }
    
    
    //判断顺序栈是否为空
    Status StackEmpty(SqStack S)
    {
    	if(S.top==S.base)
    		return OK;
    	else
    		return ERROR;
    }
    
    //求顺序栈的长度
    int  StackLength(SqStack S) 
    {
    	return S.top-S.base;   //实际元素
    }
    
    //清空顺序栈  --回到初始状态
    Status ClearStack(SqStack &S)
    {
    	if(S.base)
    		S.top=S.base;   //强制修改top,因为base始终指向底端
    	return OK;
    }
    
    //销毁顺序栈 1--释放空间
    Status DestoryStack(SqStack &S)
    {
    	if(S.base)
    	{
    		delete  S.base;  //free 和malloc,delete 和new
    		S.stacksize=0;
    		S.base=S.top=NULL;  //重新指向空指针
    	}
    	return OK;
    }
    
    //销毁栈2
    Status StackDestroy(SqStack &S)
    {
    	free(S.base);
    	S.base = NULL;
    	S.top = NULL;
    	S.stacksize = 0;
    	printf("销毁成功\n");
    	return OK;
    }
    
    //顺序栈进栈
    Status Push(SqStack &S,SElemType e)
    {
    	if(S.top-S.base==S.stacksize)  //距离==空间  -》栈满
    		return ERROR;
    	*S.top=e;     //*S.top++=e;  元素e压入栈顶
    	S.top++;  //栈顶指针加1
    	return OK;
    }
    
    //顺序栈出栈
    Status Pop(SqStack &S,SElemType &e)
    {
    	if(S.top==S.base) //栈空
    		return ERROR;
    	S.top--;
    	e=*S.top;  //e=*--S.top;
    	return OK;
    }
    
    //取顺序栈栈顶元素
    Status GetTop(SqStack S,SElemType &e)
    {
    	if(S.top==S.base)
    		return ERROR;  //栈空
        e=*(S.top-1);   //e=*--S.top;
    	return OK;
    }
    
    
    main()
    {
    	SqStack S;
    	typedef int SElemType;    
    	SElemType e;
    	if(InitStack(S))//枚举类型的接收值为真假
    	{
    		for(int i=1;i<5;i++)
    		{
    			scanf("%d",&e);
                Push(S,e);  //指向4上面  
    		}
    	}
    	printf("顺序栈长度:%d\n",StackLength(S));
       	GetTop(S,e); 
    	printf("取栈顶元素:%d\n",e);
    
        while(S.top!=S.base)
    	{
    		Pop(S,e);
    		printf("%d \n",e);  //逆置!
    	}
    
    
    	ClearStack(S);
    	printf("此时长度为:%d\n",StackLength(S));
    	StackDestroy(S);
    	
    return 0;
    }
    
    
    
    展开全文
  • 数据结构(C语言版)实现顺序栈的创建,初始化,赋值随机数,入栈,出栈,获取栈顶元素,输出 1.栈: 栈是种运算受限的线性表,是种先进后出的数据结构,限定只能在一端进行插入和删除操作,允许操作的一端称为...
  • 顺序栈的基本操作1 . 顺序栈的定义2 . 初始化new和exit的用法new的用法:exit的用法:3 . 入栈(压栈)4 . 出栈5 . 取栈顶元素四 . 链栈的基本操作1 . 链栈的定义2 . 初始化3 . 入栈4 . 出栈5 . 取栈顶元素五 . ...
  • 顺序栈的结构类型定义常见并要求我们掌握的有三种: 栈是种特殊的线性表,其特殊性在于限定仅在表尾进行插入和删除操作 线性表的顺序存储结构是指用段地址连续的存储单元次存储线性表的数据元素(类似数组定义...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    一个静态方法内调用一个非静态成员什么是非法的? 什么是方法的返回值?返回值的作用是什么? 内部类 什么是内部类? 内部类的分类有哪些 静态内部类 成员内部类 局部内部类 匿名内部类 内部类的优点 内部类有...
  • 顺序栈/链式栈

    千次阅读 2018-04-09 00:30:44
    栈是是种限定性的线性表,它将线性表的插入和删除限定仅在表的一端进行。将表中允许插入和删除的一端成为栈顶。...顺序栈 它与顺序表类似,即用组地址连续的空间存放栈中的元素。之前的...
  • 栈结构之顺序栈详解(C语言版)

    千次阅读 2020-10-24 16:40:35
    本文对栈结构的顺序栈进行详解并使用C语言对顺序栈进行实现,文章的主要内容包括顺序栈的定义、顺序栈的结构以及顺序栈的常用操作
  • 看一下关于栈的思维导图 栈是只允许在一端进行插入或删除操作的线性表,按照物理结构的不同,栈又分为顺序栈和链栈。 本篇文章是顺序栈的专场。 来看实现各个功能的代码块 ...//初始化栈 void InitStack(SqStack &
  • C语言实现顺序栈

    千次阅读 多人点赞 2018-08-04 20:54:29
    顺序栈,就是用一组地址连续的存储单元来存放栈元素,然后用一个栈结构去维护一个栈。在C中,可用动态开辟的数组去表示,维护的栈结构需要有一个栈底和一个栈顶指针。因为开辟一个数组需要事先知道它的大小,所以栈...
  • 顺序栈的基本操作

    万次阅读 2017-10-14 11:21:15
    由于顺序栈的操作位置基本在栈底,所以...顺序栈初始化就是构造一个空的顺序栈S,初始分配的最大容量maxsize,预设的需要扩容的增量incresize。其主要操作是:申请存储控件,栈顶指针的初始值置-1. void InitS
  • 的结构组成定义: #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #define ERROR 0 #define OK 1 #define INIT_SIZE 10 /*初始分配容量*/ ...
  • 顺序栈C语言实现

    千次阅读 2016-05-11 19:48:14
    “`#include <stdio.h>#define MAXSIZE 10001 #define ELEMTYPE int #define STACK_EMPTY -9999 #define N 10typedef struct stack { ELEMTYPE data[MAXSIZE]; int top; } Seq_Stack;...void initStack(Seq_Stac
  • 数据结构—顺序栈

    千次阅读 多人点赞 2019-07-03 09:20:27
    要注意的是:非空栈的栈顶指针总是指向栈顶元素的上一个位置。 栈满时的处理方法: 1、报错,返回操作系统。 2、分配更大的空间,作为栈的存储空间,将原栈的内容移入新栈。 1.顺序栈的表示 #def...
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    一个打了激素的数组 011列表:一个打了激素的数组2 012列表:一个打了激素的数组3 013元组:戴上了枷锁的列表 014字符串:各种奇葩的内置方法 015字符串:格式 016 序列!序列! 017函数:Python的乐高积木 018 ...
  • 数据结构之C语言实现初始化、入栈、出栈、查看栈顶、查看栈大小、判空等基础操作。 #define _CRT_SECURE_NO_WARNINGS 1 #include &lt;assert.h&gt; #include &lt;stdio.h&gt; #include &...
  • 顺序栈使用——表达式求值

    千次阅读 多人点赞 2017-11-30 13:06:17
    顺序栈使用——表达式求值 ...   欢迎大家阅读我的博客,如果有...   顺序栈部分在之前已经在另篇文章中提及,本篇中就不再提及,如有需要请阅读&lt;顺序栈的各种基本运算&gt;。 实验环境 ...
  • 顺序栈的基本操作及实现(C/C++)

    千次阅读 2020-06-06 21:45:26
    顺序栈初始化 //2.判断顺序栈是否空 //3求顺序栈的长度 //4.清空顺序栈 //5.销毁顺序栈 //6.顺序栈进栈 //7.顺序栈出栈 //8.取顺序栈的栈顶元素** */ 代码实现 #include<iostream> #include<...
  • firstsize 创建一个栈时这个初始大小,这里100。addsize 满时,再想入栈的话每次栈大小的增量,这里用10来代替。 create函数创建函数。push入栈函数。empty函数用来判断 是否空,print函数...
  • 栈,顺序栈,链栈的基础概念

    千次阅读 2020-02-02 23:50:32
    ——后进先出 (stack)又名堆栈,它是一种运算受限的...从一个栈删除元素又称作出栈或退,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。 的定义 (stack):是限定仅在表尾进行插入或删...
  • 哈哈哈,刚刚看了一下,下一个实验就是关于队列的,慢慢学吧,加油! 定义: 和队列是两种特殊的线性表,即操作受限的线性表,只是对插入、删除运算加以限制。 是只允许在一端进行插入、删除运算,因而是后进...
  • 顺序栈的各种基本运算

    千次阅读 多人点赞 2017-11-29 16:05:31
    顺序栈的各种基本运算 码文不易,如果帮助到您,希望您可以帮我刷一下点击量,与您无害,与我有益谢谢 支持原创 。   欢迎大家阅读我的博客,如果有错误请指正,有问题请提问,我会尽我全力改正错误回答...
  • 4 //顺序栈的静态存储结构需要预先定义或申请栈的存储空间,栈空间容量有限,一旦装满不能扩充,元素进栈会发生上溢现象 5 #define maxSize 100 //栈元素数据类型 6 typedef int SElemType; 7 typedef struct 8...
  • 计算机复试面试题总结

    万次阅读 多人点赞 2019-03-07 20:06:56
    面试问题之编程语言 1。C++的特点是什么? 封装,继承,多态。支持面向对象和面向过程的开发。 2.C++的异常处理机制?...被virtual修饰的成员函数,再基类不能实现,而他的实现放到...5.什么是内存泄漏? 没有de...
  • (stack)又名堆栈,它是一种运算受限的线性表。...从一个栈删除元素又称作出栈或退,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。 #include&lt;iostream&gt; #include&lt;...
  • 顺序栈—基本操作的实现及简单应用(C语言)

    千次阅读 多人点赞 2020-12-02 17:53:28
    文章目录栈的顺序表示和实现以及简单应用(C语言)顺序栈的基本概念二、代码实现:1.引入库2.读入数据总结 提示:以下是本篇文章正文内容,下面案例可供参考 顺序栈的基本概念 示例:pandas 是基于NumPy 的...
  • js面试题

    千次阅读 多人点赞 2019-04-09 19:42:32
    JavaScript 如何实现一个类,怎么实例这个类? 构造函数法(this + prototype) – 用 new 关键字 生成实例对象 缺点:用到了 this 和 prototype,编写复杂,可读性差 function Mobile ( name ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,066
精华内容 31,626
关键字:

初始化一个空间大小为5的顺序栈