第四章：栈与队列（115）

栈顶与栈底，空栈，后进先出 Last in first out（LIFO结构）（117）

进栈、压栈、入栈：栈的插入操作；出栈、弹栈：栈的删除操作（118）

push、pop，压栈和弹栈（进栈和出栈 ）（119）

栈的顺序存储结构：顺序栈（数组实现）（120）

两栈共享空间（122）

最好是相同的数据类型共享（124）

栈的链式存储结构（链栈）（125）

链栈不需要头结点（创建一个栈链结构，结构中包含指向栈顶top的指针和结点数量）

栈的链式存储结构——进栈push操作：（126）

栈的链式存储结构——出栈pop操作：（127）

顺序栈和链栈的优缺点：（128）

栈的作用：简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。（128）

栈的应用：递归（128）

斐波那契数列实现（129）

斐波那契数列：前面两项之和，构成了后一项

传统迭代方法

递归算法

递归函数的定义（131）

一个直接调用自己，或通过一系列的调用语句间接地调用自己的函数，称为递归函数

递归与迭代的区别（132）

栈在递归操作中的作用（132）

栈的应用——四则运算表达式求值（132）

后缀（逆波兰）（reverse polish notation, RPN）表示法（133）

后缀表达式（133）

中缀表达式（标准四则运算表达式）转后缀表达式（136）

队列的定义（139）

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表

先进先出（first in first out, FIFO），允许插入的一端称为队尾，允许删除的一端称为队头

队列的抽象数据类型（140）

循环队列（顺序存储结构）（140）

队列顺序存储的缺点（140）

出队时间复杂度高（O(n)）

front与rear指针（141）

假溢出的概念（142）

不循环所存在的问题：后面满了，但前面空着，不会把元素加到前面

循环队列定义（142）

头尾相接的顺序存储结构

如何判断循环队列是空还是满？（143）

假设队列的最大尺寸是QueueSize，则队列满的条件是（rear + 1）% QueueSize == front，%为取模符号

通用计算队列长度公式（144）

（rear - front + QueueSize）% QueueSize

循环队列顺序存储结构代码（144）

顺序存储结构循环队列缺点：可能会溢出（145）

队列的链式存储结构及实现（其实就是线性表的单链表修改版，只能尾进头出）（链队列）（145）

队头指针指向队列头结点，队尾指针指向终端结点

队列的链式存储结构——入队操作

入队操作：在链表尾部插入结点

队列的链式存储结构——出队操作

（顺序存储结构）循环队列与链队列的对比（链队列每次malloc申请和释放结点也会存在一定的时间开销）（148）

栈与队列总结（149）

本章配套代码

顺序栈

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status;
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int *//* 顺序栈结构 */
typedef struct
{SElemType data[MAXSIZE];int top; /* 用于栈顶指针 */
}SqStack;Status visit(SElemType c)
{printf("%d ",c);return OK;
}/*  构造一个空栈S */
Status InitStack(SqStack *S)
{ /* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */S->top=-1;return OK;
}/* 把S置为空栈 */
Status ClearStack(SqStack *S)
{ S->top=-1;return OK;
}/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(SqStack S)
{ if (S.top==-1)return TRUE;elsereturn FALSE;
}/* 返回S的元素个数，即栈的长度 */
int StackLength(SqStack S)
{ return S.top+1;
}/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
Status GetTop(SqStack S,SElemType *e)
{if (S.top==-1)return ERROR;else*e=S.data[S.top];return OK;
}/* 插入元素e为新的栈顶元素 */
Status Push(SqStack *S,SElemType e)
{if(S->top == MAXSIZE -1) /* 栈满 */{return ERROR;}S->top++;                /* 栈顶指针增加一 */S->data[S->top]=e;  /* 将新插入元素赋值给栈顶空间 */return OK;
}/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(SqStack *S,SElemType *e)
{ if(S->top==-1)return ERROR;*e=S->data[S->top];    /* 将要删除的栈顶元素赋值给e */S->top--;             /* 栈顶指针减一 */return OK;
}/* 从栈底到栈顶依次对栈中每个元素显示 */
Status StackTraverse(SqStack S)
{int i;i=0;while(i<=S.top){visit(S.data[i++]);}printf("\n");return OK;
}int main()
{int j;SqStack s;int e;if(InitStack(&s)==OK)for(j=1;j<=10;j++)Push(&s,j);printf("栈中元素依次为：");StackTraverse(s);Pop(&s,&e);printf("弹出的栈顶元素 e=%d\n",e);printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));GetTop(s,&e);printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));ClearStack(&s);printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));return 0;
}

两栈共享空间

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status; typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int *//* 两栈共享空间结构 */
typedef struct
{SElemType data[MAXSIZE];int top1;  /* 栈1栈顶指针 */int top2;   /* 栈2栈顶指针 */
}SqDoubleStack;Status visit(SElemType c)
{printf("%d ",c);return OK;
}/*  构造一个空栈S */
Status InitStack(SqDoubleStack *S)
{ S->top1=-1;S->top2=MAXSIZE;return OK;
}/* 把S置为空栈 */
Status ClearStack(SqDoubleStack *S)
{ S->top1=-1;S->top2=MAXSIZE;return OK;
}/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(SqDoubleStack S)
{ if (S.top1==-1 && S.top2==MAXSIZE)return TRUE;elsereturn FALSE;
}/* 返回S的元素个数，即栈的长度 */
int StackLength(SqDoubleStack S)
{ return (S.top1+1)+(MAXSIZE-S.top2);
}/* 插入元素e为新的栈顶元素 */
Status Push(SqDoubleStack *S,SElemType e,int stackNumber)
{if (S->top1+1==S->top2)   /* 栈已满，不能再push新元素了 */return ERROR;   if (stackNumber==1)           /* 栈1有元素进栈 */S->data[++S->top1]=e; /* 若是栈1则先top1+1后给数组元素赋值。 */else if (stackNumber==2)  /* 栈2有元素进栈 */S->data[--S->top2]=e; /* 若是栈2则先top2-1后给数组元素赋值。 */return OK;
}/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(SqDoubleStack *S,SElemType *e,int stackNumber)
{ if (stackNumber==1) {if (S->top1==-1) return ERROR; /* 说明栈1已经是空栈，溢出 */*e=S->data[S->top1--]; /* 将栈1的栈顶元素出栈 */}else if (stackNumber==2){ if (S->top2==MAXSIZE) return ERROR; /* 说明栈2已经是空栈，溢出 */*e=S->data[S->top2++]; /* 将栈2的栈顶元素出栈 */}return OK;
}Status StackTraverse(SqDoubleStack S)
{int i;i=0;while(i<=S.top1){visit(S.data[i++]);}i=S.top2;while(i<MAXSIZE){visit(S.data[i++]);}printf("\n");return OK;
}int main()
{int j;SqDoubleStack s;int e;if(InitStack(&s)==OK){for(j=1;j<=5;j++)Push(&s,j,1);for(j=MAXSIZE;j>=MAXSIZE-2;j--)Push(&s,j,2);}printf("栈中元素依次为：");StackTraverse(s);printf("当前栈中元素有：%d \n",StackLength(s));Pop(&s,&e,2);printf("弹出的栈顶元素 e=%d\n",e);printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));for(j=6;j<=MAXSIZE-2;j++)Push(&s,j,1);printf("栈中元素依次为：");StackTraverse(s);printf("栈满否：%d(1:否 0:满)\n",Push(&s,100,1));ClearStack(&s);printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));return 0;
}

链栈

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status;
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int *//* 链栈结构 */
typedef struct StackNode
{SElemType data;struct StackNode *next;
}StackNode,*LinkStackPtr;typedef struct
{LinkStackPtr top;int count;
}LinkStack;Status visit(SElemType c)
{printf("%d ",c);return OK;
}/*  构造一个空栈S */
Status InitStack(LinkStack *S)
{ S->top = (LinkStackPtr)malloc(sizeof(StackNode));if(!S->top)return ERROR;S->top=NULL;S->count=0;return OK;
}/* 把S置为空栈 */
Status ClearStack(LinkStack *S)
{ LinkStackPtr p,q;p=S->top;while(p){  q=p;p=p->next;free(q);} S->count=0;return OK;
}/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(LinkStack S)
{ if (S.count==0)return TRUE;elsereturn FALSE;
}/* 返回S的元素个数，即栈的长度 */
int StackLength(LinkStack S)
{ return S.count;
}/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
Status GetTop(LinkStack S,SElemType *e)
{if (S.top==NULL)return ERROR;else*e=S.top->data;return OK;
}/* 插入元素e为新的栈顶元素 */
Status Push(LinkStack *S,SElemType e)
{LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode)); s->data=e; s->next=S->top; /* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */S->top=s;         /* 将新的结点s赋值给栈顶指针，见图中② */S->count++;return OK;
}/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(LinkStack *S,SElemType *e)
{ LinkStackPtr p;if(StackEmpty(*S))return ERROR;*e=S->top->data;p=S->top;                    /* 将栈顶结点赋值给p，见图中③ */S->top=S->top->next;    /* 使得栈顶指针下移一位，指向后一结点，见图中④ */free(p);                    /* 释放结点p */        S->count--;return OK;
}Status StackTraverse(LinkStack S)
{LinkStackPtr p;p=S.top;while(p){visit(p->data);p=p->next;}printf("\n");return OK;
}int main()
{int j;LinkStack s;int e;if(InitStack(&s)==OK)for(j=1;j<=10;j++)Push(&s,j);printf("栈中元素依次为：");StackTraverse(s);Pop(&s,&e);printf("弹出的栈顶元素 e=%d\n",e);printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));GetTop(s,&e);printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));ClearStack(&s);printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));return 0;
}

斐波那契函数

#include "stdio.h"int Fbi(int i)  /* 斐波那契的递归函数 */
{if( i < 2 )return i == 0 ? 0 : 1;  return Fbi(i - 1) + Fbi(i - 2);  /* 这里Fbi就是函数自己，等于在调用自己 */
}  int main()
{int i;int a[40];  printf("迭代显示斐波那契数列：\n");a[0]=0;a[1]=1;printf("%d ",a[0]);  printf("%d ",a[1]);  for(i = 2;i < 40;i++)  { a[i] = a[i-1] + a[i-2];  printf("%d ",a[i]);  } printf("\n");printf("递归显示斐波那契数列：\n");for(i = 0;i < 40;i++)  printf("%d ", Fbi(i));  return 0;
}

顺序队列

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status;
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int *//* 循环队列的顺序存储结构 */
typedef struct
{QElemType data[MAXSIZE];int front;     /* 头指针 */int rear;      /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;Status visit(QElemType c)
{printf("%d ",c);return OK;
}/* 初始化一个空队列Q */
Status InitQueue(SqQueue *Q)
{Q->front=0;Q->rear=0;return  OK;
}/* 将Q清为空队列 */
Status ClearQueue(SqQueue *Q)
{Q->front=Q->rear=0;return OK;
}/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(SqQueue Q)
{ if(Q.front==Q.rear) /* 队列空的标志 */return TRUE;elsereturn FALSE;
}/* 返回Q的元素个数，也就是队列的当前长度 */
int QueueLength(SqQueue Q)
{return  (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}/* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
Status GetHead(SqQueue Q,QElemType *e)
{if(Q.front==Q.rear) /* 队列空 */return ERROR;*e=Q.data[Q.front];return OK;
}/* 若队列未满，则插入元素e为Q新的队尾元素 */
Status EnQueue(SqQueue *Q,QElemType e)
{if ((Q->rear+1)%MAXSIZE == Q->front)  /* 队列满的判断 */return ERROR;Q->data[Q->rear]=e;         /* 将元素e赋值给队尾 */Q->rear=(Q->rear+1)%MAXSIZE;/* rear指针向后移一位置， *//* 若到最后则转到数组头部 */return  OK;
}/* 若队列不空，则删除Q中队头元素，用e返回其值 */
Status DeQueue(SqQueue *Q,QElemType *e)
{if (Q->front == Q->rear)           /* 队列空的判断 */return ERROR;*e=Q->data[Q->front];               /* 将队头元素赋值给e */Q->front=(Q->front+1)%MAXSIZE;   /* front指针向后移一位置， *//* 若到最后则转到数组头部 */return  OK;
}/* 从队头到队尾依次对队列Q中每个元素输出 */
Status QueueTraverse(SqQueue Q)
{ int i;i=Q.front;while((i+Q.front)!=Q.rear){visit(Q.data[i]);i=(i+1)%MAXSIZE;}printf("\n");return OK;
}int main()
{Status j;int i=0,l;QElemType d;SqQueue Q;InitQueue(&Q);printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));printf("请输入整型队列元素(不超过%d个),-1为提前结束符: ",MAXSIZE-1);do{/* scanf("%d",&d); */d=i+100;if(d==-1)break;i++;EnQueue(&Q,d);}while(i<MAXSIZE-1);printf("队列长度为: %d\n",QueueLength(Q));printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));printf("连续%d次由队头删除元素,队尾插入元素:\n",MAXSIZE);for(l=1;l<=MAXSIZE;l++){DeQueue(&Q,&d);printf("删除的元素是%d,插入的元素:%d \n",d,l+1000);/* scanf("%d",&d); */d=l+1000;EnQueue(&Q,d);}l=QueueLength(Q);printf("现在队列中的元素为: \n");QueueTraverse(Q);printf("共向队尾插入了%d个元素\n",i+MAXSIZE);if(l-2>0)printf("现在由队头删除%d个元素:\n",l-2);while(QueueLength(Q)>2){DeQueue(&Q,&d);printf("删除的元素值为%d\n",d);}j=GetHead(Q,&d);if(j)printf("现在队头元素为: %d\n",d);ClearQueue(&Q);printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));return 0;
}

链队列

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status; typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */typedef struct QNode  /* 结点结构 */
{QElemType data;struct QNode *next;
}QNode,*QueuePtr;typedef struct         /* 队列的链表结构 */
{QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;Status visit(QElemType c)
{printf("%d ",c);return OK;
}/* 构造一个空队列Q */
Status InitQueue(LinkQueue *Q)
{ Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));if(!Q->front)exit(OVERFLOW);Q->front->next=NULL;return OK;
}/* 销毁队列Q */
Status DestroyQueue(LinkQueue *Q)
{while(Q->front){Q->rear=Q->front->next;free(Q->front);Q->front=Q->rear;}return OK;
}/* 将Q清为空队列 */
Status ClearQueue(LinkQueue *Q)
{QueuePtr p,q;Q->rear=Q->front;p=Q->front->next;Q->front->next=NULL;while(p){q=p;p=p->next;free(q);}return OK;
}/* 若Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(LinkQueue Q)
{ if(Q.front==Q.rear)return TRUE;elsereturn FALSE;
}/* 求队列的长度 */
int QueueLength(LinkQueue Q)
{ int i=0;QueuePtr p;p=Q.front;while(Q.rear!=p){i++;p=p->next;}return i;
}/* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
Status GetHead(LinkQueue Q,QElemType *e)
{ QueuePtr p;if(Q.front==Q.rear)return ERROR;p=Q.front->next;*e=p->data;return OK;
}/* 插入元素e为Q的新的队尾元素 */
Status EnQueue(LinkQueue *Q,QElemType e)
{ QueuePtr s=(QueuePtr)malloc(sizeof(QNode));if(!s) /* 存储分配失败 */exit(OVERFLOW);s->data=e;s->next=NULL;Q->rear->next=s;  /* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */Q->rear=s;      /* 把当前的s设置为队尾结点，rear指向s，见图中② */return OK;
}/* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
Status DeQueue(LinkQueue *Q,QElemType *e)
{QueuePtr p;if(Q->front==Q->rear)return ERROR;p=Q->front->next;      /* 将欲删除的队头结点暂存给p，见图中① */*e=p->data;              /* 将欲删除的队头结点的值赋值给e */Q->front->next=p->next;/* 将原队头结点的后继p->next赋值给头结点后继，见图中② */if(Q->rear==p)      /* 若队头就是队尾，则删除后将rear指向头结点，见图中③ */Q->rear=Q->front;free(p);return OK;
}/* 从队头到队尾依次对队列Q中每个元素输出 */
Status QueueTraverse(LinkQueue Q)
{QueuePtr p;p=Q.front->next;while(p){visit(p->data);p=p->next;}printf("\n");return OK;
}int main()
{int i;QElemType d;LinkQueue q;i=InitQueue(&q);if(i)printf("成功地构造了一个空队列!\n");printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));printf("队列的长度为%d\n",QueueLength(q));EnQueue(&q,-5);EnQueue(&q,5);EnQueue(&q,10);printf("插入3个元素(-5,5,10)后,队列的长度为%d\n",QueueLength(q));printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));printf("队列的元素依次为：");QueueTraverse(q);i=GetHead(q,&d);if(i==OK)printf("队头元素是：%d\n",d);DeQueue(&q,&d);printf("删除了队头元素%d\n",d);i=GetHead(q,&d);if(i==OK)printf("新的队头元素是：%d\n",d);ClearQueue(&q);printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n",q.front,q.rear,q.front->next);DestroyQueue(&q);printf("销毁队列后,q.front=%u q.rear=%u\n",q.front, q.rear);return 0;
}

C语言数据结构（大话数据结构——笔记2）第四章：栈与队列相关推荐

1. C语言数据结构【手抄版】第三章 栈和队列

   注意:文中彩色代码均在Visual Studio 2022编译器中编写,本文为C语言数据结构手抄版,文中有部分改动,非原创. 目录 注意:文中彩色代码均在Visual Studio 2022编译器中编 ...

2. Java数据结构与算法（第四章栈和队列）

   2019独角兽企业重金招聘Python工程师标准>>> 本章涉及的三种数据存储类型:栈.队列和优先级队列. 不同类型的结构 程序员的工具 数组是已经介绍过的数据存储结构,和其他结构( ...

3. 2021-9-28 数据结构学习 第四章 - 栈 和 队列【1024Re】

   新学期被作业淹没,将博客晾在这太久了,不禁心生惭愧,于是将今晚本来计划去深圳湾公园散步的时间用来写文章.我在想,要写什么呢,看着案上的数据结构,就决定是你了! 看名字是第四章,我是不是错过了什么,其实 ...

4. 大话数据结构读书笔记艾提拉总结 查找算法 和排序算法比较好 第1章数据结构绪论 1 第2章算法 17 第3章线性表 41 第4章栈与队列 87 第5章串 123 第6章树 149 第7章图 21

   大话数据结构读书笔记艾提拉总结 查找算法 和排序算法比较好 第1章数据结构绪论 1 第2章算法 17 第3章线性表 41 第4章栈与队列 87 第5章串 123 第6章树 149 第7章图 211 第 ...

5. c语言实现bf算法的定位函数,数据结构c语言版严蔚敏清华大学出版社第四章串.ppt...

   数据结构c语言版严蔚敏清华大学出版社第四章串 模式匹配(定位) 设有主串S和子串T(将S称为目标串,将T称为模式串),在主串S中,从位置start开始查找,如若在主串S中找到一个与子串T相等的子串,则 ...

6. 2022天勤考研数据结构笔记 第3章 栈和队列

   2022天勤考研数据结构笔记 第3章 栈和队列(更新中) 第3章 栈和队列 3.1 结构体定义 3.2 顺序栈 3.3 链栈 3.4 栈的应用 3.5 顺序队 3.6 链队 第3章 栈和队列 栈和队列 ...

7. C语言数据结构-第三章栈和队列-电大同步进度

   第三章栈和队列简介 从数据结构角度看,栈和队列是两种重要的线性结构,是一类操作受限制的特殊线性表,其特殊性在于限制插入和删除等运算的位置. 堆栈,限制用户只能在指定的一端插入和删除元素,因此具有后进先 ...

8. (王道408考研数据结构)第三章栈和队列-第三节1：栈的应用之括号匹配问题和表达式问题（前缀、中缀和后缀）

   前面我们就说过,栈是一种先进后出的线性表,这种先进后出的特性就决定了它在一类场合或问题中会经常被用到--递归.考研数据结构中所涉及的利用栈结构解决递归问题或者考察栈结构特性的问题主要有这么几类 括号匹 ...

9. 高一凡-数据结构第3章-栈与队列

   高一凡-数据结构第3章-栈与队列 3.1栈 3.1.1栈的数据结构 3.1.2接口 3.1.3实现 VS2015实例代码包: 3.1栈 3.1.1栈的数据结构 struct SqStack {SEle ...

10. R语言实战笔记--第十四章 主成分和因子分析

    R语言实战笔记–第十四章 主成分和因子分析 标签(空格分隔): R语言 主成分分析 因子分析 原理及区别 主成分分析与因子分析很接近,其目的均是为了降维,以更简洁的数据去解释结果,但这两种方法其实是相 ...

最新文章

1. 轻量级HTTP服务器Nginx
2. 为什么用IP无法访问网站，域名可以访问？
3. Bash中的管道输出和捕获退出状态
4. vbs控制电脑说话，vbs获取时间，vbs小程序
5. Nginx的功能特性及常用功能
6. 转: telnet命令学习
7. guava 并发_Google Guava并发– ListenableFuture
8. Vue.js 概述与 MVVM 模式
9. python面向对象编程项目_Python学习之==面向对象编程（一）
10. 大公司都有哪些开源项目~~~简化版
11. CentOS 关闭暂不需要的系统服务
12. 外卖行业现状分析_中国在线餐饮外卖行业分析报告（附全文）
13. C语言，C++，C#发展的回顾与展望
14. 互联网 IT 精英：龙泉寺静心之旅
15. ​K歌中的歌唱评价与嗓音分析
16. 我的Android开发校招之路
17. 测量角速度_自动驾驶系统的定海神针—惯性测量单元
18. 数据库学习笔记—MySQL技术nei幕—第一章—MySQL体系结构和存储引擎
19. CAN/CANFD总线基础培训
20. 阿里程序员绩效被判不及格，却被谷歌录取：此生再也不回阿里

热门文章

1. Groove 线上办公室
2. 兩台SQL Server數據同步解決方案
3. [转载]SQL Server 2005 Data Mining简介
4. vue 声明周期函数_【Vue】详解Vue生命周期
5. 【MM配置】Movement Type 移动类型创建
6. 复杂的选择屏幕搜索帮助
7. sap 销售订单过量交货和拣配有关设置
8. SAP ABAP 内表使用
9. oracle数据库用户密码将要过期处理办法（ORA-28002）
10. OO实现ALV TABLE 五：ALV的栏位属性