数据结构-栈和队列

最新推荐文章于 2023-10-20 19:18:20 发布
最新推荐文章于 2023-10-20 19:18:20 发布
阅读量524 收藏
点赞数 1
分类专栏： 数据结构 基础知识 文章标签： 数据结构 栈 队列
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_17119267/article/details/79077259
版权

数据结构-栈和队列

栈

​ 栈是一种特殊的线性表。它的结构非常类似于日常生活中的瓶子，只有一端开口，而插入和删除的操作只能在瓶子的瓶口处进行，这种一端开口是它的特殊性。这种特殊性也决定了栈中的数据操作顺序是先入后出的，也就是说先进入栈中的数据，最后才能出去。

1.1 栈的定义

栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。

img

结论：后进先出（Last In First Out），简称为LIFO线性表。

栈的基本运算：

img

栈的基本运算有六种：

构造空栈：InitStack(S)、

判栈空: StackEmpty(S)、

判栈满： StackFull(S)、

进栈： Push(S,x)、可形象地理解为压入，这时栈中会多一个元素

退栈： Pop(S) 、 可形象地理解为弹出，弹出后栈中就无此元素了。

取栈顶元素：StackTop(S),不同与弹出，只是使用栈顶元素的值，该元素仍在栈顶不会改变。

Note：栈是一种先进后出的线性表，但是并不意味着不会出现先进先出的情况。如：当1、2、3、4顺次入栈时，出栈的顺序也可能是1、2、3、4，这种情况发生条件是每个数入栈后出栈，然后下一个数入栈。即：1入栈后出栈，然后是2入栈后出栈，其次是3入栈后出栈，最后是4入栈后出栈，这样顺序就变成了1、2、3、4。

由于栈也是线性表，因此线性表的存储结构对栈也适用，通常栈有顺序栈和链栈两种存储结构，这两种存储结构的不同，则使得实现栈的基本运算的算法也有所不同。

栈的溢出问题解析：

​ 在顺序栈中有”上溢”和”下溢”的概念。顺序栈好比一个盒子，我们在里头放了一叠书，当我们要用书的话只能从第一本开始拿，那么当我们把书本放到这个栈中超过盒子的顶部时就放不下了，这时就是”上溢”,”上溢”也就是栈顶指针指出栈的外面，显然是出错了。反之，当栈中已没有书时，我们再去拿，看看没书，把盒子拎起来看看盒底，还是没有，这就是”下溢”。”下溢”本身可以表示栈为空栈,因此可以用它来作为控制转移的条件。而对于链栈则没有上溢的限制，它就象是一条一头固定的链子，可以在活动的一头自由地增加链环(结点)而不会溢出，链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要在头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。

1.2 顺序栈

在顺序栈中数据是按照顺序进行存储的。需要我们了解的是顺序栈中有上溢和下溢的概念。

溢出简单定义：

上溢：栈顶指针指出栈的外面。我们把顺序栈看做一个盒子，那么当我们把数据放到这个栈中超过盒子的顶部时就放不下了，这时指针指向了栈的外面，这种现象我们称为上溢。

下溢：从空栈中取数据。当栈中没有数据时，我们再去取数据，看看没数据，把盒子拎起来看看盒底，还是没有，这就是下溢。

顺序栈的类型定义为：

typedef struct
{
    int data[maxsize];
    int top;
}SqStack;

1.２.1 顺序栈的基本运算

(1) 初始化栈

void initStack(SqStack &st)
{
    st.top = -1;
}

(2)判栈空

int isEmpty(SqStack st)
{
    if(st.top==-1)
    {
        return 1;
    }   
    else
    return 0;
}

(3)判栈满

int isFull(SqStack st) {
    return st.top==maxsize-1;
}

(4)进栈

int Push(SqStack &st,int x)
{
    if(st.top==maxsize-1) //这里要注意，栈满不能进栈 
    return 0;
    ++(st.top); //先移动指针，再进栈 
    st.data[st.top]=x;
    return 1;
}

(5)出栈

int Pop(SqStack &st,int &x)
{
    if(st.top==-1) //这里要注意，栈空不能出栈 
    return 0;
    x=st.data[st.top];//先出栈栈，先移动指针
    --(st.top); 
    return 1;
}

(6)取栈顶元素

int stacktop(SqStack &st)  
{
    if(st.top==-1)
    return 0;
    return st.data[st.top];
}

代码实现如下：

 #include <stdio.h>
#define maxsize 5
typedef struct
{
    int data[maxsize];
    int top;
}SqStack;
void initStack(SqStack &st)
{
    st.top = -1;
}
int isEmpty(SqStack st)
{
    return st.top==-1;
}
int isFull(SqStack st) {
    return st.top==maxsize-1;
}
int Push(SqStack &st,int x)
{
    if(st.top==maxsize-1) //这里要注意，栈满不能进栈 
    return 0;
    ++(st.top); //先移动指针，再进栈 
    st.data[st.top]=x;
    return 1;
}
int Pop(SqStack &st,int &x)
{
    if(st.top==-1) //这里要注意，栈空不能出栈 
    return 0;
    x=st.data[st.top];//先出栈栈，先移动指针
    --(st.top); 
    return 1;
}
int stacktop(SqStack &st)  
{
    if(st.top==-1)
    return 0;
    return st.data[st.top];
}  
int StackLength(SqStack st)
 { /* 返回S的元素个数，即栈的长度 */
   return st.top+1;
 }
void show(SqStack st)
{
    int i;
    printf("输出栈中元素：\n "); 
    for(i=0;i<=st.top;i++)
    printf("%d  ",st.data[st.top]); 
        printf("\n "); 
}
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {
    int a,b,c;
    SqStack st;
    initStack(st);
    a= isEmpty(st);
    printf("是否为空 %d (1:为空  0：不为空)\n",a);
    Push(st,2);
    a= isEmpty(st);
    c=StackLength(st);
    show(st);
    printf("是否为空 %d 栈长度为%d (1:为空 0：不为空)\n",a,c);
    Pop(st,b);
     a= isEmpty(st);
    printf("是否为空 %d 出栈元素为%d (1:为空 0：不为空)\n",a,b);

    return 0;
}
1.3 链栈

​ 若是栈中元素的数目变化范围较大或不清楚栈元素的数目，就应该考虑使用链式存储结构。人们将用链式存储结构表示的栈称作”链栈”。链栈通常用一个无头结点的单链表表示。如图所示：

img

​ 和顺序栈不同，它没有固定的结构，也不会出现数据的上溢，它就像是一条一头固定的链子，可以在活动的一头自由地增加链环（结点）而不会溢出。

1.3.1 基本运算

(1) 建栈

void initstack(linkstack *s)  
{  
　　s->top=NULL;  
}

(2)判栈空

int stackempty (linkstack *s)  
{  
　 return s->top==NULL;  
}

(3) 进栈

void push(linkstack *s,datatype x)  
{  
　　 stacknode *p=(stacknode *)malloc(sizeof(stacknode));  
　　 p->data=x;  
　　 p->next=s->top;  
　　 s->top=p;  
}

​ (4) 出栈

int pop(linksatck *s)  
 { 　　   
    int x; 　　   
    stacknode *p=s->top;   

　　 if(stackempty(s)) 　　   
        error(“stack underflow”);   
　　 x=p->data; 　　   
    s->top=p->next; 　  
    free(p); 　　   
    return x;   
}

(5) 取栈顶元素

int stacktop(linkstack *s)  
{  
　　 if(stackempty(s))  
　　   error(“stack is empty”);  
　　 return s->top->data;  
}

代码实现如下：

#include <stdio.h.>
#include <malloc.h>
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode;
void InitStackL(LNode *&lst){
    lst=(LNode *)malloc(sizeof(LNode));//制造一个头结点
    lst->next=NULL;
}
int isEmpty(LNode *lst){
    if(lst->next==NULL)    
        return 1;
    else 
        return 0;
}
void push(LNode *lst,int x)
{
    LNode *p;
    p=(LNode *)malloc(sizeof(LNode));
    p->next=NULL;
    p->data=x;
    p->next=lst->next;
    lst->next=p; 
}
int pop(LNode *lst,int &x)
{
    LNode *p;
    if(lst->next==NULL)
    return 0;
    //以下就是单链表的删除操作 
    p=lst->next;
    x=p->data;
    lst->next=p->next; 
    free(p);
    return 0;
}
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv) {
    LNode *lst;
    int a,b=3,c;
    InitStackL(lst);
    a=isEmpty(lst);
    printf("栈是否为空 ：%d (1：空 0：不为空) \n",a);
    push(lst , b);
    a=isEmpty(lst);
    printf("入栈 ：%d \n",b);
    printf("栈是否为空 ：%d (1：空 0：不为空) \n",a);
    pop(lst,c);
    a=isEmpty(lst);
    printf("出栈 ：%d \n",c);
    printf("栈是否为空 ：%d (1：空 0：不为空) \n",a);
    return 0;
}
1.4 栈的应用

1) 数制转换

2）语法词法分析

3）表达式求值等

1.5 栈的递归和实现

汉诺塔的问题：

img

解决：

1）如果有一个盘子，直接从X移到Z即可。
2）如果有n个盘子要从X移到Z，Y作为辅助。问题可以转化为，先将上面n-1个从X移动到Y，Z作为辅助，然后将第n个从X移动到Z，最后将剩余的n-1个从Y移动到Z，X作为辅助。

完整实现代码，包括栈的实现：

#include<iostream>
#include<stack>
using namespace std;
//把塔x顶部的n个碟子移到塔y
//用塔Z做中转地
void towerOfHanoi(int n, int x, int y, int z)
{
    if (n > 0)
    {
        towerOfHanoi(n - 1, x, z, y);
        cout << "Move top disk for tower " << x << " to top of tower " << y << endl;
        towerOfHanoi(n - 1, z, y, x);
    }
    return;
}
//用栈实现汉诺塔的问题
template<class T>
void changeLength1D(T*&a, int oldLength, int newLength)
{//更改长度
    if (newLength < 0)
    {
        throw("wrong ");
    }
    T* temp = new T[newLength];
    int number = min(oldLength, newLength);
    copy(a, a + number, temp);
    delete[] a;
    a = temp;
}
template<class T>
class arrayStack :public stack<T>
{
public:
    arrayStack(int initialCapacity = 10);
    ~arrayStack() { delete[] stack; };
    bool empty()const { return stackTop == -1; }
    int size()const { return stackTop + 1; }
    T& top()
    {
        if (stackTop == -1)
        {
            throw ("wrong");
        }
        return stack[stackTop];
    }
    void pop()
    {
        if (stackTop == -1)
        {
            throw("empty");
        }
        stack[stackTop--].~T();
    }
    void push(const T& theElement);
private:
    int stackTop;
    int arrayLength;
    T* stack;
};
template<class T>
arrayStack<T>::arrayStack(int initialCapacity)
{
    //structure funs
    if (initialCapacity < 1)
    {
//      ostringstream s;
//      s << "Initial capacity = " << initialCapacity << " Must be > 0 ";
//      throw(s.str());
    }
    arrayLength = initialCapacity;
    stack = new T[arrayLength];
    stackTop = -1;
}
template<class T>
void arrayStack<T>::push(const T& theElement)
{
    if (stackTop == arrayLength - 1)
    {
        changeLength1D(stack, arrayLength, 2 * arrayLength);
        arrayLength *= 2;
    }
    stack[++stackTop] = theElement;
}
arrayStack<int>tower[4];
void moveAndShow(int, int, int, int);
void showState()
{
    int d = tower[3].size();
    for (int i = 0; i < d; i++)
        cout << tower[3].top() << endl;
}
void towerOfHanoi(int n)
{
    for (int d = n; d > 0; d--)
    {
        tower[1].push(d);
    }
    moveAndShow(n, 1, 2, 3);
}
void moveAndShow(int n, int x, int y, int z)
{//把塔x顶部的n个碟子移到塔y，显示移动后的布局
    //用塔Z做中转站
    if (n > 0)
    {
        moveAndShow(n - 1, x, z, y);
        int d = tower[x].top();
        tower[x].pop();
        tower[y].push(d);
        showState();
        moveAndShow(n - 1, z, y, x);
    }
}
int main()
{
    int a = 4;
    towerOfHanoi(4);//栈实现
    cout << endl;
    towerOfHanoi(4, 1, 2, 3);//递归函数实现
    return 0;
}
2、队列
2.1 队列定义

​ 队列(Queue)也是一种运算受限的线性表，它的运算限制与栈不同，是两头都有限制，插入只能在表的一端进行(只进不出)，而删除只能在表的另一端进行(只出不进)，允许删除的一端称为队尾(rear)，允许插入的一端称为队头 (Front),队列的操作原则是先进先出的，所以队列又称作FIFO表(First In First Out)

img

队列的基本运算也有六种：

置空队 ：InitQueue(Q)

判队空： QueueEmpty(Q)

判队满： QueueFull(Q)

入队 ： EnQueue(Q,x)

出队 ： DeQueue(Q)

取队头元素： QueueFront(Q),不同与出队，队头元素仍然保留。

队列也有顺序存储和链式存储两种存储结构，前者称顺序队列，后者为链队

img

​ 队列也是一种线性结构，所以队列也有顺序存储和链式存储两种存储结构，前者称顺序队列，后者为链队。

2.2 顺序队列

​ 与顺序栈类似，顺序队列也有上溢和下溢的情况，它们产生的原因和顺序栈类似，这里就不在细说。由于队列操作的特殊性（指针移动，元素不同）又出现了假上溢的情况。

img

Note：在现实生活中我们随处可见排队的情况，当队列中的人离开队列后，后面的人会上来补上，当新来人排队时是在队列中的尾部进行排列的。我们现在说的队列和生活中的排队最大的区别在于前者是指针在移动，后者是元素在移动。
Note：在队列中每插入一个元素，队列的队尾指针会向后移动一个位置；类似的在队列中每删除一个元素，队头的指针都会向接近队尾的方向移动一个位置。

2.2.1 何为假上溢

img

上图中的（c）操作，如果我们继续向队列中插入数据，尾指针就要跑到向量空间外面去了，尽管这时整个向量空间是空的，队列也是空的，却产生了“上溢”现象，这就是假上溢。

顺序队列的类型定义为： 

typedef struct
{
    int data[maxsize];
    int front;
    int rear;
}SqQueue;

2.1.2 队列的基本运算

(1) 构造空队列

void InitQueue(SqQueue &qu)
{
    qu.front =qu.rear=0;//队首队尾指针重合，并且指向0 
}

(2) 判队空

int QueueEmpty(SqQueue qu){
    if(qu.front==qu.rear) //不论队首队尾指针指向数组中的那个位置 
    return 1;               //只要两者重合，即为对空 
    else
    return 0;
}

(3) 判队满

int QueueFull(SqQueue qu){
    if((qu.rear+1)%maxsize==qu.front) //不队满的判断条件，队满侧不能入队 
    return 1;               
    else
    return 0;
}

(4) 入队

int enQueue(SqQueue &qu,int x)
{
    if((qu.rear+1)%maxsize==qu.front)//队满的判断条件，队满侧不能入队 
    return 0;
    qu.rear = (qu.rear+1)%maxsize;  //若队不空，则先移动指针 
    qu.data[qu.rear]=x;   //再存入元素 
    return 1;
}

(5) 出队

int deQueue(SqQueue &qu,int &x)
{
    if(qu.front==qu.rear)    //若队空，则不能出队 
    return 0;
    qu.front = (qu.front+1)%maxsize;//若队不空，则先移动指针 
    x=qu.data[qu.front];        //再取出元素 
    return 1;
}

(6) 取队头元素

int Queuefront(SqQueue &qu)  
{  
　　if(qu.front==qu.rear)  
    return 0;
　　 return qu.data[qu.front];
}

代码实现如下：

#include <stdio.h>
#define maxsize 10
typedef struct
{
    int data[maxsize];
    int front;
    int rear;
}SqQueue;
void InitQueue(SqQueue &qu)
{
    qu.front =qu.rear=0;//队首队尾指针重合，并且指向0 
}
int QueueEmpty(SqQueue qu){
    if(qu.front==qu.rear) //不论队首队尾指针指向数组中的那个位置 
    return 1;               //只要两者重合，即为对空 
    else
    return 0;
}
int QueueFull(SqQueue qu){
    if((qu.rear+1)%maxsize==qu.front) //不队满的判断条件，队满侧不能入队 
    return 1;               
    else
    return 0;
}
int enQueue(SqQueue &qu,int x)
{
    if((qu.rear+1)%maxsize==qu.front)//队满的判断条件，队满侧不能入队 
    return 0;
    qu.rear = (qu.rear+1)%maxsize;  //若队不空，则先移动指针 
    qu.data[qu.rear]=x;   //再存入元素 
    return 1;
}
int deQueue(SqQueue &qu,int &x)
{
    if(qu.front==qu.rear)    //若队空，则不能出队 
    return 0;
    qu.front = (qu.front+1)%maxsize;//若队不空，则先移动指针 
    x=qu.data[qu.front];        //再取出元素 
    return 1;
}
int Queuefront(SqQueue &qu)  
{  
　　if(qu.front==qu.rear)  
    return 0;
　　 return qu.data[qu.front];
}  
void show (SqQueue qu)
{
    int i;
    printf("队列元素：front to rear:\n");
    for(i=qu.front+1;i<=qu.rear;i++)
    printf("%d ",qu.data[i]);
    printf("\n");
}
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {
    SqQueue qu;
    int a,b=1,c=2,k;
    InitQueue(qu);
    a=QueueEmpty(qu);
    printf("队是否为空：%d (1:空  0：不空)\n",a);
    enQueue(qu,b);
    printf("%d 入队\n",b);
    enQueue(qu,c);
    printf("%d 入队\n",c);
    show (qu);
    a=QueueEmpty(qu);
    printf("队是否为空：%d (1:空  0：不空)\n",a);
    deQueue(qu,k);
    printf("%d 出队\n",k);
    show (qu);
    return 0;
}
2.3 循环队列

​ 为了克服线性队列造成的空间浪费，我们引入循环向量的概念，它就好像是把向量空间弯起来，形成一个头尾相接的环形，这样当队列的头尾指针移动到队列的尾部时，再进行入队的操作，就使指针指向队列的队头，也就是从头开始。这时的队列就称循环队列。
​ 通常我们所使用的大都是循环队列。但由于循环的原因，我们就不能当头尾指针重叠在一起来判断队列为空还是满的情况，为了避免这种情况，我们又引入了边界条件的概念。

img

解决方法有：
　 ① 另设一个布尔变量以区别队列的空和满；
　 ② 少用一个元素，当入队时，先测试入队后尾指针是不是会等于头指针，如果相等就算队已满，不许入队；
​ ③ 使用一个记数器记录元素总数。

顺序队列的类型定义为： 

typedef struct QNode
{
    int data;
    struct QNode *next;
}QNode;
typedef struct
{
    QNode *front;
    QNode *rear;
}LiQueue;

2.3.1 循环队列的基本运算

(1) 建空队

void InitQueue(LiQueue *&lqu)///初始化队列
{
    lqu=(LiQueue *)malloc(sizeof(LiQueue));
    lqu->front=lqu->rear=NULL;
}

(2) 判队空

int QueueEmpty(LiQueue *lqu)//判断队列为空 
{
    if(lqu->front==NULL||lqu->rear==NULL)
    return 1;
    else
    return 0;
}

(3) 入队

void enQueue(LiQueue *lqu,int x)
{///入队
    QNode *p;
    p=(QNode *)malloc(sizeof(QNode));
    p->data=x;
    p->next=NULL;
    if(lqu->rear==NULL)
        lqu->front=lqu->rear=p;
    else
    {
        lqu->rear->next=p;
        lqu->rear=p;
    }
}

(4) 出队

int deQueue(LiQueue *lqu,int &x)
{///出队
    QNode *p;
    if(lqu->rear==NULL) 
    return 0;    //对空不能出队 
    else
    p=lqu->front;
    if(lqu->front==lqu->rear)
       lqu->front=lqu->rear=NULL;
    else
    lqu->front=lqu->front->next;    
    x=p->data;
    free(p);
    return 1;
}

(5) 取队头元素

int Queuefront(LiQueue *lqu)  
{ 
    if(lqu->front==NULL||lqu->rear==NULL)
        return 0;
    return lqu->front->data;  
}

代码实现如下：

#include <stdio.h>
#include <malloc.h>
typedef struct QNode
{
    int data;
    struct QNode *next;
}QNode;
typedef struct
{
    QNode *front;
    QNode *rear;
}LiQueue;
void InitQueue(LiQueue *&lqu)///初始化队列
{
    lqu=(LiQueue *)malloc(sizeof(LiQueue));
    lqu->front=lqu->rear=NULL;
}
int QueueEmpty(LiQueue *lqu)//判断队列为空 
{
    if(lqu->front==NULL||lqu->rear==NULL)
    return 1;
    else
    return 0;
}
void enQueue(LiQueue *lqu,int x)
{///入队
    QNode *p;
    p=(QNode *)malloc(sizeof(QNode));
    p->data=x;
    p->next=NULL;
    if(lqu->rear==NULL)
        lqu->front=lqu->rear=p;
    else
    {
        lqu->rear->next=p;
        lqu->rear=p;
    }
}
int deQueue(LiQueue *lqu,int &x)
{///出队
    QNode *p;
    if(lqu->rear==NULL) 
    return 0;    //对空不能出队 
    else
    p=lqu->front;
    if(lqu->front==lqu->rear)
       lqu->front=lqu->rear=NULL;
    else
    lqu->front=lqu->front->next;    
    x=p->data;
    free(p);
    return 1;
}
int Queuefront(LiQueue *lqu)  
{ 
    if(lqu->front==NULL||lqu->rear==NULL)
        return 0;
    return lqu->front->data;  
}  
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {
    LiQueue *qu;
    int a,b=1,c=2,k;
    InitQueue(qu);
    a=QueueEmpty(qu);
    printf("队是否为空：%d (1:空  0：不空)\n",a);
    enQueue(qu,b);
    printf("%d 入队\n",b);
    enQueue(qu,c);
    printf("%d 入队\n",c);
    a=QueueEmpty(qu);
    printf("队是否为空：%d (1:空  0：不空)\n",a);
    deQueue(qu,k);
    printf("%d 出队\n",k);
    return 0;
}
3、总结：

​ 最近又重新学习数据结构的东西，好长时间没看差不多都忘了。花了好几个小时，查阅资料，把数据结构栈和队列的知识从头到尾的把数据结构的线性结构复习了一遍，相信经过上面的复习，对线性结构又有了更深入的了解。你后会经常写一些总结发出来，复习起来会好很多。笔者学疏才浅，如果文章有误，敬请各位高手斧正。

参考博文 http://blog.csdn.net/zhang_xinxiu/article/details/11962605

​http://blog.csdn.net/hguisu/article/details/7674195

泸州月
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-栈和队列.pptx
07-11
数据结构与算法 数据结构-栈和队列全文共41页，当前为第1页。 一、线性结构 （二）栈和队列 数据结构-栈和队列全文共41页，当前为第2页。 1.定义 2.1 栈 与线性表相同，仍为一对一( 1:1)关系。 用顺序栈或链栈存储均...
【数据结构】栈（顺序栈、双端栈、链栈）的存储结构及基本运算（C语言）
weixin_51450101的博客
01-17 2277
目录1. 栈的基本概念2. 顺序栈3. 双端顺序栈（两栈共享技术）4. 链栈 1. 栈的基本概念 栈是一种限定性线性表，是将线性表的插入和删除操作限制为仅在表的一端进行，通常将表中允许进行插入删除的一端称为栈顶（Top），因此栈顶的当前位置是动态变化的，它由一个称为栈顶指针的位置指示器来指示。表的另一端称为栈底（Bottom）。当栈中没有元素时称为空栈。 栈的修改是按后进先出的原则，如元素以 a1,a2,a3,…,an 的顺序进栈，则出栈顺序为 an,…,a3,a2,a1 。每次进栈的元素的元素都被放在原
数据结构-顺序栈详解（C语言）
最新发布
m0_55698213的博客
10-20 1538
本文主要讲述顺序栈基本定义和特点以及顺序栈的C语言代码实现与顺序栈的实际应用。以上就是顺序栈的基本介绍，本文仅仅简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出（FILO）的原则，即在栈顶添加和删除元素。顺序栈在计算机科学中经常使用，因为它允许我们在高频率的情况下进行添加和删除操作。
顺序栈的定义和特点，顺序栈的基本操作操作（创建、遍历、出栈、入栈）
小钱努力学C的博客
07-21 351
栈的定义和特点描述，顺序栈以及链栈基本操作（增删改查）的实现。
数据结构 第三章：栈和队列
m0_61532661的博客
08-15 162
栈和队列是两种常用的、重要的数据结构是限定插入和删除只能在表的“端点”进行的线性表普通线性表的插入和删除操作栈和队列是线性表的子集（是插入和删除位置受限的线性表）规定栈的插入和删除只能在表尾操作栈的操作具有后进先出的固有特性如果问题求解的过程具有“后进先出”的天然特性，则求解算法中必然需要利用“栈”数制转换表达式求值括号匹配的检验八皇后问题行编辑程序函数调用迷宫求解递归调用的实现队列只能插入在表尾，删除只能删除表头元素队列的操作具有先进先出。
在顺序队列中，什么叫真溢出？什么叫假溢出？为什么顺序队列通常都采用顺序循环队列结构？
yygr的博客
01-24 5861
https://zhidao.baidu.com/question/37559933.html 在顺序队列中，由于数组空间不够而产生的溢出叫真溢出； 顺序队列因多次入队列和出队列操作后出现的有存储空间但不能进行入队列操作的溢出称为假溢出； 假溢出是由于队尾rear的值和队头front的值不能由所定义数组下界值自动转为数组上界值而产生的，解决的办法是把顺序队列所使用的存储空间构造成一个逻辑上首尾相连的循环队列。 和顺序表一样，顺序队列用一个向量空间来存放当前队列中的元素。由于队列的队头和队尾的位置是变化的，设
数据结构-栈和队列-PPT
02-04
数据结构-栈和队列-PPT
数据结构-栈和队列的使用
03-25
数据结构， 栈和队列的C语言用法； 包含基本原理以及使用的C语言例程，方便快捷
数据结构-栈和队列.ppt
11-06
对线性表 L=(a1,a2,,...,an), 可在任意第i(i=1,2,,...n,n+1)个位置插入新元素， 或删除任意第i(i=1,2,,...n)个元素 受限数据结构---- 插入和删除受限制的线性表。 1.栈(stack), 2.队列(queue)
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
数据结构之栈和队列（顺序栈、链栈、循环队列）
qq_43752469的博客
09-12 1253
一、栈 1、栈以及栈的基本操作 （1）栈：只允许在一端进行插入或删除操作的线性表。特点：先进后出。 栈顶：允许进行插入删除。 栈底：不允许进行插入和删除，固定的。 （2）栈的基本操作 2、栈的顺序存储结构 （1）顺序栈的实现 （2）顺序栈的基本操作 顺序栈的基本运算： （3）共享栈：栈底位置相对不变，两个顺序栈共享一个一维数组空间，将两个栈底分布设置在两端，两个栈顶向共享空间的中间延伸。 栈空：top0=-1，top1=maxsize 栈满：top1=top0+1 进栈：s.data[++top0
数据结构-队列（C语言）
CC的博客
07-23 479
数据结构-队列（C语言）
栈之顺序栈
GailyYelp的博客
03-26 931
目录 顺序栈的简介 举例以及详细分析 代码块 测试结果 顺序栈的简介在顺序栈中有”上溢”和”下溢”的概念。顺序栈好比一个盒子，我们在里头放了一叠书，当我们要用书的话只能从第一本开始拿(你会把盒子翻过来吗?真聪明^^)，那么当我们把书本放到这个栈中超过盒子的顶部时就放不下了(叠上去的不算，哼哼)，这时就是”上溢”,”上溢”也就是栈顶指针指出栈的外面，显然是出错了。反之，当栈中已没有书时，我们再去拿，看
顺序栈 和链栈
weixin_43154720的博客
10-18 9752
栈是一种特殊的线性表，因此可以用线性表的方法来存储栈。最简单的方法就是用一维数组来存储。由于栈底固定不变的，而栈顶随进出栈操作动态变化的，因此为了实现对的栈的操作，必须记住栈顶的当前位置。 顺序栈优缺点： 优点：简单、存储密度高。 确定：即使栈的长度很长，也还是可能发生上溢。当栈的容量不固定时，必须设置栈的长度以使其可以容纳更多的元素，容易浪费空间。 #include<iostream> #include<cstdio> using namespace std; const
数据结构（四）——栈
qq_38181811的博客
03-12 1225
栈，即stack，同样是线性表。只是它在设计时，运算规则做了限制。是限定性的线性表结构。 栈，只能在固定的一端插入和取出（取出，也就意味着删除了）。通常，能插入删除的那一端，叫做栈顶，top；不能插入删除的，称为栈底，bottom。插入栈，称为入栈。删除，称为出栈/退栈。当栈中没有元素时，称为空栈。 学习过单片机的应该对栈有了解，毕竟是有一个实实在在的物理容器的概念。出入栈的原则，是先进后出，la...
上溢与下溢
热门推荐
a19576的专栏
07-12 2万+
堆栈的上溢与下溢 由于堆栈区域是在堆栈定义时就确定了的，因而堆栈工作过程中有可能产生溢出。堆栈溢出有两种情况可能发生：如堆栈已满，但还想再存入信息，这种情况称为堆栈上溢；另一种情况是，如堆栈已空，但还想再取出信息，这种情况称为堆栈下溢。不论上溢或下溢，都是不允许的。因此在编制程序时，如果可能发生堆栈溢出，则应在程序中采取保护措施。这可以通过给SP规定上、下限，在进栈或出栈操作前先做SP和边界值的
顺序栈与链式栈
weixin_30839881的博客
08-07 92
　　栈是限定尽在表尾进行插入或者删除操作的线性表，分为顺序栈和链式栈。 　　对于malloc()一次申请的内存地址，在逻辑上是连续的，也就是我们用的时候可以当做连续的来用，但是在物理内存上未必是连续的； 　　顺序栈： 　　　　利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设top指示栈顶元素在顺序栈中的位置，top永远指向栈顶元素的下一个元素位置，下面我们来看 ...
数据结构（队列）
m0_62292821的博客
03-26 4453
队列是一种先进先出的线性表，只允许在队尾插入，在队头删除元素。 队列也分为顺序队列和链队列 队列的实现 队列的顺序存储结构 在队列的存储结构中，需要设置front和rear两个整形变量来分别指示队头元素和队尾元素（又称头指针和尾指针）。 typedef struct { QElemType *base;//初始化时动态分配存储空间 int front;//头指针 int rear;//尾指针 } SqQueue; 循环队列 当入队次数足够多时，我们会发现数据不能如队列了，但队列中还有剩余
(1)堆栈（顺序栈）
m0_56696378的博客
07-15 1417
数据结构的学习笔记
十进制转化二进制顺序栈
08-09
### 回答1： 好的，我了解您的问题。实现十进制转二进制可以使用顺序栈来模拟，具体步骤如下： 1.将十进制数入栈。 2.用栈顶元素除以二，得到商和余数，余数入栈。 3.重复第2步，直到商为0。 4.弹出栈中所有元素，即为该十进制数的二进制表示。 需要注意的是，在弹出栈中元素时，要注意顺序，以得到正确的二进制表示。 希望我的回答对您有所帮助。 ### 回答2： 十进制转化为二进制的过程可以通过顺序栈来实现。首先，我们需要创建一个空栈，作为二进制数的容器。 将十进制数从右往左依次除以2，将余数依次压入栈中，直到除完。 接下来，我们开始弹出栈中的元素，即从栈中取出元素，直到栈为空。将弹出的元素依次排列起来，即为十进制数的二进制表示。 举个例子，我们将十进制数13转化为二进制数。 首先，将13除以2，得到的余数为1，将1压入栈中。然后将13除以2，得到的商为6，再次除以2，得到余数为0，将0压入栈中。最后，将6除以2，得到的商为3，再次除以2，得到的余数为1，将1压入栈中。 现在我们开始弹出栈中的元素，依次为1、0、1。将它们按照弹出顺序排列起来，得到的二进制数表示为101。 因此，十进制数13转化为二进制数的结果是101。 以上就是使用顺序栈实现十进制转化二进制的过程。通过这种方法，我们可以将任意十进制数转化为对应的二进制数。 ### 回答3： 十进制转化为二进制可以通过顺序栈来实现。首先，我们需要明确十进制转换为二进制的原理。 在十进制转换为二进制时，我们需要不断地除以2，并将余数存入栈中。具体操作如下： 1. 初始化一个空的顺序栈。 2. 将十进制数除以2，并取得其余数。 3. 将余数入栈。 4. 将十进制数除以2取整，然后继续执行第2步骤，直到十进制数变为0. 5. 从栈顶开始依次弹出栈中的元素，即可得到二进制数。 下面是一个具体的例子来说明： 以十进制数12转化为二进制数为例。 1. 初始化一个空的顺序栈。 2. 12除以2，得到6余数0。将余数0入栈。 3. 6除以2，得到3余数0。将余数0入栈。 4. 3除以2，得到1余数1。将余数1入栈。 5. 1除以2，得到0余数1。将余数1入栈。 6. 十进制数变为0，停止除法运算。 7. 从栈顶开始弹出栈中的元素，得到的顺序就是12的二进制表示。 第一个弹出的元素是1，第二个是1，第三个是0，第四个是0。 因此，12的二进制表示为1100。 通过以上步骤，我们可以将任意的十进制数转化为二进制数。这个过程中顺序栈的作用是将余数按照反序存储，然后逐个弹出，最终得到正确的二进制表示。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

泸州月

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

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

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

打赏作者

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

抵扣说明：

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

余额充值