Day13-栈的实现(Java/C/链栈和顺序栈)

栈

概念简述

**栈(stack)：**是限定仅在表尾进行插入和删除操作的线性表。
**属性：**我们把允许插入和删除的一端称为栈顶(top)另一端称为底(bottom)不含任何数据元素的栈称为空栈。栈又称为后进先出(LastInFirstOut)的线性表简称LIFO结构。

栈的抽象数据类型

链栈的实现

• Java实现链栈

public class LinkedListStack<E> implements Stack<E>, Iterable {
    //1.创建内部节点类
    private static class Node<E>{
        E value;
        Node<E> next;
        public Node(E value, Node<E> next) {
            this.value = value;
            this.next = next;
        }
    }
    //2.创建栈中相关的属性
    private Node<E> head = new Node<>(null, null);//头指针
    private int size;//栈的大小
    private int capacity;//栈的容量
    public LinkedListStack(int capacity) {
        this.capacity = capacity;
    }

    /*向栈顶压入元素*/
    @Override
    public boolean push(E value) {
        //1.判断栈中是否为满
        if (isFull()) return false;
        //2.头插法
        head.next = new Node<>(value, head.next);
        //3.栈的大小+1
        size++;
        return true;
    }

    @Override
    public E pop() {
        //1.判断栈中是否为空
        if (isEmpty()) return null;
        E value = head.next.value;
        //2.删除栈顶元素
        head.next = head.next.next;
        size--;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) return null;
        return head.next.value;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == capacity;
    }

    @Override
    public Iterator iterator() {
        return new Iterator() {
            Node<E> p = head.next;
            @Override
            public boolean hasNext() {
                return p != null;
            }

            @Override
            public Object next() {
                E value = p.value;
                p = p.next;
                return value;
            }
        };
    }
}

• C语言实现链栈

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

// 创建节点结构体
typedef struct Node {
    void* value;
    struct Node* next;
} Node;

// 创建栈结构体
typedef struct {
    Node* head;
    int size;
    int capacity;
} LinkedListStack;


LinkedListStack* createLinkedListStack(int capacity) {
    LinkedListStack* stack = (LinkedListStack*)malloc(sizeof(LinkedListStack));
    stack->head = NULL;
    stack->size = 0;
    stack->capacity = capacity;
    return stack;
}

int isFull(LinkedListStack* stack) {
    return stack->size == stack->capacity;
}

int isEmpty(LinkedListStack* stack) {
    return stack->size == 0;
}

int push(LinkedListStack* stack, void* value) {
    if (isFull(stack)) return 0;

    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = value;
    newNode->next = stack->head;
    stack->head = newNode;

    stack->size++;
    return 1;
}

void* pop(LinkedListStack* stack) {
    if (isEmpty(stack)) return NULL;

    void* value = stack->head->value;
    Node* temp = stack->head;
    stack->head = stack->head->next;
    free(temp);

    stack->size--;
    return value;
}

void* peek(LinkedListStack* stack) {
    if (isEmpty(stack)) return NULL;

    return stack->head->value;
}

void freeLinkedListStack(LinkedListStack* stack) {
    Node* current = stack->head;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
    free(stack);
}

int main() {
    LinkedListStack* stack = createLinkedListStack(5);
    
    int value1 = 10;
    int value2 = 20;
    int value3 = 30;

    push(stack, &value1);
    push(stack, &value2);
    push(stack, &value3);

    printf("Stack size: %d\n", stack->size);

    int* top = (int*)peek(stack);
    if (top != NULL) {
        printf("Stack top value: %d\n", *top);
    }

    int* poppedValue = (int*)pop(stack);
    if (poppedValue != NULL) {
        printf("Popped value: %d\n", *poppedValue);
    }

    freeLinkedListStack(stack);

    return 0;
}

顺序栈的实现

• Java语言实现

public class ArrayListStack<E> implements Stack<E> {
    //1.创建栈的基本属性
    private E array[];//定义一个数组
    private int top;//定义一个头指针
    @SuppressWarnings("all")
    public ArrayListStack(int capacity) {
        this.array = (E[]) new Object[capacity];
    }

    /*入栈*/
    @Override
    public boolean push(E value) {
        //1.如果栈为满，返回false
        if (isFull()) return false;
        //2.将值入栈,并且将top + 1
        array[top++] = value;
        return true;
    }
    /*出栈*/
    @Override
    public E pop() {
        //1.如果栈为空，返回null
        if (isEmpty()) return null;
        //2.将值删除，并返回删除的值
        return array[--top];
    }
    /*返回栈顶元素*/
    @Override
    public E peek() {
        //1.如果栈为空，返回null
        if (isEmpty()) return null;
        //2.将值删除，并返回删除的值
        return array[top - 1];
    }
    /*判断栈是否为空*/
    @Override
    public boolean isEmpty() {
        return top == 0;
    }
    /*判断栈是否为满*/
    @Override
    public boolean isFull() {
        return top == array.length;
    }
}

• C语言实现

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

/*创建一个栈*/
typedef struct Stack{
	int *array;//创建一个数组 
	int top;//创建一个栈顶指针 
	int capacity;
}Stack; 

/*函数方法的声明—————————————*/
Stack* initStack(int capacity);
bool isFull(Stack *stack);
bool isEmpty(Stack *stack);
bool push(int value, Stack *stack);
int poll(Stack *stack);
int peek(Stack *stack);
/*————————————————————*/
int main(){
	Stack *stack = initStack(3);
	push(1, stack);
	push(2, stack);
	push(3, stack);
	printf("%d\n", peek(stack));
} 

/*栈的初始化*/
Stack* initStack(int capacity){
	Stack* stack = (Stack *)malloc(sizeof(Stack));//创建一个栈 
	stack->array = (int *)malloc(sizeof(int) * capacity);
	stack->capacity = capacity;
	stack->top = 0;//设置栈顶为0索引 
	return stack; 
}

/*判断栈是否为空*/
bool isEmpty(Stack *stack){
	return stack->top == 0;
} 

/*判断栈是否为满*/
bool isFull(Stack *stack){
	return stack->top == stack->capacity;
} 

/*入栈*/
bool push(int value, Stack *stack){
	if(isFull(stack)) return false;
	stack->array[stack->top++] = value;
	return true;
}

/*出栈*/
int poll(Stack *stack){
	if(isEmpty(stack)) return -1;
	return stack->array[--stack->top];
}

/*返回栈顶元素*/
int peek(Stack *stack){
	if(isEmpty(stack)) return -1;
	return stack->array[stack->top - 1];
}