16-棧的幾種用法_案例代碼

原創 ibbo 2020-07-08 05:44

棧:

代碼 1 : stack

#include <stdio.h>
#include <stdlib.h>

//類型
typedef struct node{
    int *data;
    int top;
    int size;
}stacks_t;

//創建
stacks_t * create_stack(int size)
{
    if(size<0||size>1024)
        return NULL;

    stacks_t* stack=malloc(sizeof(stacks_t));

    stack->size=size;
    stack->top=-1;

    stack->data=malloc(sizeof(int)*size);

    return stack;

}

//判空
int isempty(stacks_t* stack)
{
    if(stack==NULL)
        return 0;

    return stack->top==-1;
}

//判滿
int isfull(stacks_t* stack)
{
    if(stack==NULL)
        return 0;

    return stack->top==stack->size-1;
}

//入棧  push
int push_stack(stacks_t* stack,int data)
{
    if(stack==NULL||isfull(stack))
        return -1;

    stack->top++;

    stack->data[stack->top]=data;

    return 0;
}

//出棧
//不使用  返回值的情況下，把棧頂元素拿出來 放到某個變量裏面去
//指針
int pop_stack(stacks_t* stack,int *data)//  int *  雙向傳參  可讀可寫   const  只讀
{
    if(stack==NULL||isempty(stack)||data==NULL)
        return -1;

    *data=stack->data[stack->top--];

    return 0;
}

//打印  （假打印）
int print_stack_notreal(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    int i;
    for(i=stack->top;i>=0;i--)
    {
        printf("%3d ",stack->data[i]);

    }
    printf("\n");

    return 0;
}

//看一眼  查看棧頂元素
int view_stack(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    printf("%3d ",stack->data[stack->top]);

    return 0;

}

//清空
int clear_stack(stacks_t* stack)
{
    if(NULL==stack)
        return -1;

    stack->top=-1;

    return 0;
}

//銷燬
int destroy_stack(stacks_t* stack)
{
    if(stack==NULL)
        return -1;

    free(stack->data);
    free(stack);
    return 0;
}

//長度
int length_stack(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return 0;

    return stack->top+1;
}

//真打印
int print_stack_real(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    stacks_t* temp=create_stack(length_stack(stack));

    int data;
    while(!isempty(stack))
    {
        view_stack(stack);

        pop_stack(stack,&data);

        push_stack(temp,data);
    }
    printf("\n");

    while(!isempty(temp))
    {
        pop_stack(temp,&data);

        push_stack(stack,data);
    }

    destroy_stack(temp);

    return 0;
}


//真逆打印
int reprint_stack_real(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    stacks_t* temp=create_stack(length_stack(stack));

    int data;
    while(!isempty(stack))
    {
        pop_stack(stack,&data);

        push_stack(temp,data);
    }

    while(!isempty(temp))
    {
        view_stack(temp);

        pop_stack(temp,&data);

        push_stack(stack,data);
    }
    printf("\n");

    destroy_stack(temp);

    return 0;
}


int main(int argc, const char *argv[])
{
    stacks_t* stack=create_stack(30);

    int i;

    for(i=1;i<=15;i++)
    {
        push_stack(stack,i);
        print_stack_notreal(stack);

    }

    print_stack_real(stack);
    reprint_stack_real(stack);
    print_stack_notreal(stack);

    return 0;
}

代碼 2 : linkstack

#include <stdio.h>
#include <stdlib.h>

typedef struct node{
    int data;
    struct node * next;
}linkstack_t;

//創建
linkstack_t* create_stack()
{
    linkstack_t* stack=malloc(sizeof(linkstack_t));
    stack->next=NULL;
    return stack;
}

//判空
int isempty_stack(linkstack_t* stack)
{
    if(stack==NULL)
        return 0;

    return stack->next==NULL;
}

//入棧
int push_stack(linkstack_t* stack,int data)
{
    if(stack==NULL)
        return -1;

    linkstack_t* newnode=create_stack();
    newnode->data=data;
    newnode->next=stack->next;
    stack->next=newnode;

    return 0;
}

//出棧
int pop_stack(linkstack_t* stack,int *data)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;


    linkstack_t* temp=stack->next;

    *data=temp->data;

    stack->next=temp->next;

    free(temp);

    return 0;
}

//假打印
int print_stack_notreal(linkstack_t* stack)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;

    while(stack->next!=NULL)
    {
        printf("%3d ",stack->next->data);

        stack=stack->next;

    }
    printf("\n");

    return 0;
}

//清空
int clear_stack(linkstack_t* stack)
{
    if(stack==NULL)
        return -1;

    int data;
    while(!isempty_stack(stack))
    {
        pop_stack(stack,&data);
    }

    return 0;
}

//銷燬
int destroy_stack(linkstack_t* stack)
{
    if(NULL==stack)
        return -1;

    if(!isempty_stack(stack))
        clear_stack(stack);

    free(stack);

    return 0;
}

//真打印
int print_stack_real(linkstack_t* stack)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;

    int data;

    linkstack_t* temp=create_stack();

    while(!isempty_stack(stack))
    {
        pop_stack(stack,&data);

        printf("%3d ",data);

        push_stack(temp,data);
    }
    printf("\n");

    while(!isempty_stack(temp))
    {
        pop_stack(temp,&data);

        push_stack(stack,data);
    }

    destroy_stack(temp);

    return 0;
}

//真逆打印
int reprint_stack_real(linkstack_t* stack)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;

    int data;

    linkstack_t* temp=create_stack();

    while(!isempty_stack(stack))
    {
        pop_stack(stack,&data);

        push_stack(temp,data);
    }

    while(!isempty_stack(temp))
    {
        pop_stack(temp,&data);

        printf("%3d ",data);

        push_stack(stack,data);
    }
    printf("\n");

    destroy_stack(temp);

    return 0;
}

int main(int argc, const char *argv[])
{

    linkstack_t* stack=create_stack();

    int i;

    for(i=1;i<=20;i++)
    {
        push_stack(stack,i);
        print_stack_real(stack);
    }

    int data;
    for(i=1;i<=20;i++)
    {
        pop_stack(stack,&data);

        reprint_stack_real(stack);
    }

    return 0;
}

代碼 3 : linkqueue

#include <stdio.h>
#include <stdlib.h>

typedef struct node{
    int data;
    struct node* next;
}list_t;


typedef struct queuenode{

    list_t* head;
    list_t* tail;

}queue_t;

//創建
queue_t* create_queue()
{
    queue_t* queue=malloc(sizeof(queue_t));

    queue->head=malloc(sizeof(list_t));
    queue->head->next=NULL;

    queue->tail=queue->head;

    return queue;

}

//判空
int isempty(queue_t* queue)
{
    if(queue==NULL)
        return 0;

    return queue->head->next==NULL;

}

//入隊
int push_queue(queue_t* queue,int data)
{
    if(queue==NULL)
        return -1;

    list_t* newnode=malloc(sizeof(list_t));
    newnode->next=NULL;
    newnode->data=data;

    queue->tail->next=newnode;

    queue->tail=newnode;

    return 0;
}

//出隊
int pop_queue(queue_t* queue,int *data)
{
    //嘗試 全部取出數據，再放入幾個數據，再打印看一下，刪除真的沒問題麼？？？？
    //坑？？？？:
    if(queue==NULL||isempty(queue))
        return -1;

    list_t* temp=queue->head->next;

    if(temp==queue->tail)
        queue->tail=queue->head;

    *data=temp->data;

    queue->head->next=temp->next;

    free(temp);

    return 0;

}

//長度
int length_queue(queue_t* queue)
{

    if(queue==NULL||isempty(queue))
        return 0;

    list_t* temp=queue->head;

    int sum=0;
    while(temp->next!=NULL)
    {
        sum++;
        temp=temp->next;
    }

    return sum;
}

//假打印
int print_queue_notreal(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    list_t* temp=queue->head;

    while(temp->next!=NULL)
    {
        printf("%3d ",temp->next->data);
        temp=temp->next;
    }
    printf("\n");

    return 0;
}

//清空
int clear_queue(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    int data;

    while(!isempty(queue))
    {
        pop_queue(queue,&data);

    }
    return 0;
}

//銷燬
int destroy_queue(queue_t* queue)
{
    if(queue==NULL)
        return -1;

    if(!isempty(queue))
        clear_queue(queue);

    free(queue->head);
    free(queue);

    return 0;
}

//真正打印1
int print_queue_real(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    queue_t* temp=create_queue();

    int data;
    while(!isempty(queue))
    {
        pop_queue(queue,&data);

        printf("%3d ",data);

        push_queue(temp,data);
    }
    printf("\n");

    while(!isempty(temp))
    {
        pop_queue(temp,&data);

        push_queue(queue,data);
    }
    destroy_queue(temp) ;

    return 0;
}

//真正打印2
int print_queue_real2(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    int *stack1=malloc(sizeof(int)*length_queue(queue));

    int top1=-1;

    int *stack2=malloc(sizeof(int)*length_queue(queue));

    int top2=-1;

    int data;
    while(!isempty(queue))
    {
        pop_queue(queue,&data);
        printf("%3d ",data);

        stack1[++top1]=data;
    }

    while(top1!=-1)
    {
        data=stack1[top1--];

        stack2[++top2]=data;
    }

    while(top2!=-1)
    {
        data=stack2[top2--];

        push_queue(queue,data);
    }

    printf("\n");

    free(stack1);
    free(stack2);

    return 0;
}

//真逆打印
int reprint_queue_real(queue_t* queue)//經典面試題：兩個棧實現一個隊列功能
{
    if(queue==NULL||isempty(queue))
        return -1;

    int *stack1=malloc(sizeof(int)*length_queue(queue));

    int top1=-1;

    int *stack2=malloc(sizeof(int)*length_queue(queue));

    int top2=-1;

    int data;
    while(!isempty(queue))
    {
        pop_queue(queue,&data);

        stack1[++top1]=data;
    }

    while(top1!=-1)
    {
        data=stack1[top1--];

        printf("%3d ",data);

        stack2[++top2]=data;
    }

    while(top2!=-1)
    {
        data=stack2[top2--];

        push_queue(queue,data);
    }

    printf("\n");

    free(stack1);
    free(stack2);

    return 0;
}

int main(int argc, const char *argv[])
{
    queue_t* queue=create_queue();

    int i;
    for(i=1;i<=15;i++)
    {
        push_queue(queue,i*2);
        print_queue_real(queue);
    }

    reprint_queue_real(queue);

    print_queue_real2(queue);
    print_queue_real(queue);
    print_queue_notreal(queue);

    return 0;
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

17-tree_queue_linkstack_linkqueue_代碼案例

代碼 1 : tree #include <stdio.h> #include <stdlib.h> typedef struct node{ int data; struct node * lchild;

ibbo 2020-07-08 05:44:47

12-Shell腳本_練習

變量 : 使用變量時, 必須在變量名前加$ 用戶自定義變量 : 沒有數據類型和存儲類型 直接定義使用, 在定義時必須賦值 在 = 的左右兩端不要出現空格符 如果值出現空格, 需要使用” “ echo $var : 不關心

ibbo 2020-07-08 05:44:35

8-數據類型_處理5個學生的數據

數據結構練習: 構造一個學生類型 : 姓名, 年齡, 學號, 成績 處理5個學生的數據; 循環輸入學生信息; 找出成績最高的學生, 並且打印其信息(注意:不要排序). 按照成績排序, 並且打印其信息. #include <st

ibbo 2020-07-08 05:44:35

基本數據結構——線性結構（棧）

1.什麼是線性結構 線性結構是一種有序數據項的集合，其中每個數據項都有唯一的前驅和後繼（除了第一個沒有前驅，最後一個沒有後繼）。新的數據項加入到數據集中時，只會加入到原有某個數據項之前或之後。具有這種性質的數據集，就稱爲線性結構。

weixin_38324954 2020-07-08 11:06:52

【算法】leetcode 84. 柱狀圖中最大的矩形（單調棧）

問題來源 84. 柱狀圖中最大的矩形 84. 柱狀圖中最大的矩形 給定 n 個非負整數，用來表示柱狀圖中各個柱子的高度。每個柱子彼此相鄰，且寬度爲 1 。 求在該柱狀圖中，能夠勾勒出來的矩形的最大面積。 以上是柱狀圖的示例

岚清子 2020-07-08 09:13:35

棧的應用：中綴表達式和後綴表達式互轉

一、概要        中綴表達式是我們經常接觸的算術表達式，如（a+b）* c，a * （c - d）等，優點是便於記憶，缺點是對運算順序有嚴格的要求。後綴表達式又稱逆波蘭式，如abc*+d e *f+g*+，雖然不便記憶，但是它不像中

Paul-LangJun 2020-07-08 06:58:23

【線性 dp】A015_LC_最長有效括號（棧 + dp / 空間壓縮）

一、Problem Given a string containing just the characters ‘(’ and ‘)’, find the length of the longest valid (well-for

ByteSinging 2020-07-08 05:01:10

數據結構筆記淺記（三）空間複雜度

用於衡量算法佔用內存空間隨着數據量變大時的增長趨勢。這個概念與時 間複雜度非常類似，只需將“運行時間”替換爲“佔用內存空間”。   算法在運行過程中使用的內存空間主要包括以下幾種。         ‧ 輸入空間：用於存儲算法的輸入數據。  

原創 2024-03-23 00:43:15

go學習-struct

初始化package main import ( "fmt" ) type person struct { Name string Age int } func main() { a := person{ Name:

coder_cll 2020-07-08 12:24:18

杭電hdu 1086 You can Solve a Geometry Problem too 線段相交

http://acm.hdu.edu.cn/showproblem.php?pid=1086 判斷兩條線段是否相交。用叉乘來判斷。 #include <stdio.h> struct Lpoint { double x; doubl

wchyumo2009 2020-07-08 12:20:38

ip轉換爲數值 數值轉換爲ip c++

作爲練習，自己編了一個：   #include "stdafx.h" #include <iostream> #include <string> //#include <windows.h> using namespace std;

hityct1 2020-07-08 09:03:05

鏈表的建立插入與刪除

//file 鏈表的建立插入與刪除.cpp #include"iostream.h"#include"string.h"#include"stdlib.h" struct listnode{ //鏈表結點的類型聲明 int num; ch

陆家三少 2020-07-08 08:35:09

文件的讀與寫操作

//文件的讀與寫操作.cpp #include <iostream.h>#include"fstream.h"#include<stdlib.h> #define SIZE 2 typedef struct{ char name[10];

陆家三少 2020-07-08 08:35:09

從面向結構到面向對象-----josephus問題(方法二:結構的應用）

今天看了一下josephus問題，突然有點想寫些東西的衝動，結合自己的部份思想，於是便寫了這幾篇帖子。因爲有幾篇代碼有點長，就分開發吧。如果對你有什麼幫助的話，本人勝感欣慰。也許你會說，這個問題好多書上都有代碼，但本人詣在於用不同的方法寫

yingcongxiao 2020-07-08 05:47:57

線性表的構造

線性表的邏輯定義    　線性表（Linear List）是由n（n≥0）個數據元素（結點）a1，a2，…，an組成的有限序列。   　 ① 數據元素的個數n定義爲表的長度（n=0時稱爲空表）。    　② 將非空的線性表（n＞0）記作：

yingcongxiao 2020-07-08 05:47:46