数据结构(c语言版) 栈

顺序栈

要求：实现顺序栈的入栈，出栈，显示栈

代码

#include 
#define MAXSIZE 100

struct liststack{
    int data[MAXSIZE];
    int top;
};

//初始化栈
void init(struct liststack * LS){
    LS->top = -1;
}

//入栈操作
void instack(struct liststack * LS, int value){
    //判断是否栈满
    if(LS->top == (MAXSIZE-1)){
        printf("入栈失败：栈满！\n");
        return;
    }
    //入栈
    LS->top ++;
    LS->data[LS->top] = value;
    printf("数据 %d 入栈成功，在第 %d 位\n", value, LS->top+1);
}

//出栈操作
void outstack(struct liststack * LS){
    //判断是否栈空
    if(LS->top == -1){
        printf("出栈失败：栈空！\n");
        return;
    }
    //出栈
    printf("第 %d 位数据为 %d 出栈成功！\n",LS->top+1 , LS->data[LS->top]);
    LS->top --;
}

//显示栈的数据
void isstack(struct liststack * LS){
    //判断是否栈空
    if(LS->top == -1){
        printf("显示栈失败：栈空！\n");
        return;
    }
    int index = LS->top;
    while(index != -1){
        printf("第 %d 位数据是 %d \n",index + 1, LS->data[index]);
        index --;
    }
}

//判断栈
int emptystack(struct liststack * LS){
    if(LS->top == -1){
        printf("栈为空栈\n");
        return 1;
    }

    if(LS->top == (MAXSIZE-1)){
        printf("栈为满栈\n");
        return 0;
    }

    printf("既不是空栈，也不是满栈\n");
    return 2;

}


int main(){
    struct liststack LS;
    init(&LS);

    printf("****************入栈操作****************\n");
    int value;
    printf("请输入入栈的数据（输入0则结束）：");
    scanf("%d", &value);
    while (value != 0){
        instack(&LS, value);
        printf("请输入入栈的数据（输入0则结束）：");
        scanf("%d", &value);
    }

    printf("\n****************显示栈中数据****************\n");
    isstack(&LS);

    printf("\n****************出栈操作****************\n");
    int flag;
    printf("出栈请输入1，结束请输入0：");
    scanf("%d", &flag);
    while (1){
        if(flag == 1){
            outstack(&LS);
        }
        if(flag == 0){
            break;
        }
        printf("出栈请输入1，结束请输入0：");
        scanf("%d", &flag);
    }

    printf("\n****************显示栈中数据****************\n");
    isstack(&LS);

    printf("\n****************判断栈****************\n");
    emptystack(&LS);
}

运行结果

****************入栈操作****************
请输入入栈的数据（输入0则结束）：10
数据 10 入栈成功，在第 1 位
请输入入栈的数据（输入0则结束）：20
数据 20 入栈成功，在第 2 位
请输入入栈的数据（输入0则结束）：304
数据 304 入栈成功，在第 3 位
请输入入栈的数据（输入0则结束）：450
数据 450 入栈成功，在第 4 位
请输入入栈的数据（输入0则结束）：596
数据 596 入栈成功，在第 5 位
请输入入栈的数据（输入0则结束）：0

****************显示栈中数据****************
第 5 位数据是 596
第 4 位数据是 450
第 3 位数据是 304
第 2 位数据是 20
第 1 位数据是 10

****************出栈操作****************
出栈请输入1，结束请输入0：1
第 5 位数据为 596 出栈成功！
出栈请输入1，结束请输入0：1
第 4 位数据为 450 出栈成功！
出栈请输入1，结束请输入0：0

****************显示栈中数据****************
第 3 位数据是 304
第 2 位数据是 20
第 1 位数据是 10

****************判断栈****************
既不是空栈，也不是满栈

进程已结束，退出代码为 0

链栈

实现链栈的创建，入栈，出栈，显示栈

代码

#include 
#include 

struct linkstack{
    int data;
    struct linkstack * next;
};

//初始化栈
void init(struct linkstack * LS){
    LS->next = NULL;
}

//判断栈
int emptystack(struct linkstack * LS){
    if(LS->next == NULL){
        printf("栈为空栈\n");
        return 0;
    }
    printf("栈不是空栈\n");
    return 1;
}

//入栈  头插法
void instack(struct linkstack * LS, int value){
    if(LS == NULL){
        printf("栈不存在\n");
        return;
    }

    struct linkstack * NewNode = malloc(sizeof(struct linkstack));
    if(NewNode){
        NewNode->data = value;
        NewNode->next = LS->next;
        LS->next = NewNode;
        printf("数据 %d 入栈成功！\n", value);
    } else{
        printf("入栈失败！\n");
    }


};


//出栈
void outstack(struct linkstack * LS){
    if(LS->next == NULL){
        printf("出栈失败：栈为空！\n");
    }
    struct linkstack* temp = LS->next;
    LS->next = LS->next->next;
    printf("数据 %d 出栈成功！\n",temp->data);
    free(temp);
}

//显示栈
void isstack(struct linkstack * LS){
    if(LS->next == NULL){
        printf("显示栈失败：栈为空！\n");
    }
    int top = 1;
    struct linkstack* temp = LS->next;
    while(temp != NULL){
        printf("距栈顶第 %d 位的数据是 %d \n",top, temp->data);
        top ++;
        temp = temp->next;
    }
}

int main(){
    struct linkstack LS;
    init(&LS);

    printf("****************链栈入栈操作****************\n");
    int value;
    printf("请输入入栈的数据（输入0则结束）：");
    scanf("%d", &value);
    while (value != 0){
        instack(&LS, value);
        printf("请输入入栈的数据（输入0则结束）：");
        scanf("%d", &value);
    }


    printf("\n****************显示链栈中数据****************\n");
    isstack(&LS);

    printf("\n****************链栈出栈操作****************\n");
    int flag;
    printf("出栈请输入1，结束请输入0：");
    scanf("%d", &flag);
    while (1){
        if(flag == 1){
            outstack(&LS);
        }
        if(flag == 0){
            break;
        }
        printf("出栈请输入1，结束请输入0：");
        scanf("%d", &flag);
    }

    printf("\n****************显示链栈中数据****************\n");
    isstack(&LS);

    printf("\n****************判断链栈****************\n");
    emptystack(&LS);
}

运行结果

共享栈

要求：两栈共享技术

代码

#include 
#define MAXSIZE 100

//声明结构体
struct DListStack{
    int data[MAXSIZE];
    int top[2];
};

//初始化结构体
void init(struct DListStack* DLS){
    DLS->top[0] = -1;
    DLS->top[1] = MAXSIZE;
}

//入栈
void inDLStack(struct DListStack* DLS, int value, int i){
    //判断是否满栈
    if(DLS->top[0]+1 == DLS->top[1]){
        printf("入栈失败：栈满\n");
        return;
    }

    //判断在第几个栈 入栈
    if(i == 0){
        DLS->top[0]++;
        DLS->data[DLS->top[0]] = value;
        printf("数据 %d 在共享栈的第左栈中第 %d 位入栈成功\n",value, DLS->top[0]+1);
        return;
    }

    if(i == 1){
        DLS->top[1]--;
        DLS->data[DLS->top[1]] = value;
        printf("数据 %d 在共享栈的右栈中第 %d 位入栈成功\n",value, DLS->top[1]+1);
        return;
    }
    printf("入栈失败\n");
}

//出栈
void outDLStack(struct DListStack* DLS, int i){
    //判断是否满栈
    if(DLS->top[0] == -1 && DLS->top[1] == MAXSIZE){
        printf("出栈失败：两个栈都为空栈\n");
        return;
    }

    //判断在第几个栈 出栈
    if(i == 0){
        if(DLS->top[0] == -1){
            printf("出栈失败：左栈为空栈!\n");
            return;
        }
        printf("数据 %d 在共享栈的左栈中第 %d 位出栈成功\n",DLS->data[DLS->top[0]], DLS->top[0]+1);
        DLS->top[0]--;
        return;
    }

    if(i == 1){
        if(DLS->top[1] == -1){
            printf("出栈失败：右栈为空栈!\n");
            return;
        }
        printf("数据 %d 在共享栈的右栈中第 %d 位出栈成功\n",DLS->data[DLS->top[1]], DLS->top[1]+1);
        DLS->top[1]++;
        return;
    }
    printf("出栈失败\n");
}

//显示栈
void isDLStack(struct DListStack* DLS){
    //判断是否满栈
    if(DLS->top[0] == -1 && DLS->top[1] == MAXSIZE){
        printf("显示栈失败：两个栈都为空栈\n");
        return;
    }

    //显示第一个栈
    int index_0 = DLS->top[0];
    if(index_0 == -1){
        printf("显示栈失败：左栈为空栈!\n");
    }
    while (index_0 != -1){
        printf("数据 %d 在共享栈的左栈中第 %d 位出栈成功\n",DLS->data[index_0], index_0+1);
        index_0 --;
    }

    //显示第er个栈
    int index_1 = DLS->top[1];
    if(index_1 == MAXSIZE){
        printf("显示栈失败：右栈为空栈!\n");
    }
    while (index_1 != MAXSIZE){
        printf("数据 %d 在共享栈的右栈中第 %d 位出栈成功\n",DLS->data[index_1], index_1+1);
        index_1 ++;
    }

}

int main(){
    struct DListStack DLS;
    init(&DLS);

    printf("********************入栈操作***********************\n");
    int value,index;
    printf("请输入入栈的值和左（0）栈或者右（1）栈，输入2 2则结束：");
    scanf("%d %d",&value, &index);
    while (1){
        if(index == 0){
            inDLStack(&DLS, value, 0);
        }
        if(index == 1){
            inDLStack(&DLS, value, 1);
        }
        if(index == 2){
            break;
        }
        printf("请输入入栈的值和左（0）栈或者右（1）栈，输入2 2则结束：");
        scanf("%d %d",&value, &index);
    }

    printf("\n********************显示栈操作***********************\n");
    isDLStack(&DLS);

    printf("\n********************出栈操作***********************\n");
    int flag;
    printf("出左栈则输入0，出右栈则输入1，结束则输入2：");
    scanf("%d", &flag);
    while (1){
        if(flag == 0){
            outDLStack(&DLS, 0);
        }
        if(flag == 1){
            outDLStack(&DLS, 1);
        }
        if(flag == 2){
            break;
        }
        printf("出左栈则输入0，出右栈则输入1，结束则输入2：");
        scanf("%d", &flag);
    }

    printf("\n********************显示栈操作***********************\n");
    isDLStack(&DLS);

}

运行结果