三.栈、队列、数组

闲的没事干.

已于 2023-09-10 15:09:23 修改

阅读量73

点赞数

文章标签： c语言数据结构

于 2023-08-26 22:21:03 首次发布

本文链接：https://blog.csdn.net/weixin_55574534/article/details/132516734

版权

第三章栈、堆、数组

一.顺序栈
二.队列
课后习题
- 3.3栈实现递归函数的非递归计算

一.顺序栈

1 .顺序栈

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define maxsize 10
typedef struct{
    int data[maxsize];
    int top;        //栈顶
}sqtack;
//1初始化
void initstack(sqtack * sk){
//    sk.top =-1;
    sk->top =-1;
}
//2判空
bool stackempty(sqtack sk){
    if(sk.top == -1){
        return true;
    }
    else
        return false;
}
//3进栈
bool push(sqtack *sk,int element){
    if(sk->top ==maxsize-1){
        return false;   //栈满
    }
    sk->data[++sk->top]=element;
    return true;
}
//4出栈
bool pop(sqtack *sk,int* element ){
    if(sk->top ==-1){
        printf("\n当前栈为空栈，出栈失败!\n");
        return false; //栈空
    }
    *element=sk->data[sk->top--];   //element是地址
    printf("\t出栈:%d",*element);
    return true;
}
//5读栈顶元素
bool gettop(sqtack sk,int *element){
    if(sk.top == -1)
        return false;  //栈空
    *element=sk.data[sk.top];
    printf("当前栈顶元素:%d \n",*element);
    return true;
}

void print_stack(sqtack sk){
    printf("栈中元素:");
    while(sk.top!=-1){
        printf("\t %d",sk.data[sk.top--]);
    }
    printf("\n");
}
void test(){
    sqtack sk;
    int element;
    initstack(&sk);
    push(&sk,1);
    gettop(sk,&element);
    push(&sk,2);
    gettop(sk,&element);
    push(&sk,3);
    gettop(sk,&element);
    push(&sk,4);
    gettop(sk,&element);
    print_stack(sk);
//打印出栈元素在pop函数中，懒得在main函数中写，main函数element拿到的是出栈元素
    pop(&sk,&element);
    pop(&sk,&element);
    pop(&sk,&element);
    pop(&sk,&element);
    pop(&sk,&element);//故意在空栈多出栈
}

int main()
{
    test();
    return 0;
}

2.共享栈

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define maxsize 10
typedef struct{
    int data[maxsize];
    int top1;        //栈1       从上往下
    int top2;        //栈2       从下往上
}sharestack;    //共享栈

void print_stack(sharestack sk){
    printf("该共享栈中元素:\n");
    printf("\t栈1中元素:");
    while(sk.top1!=maxsize){
        printf("\t %d",sk.data[sk.top1++]);
    }
    printf("\n");
    printf("\t栈2中元素:");
        while(sk.top2!=-1){
        printf("\t %d",sk.data[sk.top2--]);
    }
    printf("\n");
}

//1初始化
void initstack(sharestack * sk){
    sk->top1 =maxsize;
    sk->top2 =-1;
}
//2判空
bool stackempty(sharestack sk){
    if(sk.top2 == -1 && sk.top1==maxsize){
        return true;
    }
    else
        return false;
}
//3进栈
bool push(sharestack *sk,int element,int num){   //num表示进栈1还是栈2
    if(sk->top1  ==sk->top2+1){
        return false;   //栈满
    }
    if(num==1)
        sk->data[--sk->top1]=element;
    else if(num==2)
        sk->data[++sk->top2]=element;
    else
        printf("该共享栈仅栈1和栈2\n");
    return true;
}
//4出栈
bool pop(sharestack *sk,int* element,int num){
    if(sk->top2 ==-1 && sk->top1==maxsize){
        printf("\n当前栈为空栈，出栈失败!\n");
        return false; //栈空
    }
    if(num==1){
        if(sk->top1!=maxsize){
            *element=sk->data[sk->top1++];   //element是地址
            printf("\t栈1出栈:%d",*element);
        }
        else printf("\n栈1当前为空栈!\n");
    }

    else if(num==2){
        if(sk->top2!=-1){
            *element=sk->data[sk->top2--];   //element是地址
            printf("\t栈2出栈:%d",*element);
        }
        else printf("栈2当前为空栈!\n");
    }
    return true;
}
//5读栈顶元素
bool gettop(sharestack sk,int *element,int num){
    if(sk.top1 == maxsize && sk.top2 ==-1)
        return false;  //栈空
    if(num==1){
        *element=sk.data[sk.top1];   //element是地址
        printf("当前栈1顶元素:%d \n",*element);
    }
    else if(num==2){
       *element=sk.data[sk.top2];   //element是地址
        printf("当前栈2顶元素:%d \n",*element);
    }
    return true;
}


void test(){
    sharestack sk;
    int element;
    initstack(&sk);
    push(&sk,1,1);      //栈地址 进栈元素  进共享栈中栈1
    gettop(sk,&element,1);
    push(&sk,2,2);      //栈地址 进栈元素  进共享栈中栈2
    gettop(sk,&element,2);
    push(&sk,3,1);
    gettop(sk,&element,1);
    push(&sk,4,2);
    gettop(sk,&element,2);
    print_stack(sk);
//打印出栈元素在pop函数中，懒得在main函数中写，main函数element拿到的是出栈元素

    printf("出栈:\n");
    pop(&sk,&element,1);
    pop(&sk,&element,2);
    pop(&sk,&element,1);
    pop(&sk,&element,2);
    pop(&sk,&element,1);//故意在空栈多出栈
    pop(&sk,&element,2);//故意在空栈多出栈
}
int main()
{
    test();
    return 0;
}

3.链栈（不带头节点）

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>  //bool
#include <stddef.h>   // null
#include<malloc.h>      //malloc、free
typedef struct node{
    int data;
    struct node *next;
}node,*linklist;

linklist init(linklist lt){
    lt =NULL;
    return lt;
}
void print_list(linklist lt){   //打印链表，遍历每个节点并输出数据
    if(lt==NULL){
        printf("当前为空表！\n");
        return ;
    }
    printf("链表元素中有:");
    while(lt)
    {
        printf("%d\t",lt->data);
        lt= lt->next;
    }
    printf("\n");
}

linklist head_insert(linklist lt){ //头插法，每次插入的元素都会成为链表的第一个节点，并且在函数中初始化链表
    int n=0, e=0;
    printf("请输入要插入元素个数:");
    scanf("%d",&n);
    printf("\t请输入插入的元素:");
    for(int i=0;i<n;i++)
    {
        node*s = (node*)malloc(sizeof(node));
        scanf("%d",&e);
        s->data =e;
        s->next = lt;   //把当前节点的next指向原来的链表
        lt = s;         //把链表的头指针指向当前节点
    }
    return lt; //返回新的链表头指针
}
linklist head_delete(linklist lt){
    if(lt==NULL){
        printf("当前为空表！\n");
        return lt;
    }
    node *temp=lt;
    lt = lt->next;
    free(temp);
    return lt;
}
int main()
{
    linklist lt; //定义一个链表头指针
    lt =init(lt);
    lt = head_insert(lt); //调用头插法函数，返回新的链表头指针
    print_list(lt); //打印链表

    lt=head_delete(lt);
    print_list(lt);
    return 0;
}

二.队列

1.顺序队列

#include <stdio.h>
#include <stdlib.h>
#define max 10
typedef struct{
    int data[max];
    int front,rear;
}sqqueue; // 顺序队列

void init(sqqueue* lt){
    lt->front=0;
    lt->rear=0;
}

int EnQueue(sqqueue* lt,int element){
    if(lt->rear == max) return 0; //对满
    lt->data[lt->rear++]=element;    //进队
    return 1;
}

int DeQueue(sqqueue*lt){
    if(lt->front == lt->rear) return 0; //对空
    int element =lt->data[lt->front++]; //保存队头元素,逻辑删除 头指针后移
    return  element;
}

int queueempty(sqqueue lt){
    if(lt.front == lt.rear){
        printf("当前队列为空!\n");
        return  0;
    }
    else{
        printf("当前队列非空!\n");
        return 1;
    }
}

int gethead(sqqueue lt){
    int element=lt.data[lt.front];
    return element;
}

void print_Queue(sqqueue lt){
    if(lt.front == lt.rear){
        printf("\t当前队列为空!\n");
        return ;
    }
    printf("当前队列中元素有:");
    int i=lt.front; // 不改变头指针
    while(i <lt.rear){      //当头指针与尾指针相同时
        printf("\t %d",lt.data[i++]);
    }
    printf("\n");
}
int main()
{
    sqqueue lt;
    init(&lt);  //初始化
    queueempty(lt);     //判空
    EnQueue(&lt,1);   //进队
    EnQueue(&lt,2);
    print_Queue(lt);    //打印队列
    int head=gethead(lt); //获取队头
    printf("队头:%d \n",head);
    DeQueue(&lt);
    print_Queue(lt);
    DeQueue(&lt);       //进队1 2 出队1 2，当前应当为空队列
    print_Queue(lt);
    return 0;
}

2.循环队列

#include <stdio.h>
#include <stdlib.h>
#define max 5
typedef struct{
    int data[max];
    int front,rear;
}sqqueue; // 循环队列
//这种写法:front指向对头元素，rear指向队尾元素下一个，如果一直进队 不出对直到队满，牺牲的单元为rear，在这个代码中 为下标4
void init(sqqueue* lt){    
    lt->front=0;
    lt->rear=0;
}

void print_queue(sqqueue lt){
    printf("\n");
    if(lt.front ==lt.rear){
        printf("\t当前循环队列为空!\n");
        return ;
    }
    printf("当前队列中元素有:");
    int i =lt.front;       //不改变头指针
    while((i)%max !=lt.rear){        //打印与进队区别,lt.front 不应该加一
        printf("\t %d",lt.data[i]);
        i =(i+1)%max;
    }
    printf("\n");
}

int queueempty(sqqueue lt){
    if(lt.front == lt.rear){
        printf("当前队列为空!\n");
        return  0;
    }
    else{
        printf("当前队列非空!\n");
        return 1;
    }
}

void gethead(sqqueue lt ,int *element){
    *element=lt.data[lt.front];
}

int getlength(sqqueue lt){  //队列长度
    printf("队列长度:%d\n",(lt.rear +max -lt.front)%max);
    return (lt.rear +max -lt.front)%max;
}
//--------printf方便我查看代码，实际可以将printf打印情况改成 return 0 1
void EnQueue(sqqueue* lt,int element){        //进队一个
    if((lt->rear +1)% max !=lt->front){      //这样会牺牲一个位置,如果不牺牲将判断混乱,空对与满对分不清
        lt->data[lt->rear] =element;
        lt->rear = (lt->rear +1 )%max; //更新rear 尾指针
    }
    else printf("\t队列已满\n");
}

void DeQueue(sqqueue* lt){            //出队一个
    if(lt->front !=lt->rear){       //不是空队列
      int element = lt->data[lt->front];      //出队元素
      lt->front =(lt->front+1) %max;
      printf("\t %d",element);
    }
    else printf("\n 队列为空对列，出队失败!");
}
int main()
{
    sqqueue lt;
    init(&lt);  //初始化
    queueempty(lt);     //判空

    printf("进队:");  //因为进队显示是靠最后打印，所以对满显示在进队前
    EnQueue(&lt,1);
    EnQueue(&lt,2);
    EnQueue(&lt,3);
    EnQueue(&lt,4); // max 5
    printf("\t 对头下标:%d  队尾下标:%d\n",lt.front,lt.rear);   // 0 4，这种写法front指向对头元素，rear指向队尾元素下一个,注实际对尾元素下标为lt.rear-1
    printf("\t 对头元素:%d  队尾元素:%d\n",lt.data[lt.front],lt.data[lt.rear]);// 1 垃圾值

    EnQueue(&lt,5); //正常应该只能储存4个,循环队列牺牲一个单元
    EnQueue(&lt,6);

    print_queue(lt);        //打印队列，输出的模拟显示进队的元素
    getlength(lt);
    printf("出队:");      //只是逻辑出队，物理并没有删除
    DeQueue(&lt);       //出队在函数里自己打印
    DeQueue(&lt);       //可以将出队不完全，将下面几个出队 注释，测试循环,下面还有第二次进队出队
    DeQueue(&lt);
//    DeQueue(&lt);
//    DeQueue(&lt);   //max 5
//    DeQueue(&lt);

    print_queue(lt);
//------
    printf("第二次进队出队:\n");
    EnQueue(&lt,11);
    EnQueue(&lt,21);
    print_queue(lt);
    printf("\t 对头下标:%d  队尾下标:%d\n",lt.front,lt.rear);   // 4 1，实际队尾元素下标lt.rear-1
    printf("\t 对头元素:%d  队尾元素:%d\n",lt.data[lt.front],lt.data[lt.rear]);// 11 2,因为删除只是逻辑删除2是第一次入队留在那的，实际队尾元素下标lt.rear-1 元素值21
    DeQueue(&lt);
    getlength(lt);  //进队两个出队一个 正常输出长度1
    EnQueue(&lt,31);
    print_queue(lt);
    DeQueue(&lt);
    print_queue(lt);    //进队 11 21 出队11 进队31，最后正常输出 21 31
    return 0;
}

3.链式存储的队列

1.带头节点

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct node{
    int data;
    struct node*next;
}node;

typedef struct{
    node *front,*rear;  //队列 头指针，尾指针
}LinkQueue;

/*
原来的初始化不行的原因是，lq 是一个局部变量，它在函数调用结束后就会被释放，所以你不能直接修改它的值。
如果你想修改一个指针的值，你需要传递它的地址，或者返回它的值。

错误的初始化是 main函数不分配内存,这样主函数的lq (就是一个未初始化的指针，它可能指向一个随机的地址，
也可能指向 NULL。这个地址可能是有效的，也可能是无效的，也可能是垃圾的),init函数分配内存不返回
*/

//LinkQueue* init(LinkQueue* lq){                  //必须使用linkqueue*,因为定义的类型不是指针，而init返回的是个指针
//    lq =(LinkQueue *)malloc(sizeof(LinkQueue));   //创建头节点
//    lq->front =lq->rear =(node *)malloc(sizeof(node)); //头指针尾指针 指向头节点
//    lq->front->next=NULL;
//    return lq;
//}
//
//int main(){
//    LinkQueue* lq;
//    lq = init(lq);
//}

void init(LinkQueue* lq){
    lq->front =lq->rear =(node *)malloc(sizeof(node)); //头指针尾指针 指向头节点
    lq->front->next=NULL;
}

void EnQueue(LinkQueue *lq,int element){
    node *temp =(node*)malloc(sizeof(node));
    temp->next =NULL;
    temp->data =element;
    lq->rear->next =temp;   //进队
    lq->rear = temp;        //更新尾指针
}

int DeQueue(LinkQueue *lq){
    if(lq->front == lq->rear){
        printf("\t当前队列为空!\n");
        return 0;
    }
    else{
        node *temp =lq->front->next;    //保存当前对头节点
        int element=temp->data;         //保存对头节点值
        lq->front->next = temp->next;    //更新头指针,如果仅一个元素 那么头指针指向的是NULL
        if(temp ==lq->rear){                //如果就一个元素情况
            lq->rear = lq->front;         //更新尾指针,相当于都置空 NULL
        }
        free(temp);
        printf("\t出队:%d",element);
        return element;
    }
}

int Queueempty(LinkQueue *lq){
    if(lq->front ==lq->rear){
        return 0;   //空队
    }
    else
        return 1;
}
void print_lq(LinkQueue* lq){
    if(lq->front == lq->rear){      //空队列
        printf("当前链队为空! \n");
        return ;
    }
    node*temp =lq->front->next;   //不改变头指针
    printf("链队中元素有:");
    while(temp!=NULL){
        printf("\t %d",temp->data);
        temp =temp->next;
    }
    printf("\n");
}

int main()
{
    LinkQueue* lq = (LinkQueue *)malloc(sizeof(LinkQueue)); //给 lq 分配内存空间,如果这样写
    init(lq);
    EnQueue(lq,1);
    EnQueue(lq,2);
    EnQueue(lq,3);
    print_lq(lq);   //打印 1 2 3
    DeQueue(lq);
    DeQueue(lq);

    printf("\n");
    print_lq(lq);   //打印 3
    DeQueue(lq);    //出队后 为空队
    DeQueue(lq);
    print_lq(lq);
    free(lq);
    return 0;
}

2.不带头节点

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct node{
    int data;
    struct node*next;
}node;

typedef struct{
    node *front,*rear;  //队列 头指针，尾指针
}LinkQueue;

/*
带头节点和不带头节点实现起来的理论和代码的区别主要有以下几点：
    1.带头节点的队列不需要判断队列是否为空，因为头指针和尾指针总是指向一个有效的节点。
    2.带头节点的队列入队时不需要判断是否是第一个元素，因为总是在尾指针后面插入新节点。
    3.带头节点的队列出队时不需要判断是否是最后一个元素，因为总是删除头指针后面的第一个节点。
    4.带头节点的队列需要额外分配一个头节点的内存空间，而不带头节点的队列不需要。
*/
void init(LinkQueue* lq){
    lq->front=NULL;
    lq->rear=NULL;
}

void EnQueue(LinkQueue *lq,int element){
    node *temp =(node*)malloc(sizeof(node));
    temp->next =NULL;
    temp->data =element;

    if(lq->rear ==NULL){    //队空的情况
        lq->front =temp;
        lq->rear =temp;
    }
    else{
        lq->rear->next =temp;   //进队
        lq->rear = temp;        //更新尾指针
    }

}

int DeQueue(LinkQueue *lq){
    if(lq->front == NULL){
        printf("\t当前队列为空!\n");
        return 0;
    }
    else{
        node *temp =lq->front;    //保存当前对头节点
        int element=temp->data;         //保存对头节点值
        lq->front = temp->next;    //更新头指针,如果仅一个元素 那么头指针指向的是NULL
        if(NULL ==lq->front){       //如果就一个元素情况
            lq->rear = NULL;         //更新尾指针,置空
        }
        free(temp);
        printf("\t出队:%d",element);
        return element;
    }
}

int Queueempty(LinkQueue *lq){
    if(lq->front ==lq->rear){
        return 1;   //空队
    }
    else
        return 0;
}
void print_lq(LinkQueue* lq){
    if(lq->front == NULL){      //空队列
        printf("当前链队为空! \n");
        return ;
    }
    node*temp =lq->front;   //不改变头指针
    printf("链队中元素有:");
    while(temp!=NULL){
        printf("\t %d",temp->data);
        temp =temp->next;
    }
    printf("\n");
}

int main()
{
    LinkQueue* lq = (LinkQueue *)malloc(sizeof(LinkQueue)); //给 lq 分配内存空间
    init(lq);

    EnQueue(lq,1);
    EnQueue(lq,2);
    EnQueue(lq,3);
    print_lq(lq);   //打印 1 2 3
    DeQueue(lq);
    DeQueue(lq);

    printf("\n");
    print_lq(lq);   //打印 3
    DeQueue(lq);    //出队后 为空队
    DeQueue(lq);
    print_lq(lq);
    free(lq);
    return 0;
}

课后习题

3.3栈实现递归函数的非递归计算

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

#define maxsize 10
typedef struct{
    int data;           //表明第几个元素
    double va;        //保存p(x)的值
}sqtack[maxsize];

int test(int n,double x){  //n表示算f(n), x表示第二位元素 2*x
    sqtack s;
    int top=-1,i;               //栈 下标0开始存储实际元素
    double fv1=1,fv2=2*x;      //第0项 1 第1项 2*x
    for(i=n;i>=2;i--){
        s[++top].data=i;        //用于表示n-1，计算是第几个元素
    }
    while(top>=0){
        s[top].va=2*x*fv2 -2*(s[top].data-1)*fv1;
        fv1=fv2;
        fv2=s[top--].va;    //top-- 出栈
    }
    if(n==0){
        printf("\t 第一种:%f\n",fv1);
        return fv1;
    }
    else{
        printf("\t 第二种:%f\n",fv2);
        return fv2;
    }
}
int main()
{
    test(2,2);
    return 0;
}