数据结构与算法之栈

最新推荐文章于 2022-05-09 00:41:05 发布
最新推荐文章于 2022-05-09 00:41:05 发布
阅读量185 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 java 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pizicai007/article/details/105552643
版权

数据结构与算法之栈

1. 基本知识

1.1 概念

栈是一种操作受限的数据结构，只能在一端插入和删除数据，因此只支持入栈和出栈操作，后进先出是它的最大特点。栈可以通过数组实现，也可以通过链表来实现，其出栈和入栈的时间复杂度都是O(1)。

栈的结构

1.2 分类
  1. 顺序栈：数组实现
  2. 链式栈：链表实现
1.3 基本操作
  1. 入栈 push(T data)
  2. 出栈 pop()
  3. 获取栈顶数据 peek()
1.3 实现

只需要维护一个栈顶指针，通过数组实现的顺序栈和通过链表实现的链式栈。

1.3.1 顺序栈
package com.baidu.test.construct.stack;

/**
 * 顺序栈，后进先出
 */
public class ArrayStack<T> {

    // 默认容量
    private final static int DEFAULT_CAPACITY = 10;

    // 元素集合
    private Object[] datas;

    // 容量
    private int capacity;

    // 长度
    private int top;

    public ArrayStack() {
        this(DEFAULT_CAPACITY);
    }

    public ArrayStack(int capacity) {
        this.datas = new Object[capacity];
        this.capacity = capacity;
        this.top = 0;

    }

    /**
     * 入栈
     * @param data
     */
    public void push(T data) {
        ensureCapacity(top+1);
        datas[top++] = data;
    }

    /**
     * 出栈
     * @return
     */
    public T pop() {
        if (top == 0) {
            return null;
        }
        return (T) datas[--top];
    }

    /**
     * 获取栈顶元素
     * @return
     */
    public T getTop() {
        return (T) datas[top-1];
    }

    public int size() {
        return top;
    }

    public boolean empty() {
        return top == 0;
    }

    /**
     * 扩容
     * @param size
     */
    public void ensureCapacity(int size) {
        if (size > capacity) {
            System.out.println("容量不足，触发扩容...");
            capacity = capacity * 2;
            Object[] temp = new Object[capacity];
            System.arraycopy(datas, 0, temp, 0, top);
            datas = temp;
        }
    }

    public static void main(String[] args) {
        ArrayStack<Integer> stack = new ArrayStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        stack.push(8);
        System.out.println("获取栈顶：" + stack.getTop());
        stack.push(9);
        stack.push(10);
        stack.push(11);
        stack.push(12);
        System.out.println("顺序栈长度：" + stack.size());
        System.out.println("顺序栈是否为空：" + stack.empty());
        System.out.print("遍历出栈：");
        while (!stack.empty()) {
            System.out.print(stack.pop() + "，");
        }
    }
}
1.3.2 链式栈
package com.baidu.test.construct.stack;

/**
 * 链表栈
 */
public class LinkedListStack<T> {

    // 头节点
    private Node<T> head;

    // 当前结点
    private Node<T> current;

    // 长度
    private int size;

    public LinkedListStack() {
        this.head = this.current = new Node<T>(null, null);
        this.size = 0;
    }

    /**
     * 入栈，链表尾部入栈
     * @param data
     */
    public void push(T data) {
        index(size-1);
        current.next = new Node<T>(data, current.next);
        size++;
    }

    /**
     * 出栈，链表头部出栈
     * @return
     */
    public T pop() {
        current = head;
        Node<T> node = current.next;
        current.next = current.next.next;
        size--;
        return node.data;
    }

    /**
     * 获取栈顶位置
     * @return
     */
    public T getTop() {
        return head.next.data;
    }

    public int size() {
        return size;
    }

    public boolean empty() {
        return size == 0;
    }

    private void index(int index) {
        if (index < -1 || index > size -1) {
            throw new IndexOutOfBoundsException();
        }
        if (index == -1) {
        	current = head;
            return;
        }
        current = head.next;
        int i=0;
        while (i<index) {
            current = current.next;
            i++;
        }
    }

    private static class Node<T> {
        private T data;
        private Node<T> next;

        public Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
    }

    public static void main(String[] args) {
        LinkedListStack<Integer> stack = new LinkedListStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        stack.push(8);
        System.out.println("获取栈顶：" + stack.getTop());
        stack.push(9);
        stack.push(10);
        stack.push(11);
        stack.push(12);
        System.out.println("顺序栈长度：" + stack.size());
        System.out.println("顺序栈是否为空：" + stack.empty());
        System.out.print("遍历出栈：");
        while (!stack.empty()) {
            System.out.print(stack.pop() + "，");
        }
    }
}

2. 栈的应用

2.1 栈在括号匹配中的应用
package com.baidu.test.construct.stack;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class StackDemo {

    /**
     * 有效的括号：
     * 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
     * 有效字符串需满足：
     *      左括号必须用相同类型的右括号闭合。
     *      左括号必须以正确的顺序闭合。
     *
     * @param s
     * @return
     */
    private static boolean isValid(String s) {
        Stack<Character> stack = new Stack();
        Map<Character, Character> map = new HashMap<>();
        map.put(')', '(');
        map.put(']', '[');
        map.put('}', '{');
        int length = s.length();
        for (int i=0; i< length; i++) {
            char c = s.charAt(i);
            if (map.containsKey(c)) {
                Character pop = stack.isEmpty()? '$' : stack.pop();
                if (map.get(c) != pop) {
                    return false;
                }
            } else if (map.containsValue(c)) {
                stack.push(c);
            }
        }
        return stack.isEmpty();
    }

    public static void main(String[] args) {
        System.out.println(isValid("sfadfd[](sdfd){]"));
    }

}
2.2 最小栈的实现

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
  push(x) —— 将元素 x 推入栈中。
  pop() —— 删除栈顶的元素。
  top() —— 获取栈顶元素。
  getMin() —— 检索栈中的最小元素。

示例:
  MinStack minStack = new MinStack();
  minStack.push(-2);
  minStack.push(0);
  minStack.push(-3);
  minStack.getMin(); --> 返回 -3.
  minStack.pop();
  minStack.top(); --> 返回 0.
  minStack.getMin(); --> 返回 -2.

2.2.1 双栈实现
思路：
	1.将第一个元素入栈。
	2.新加入的元素如果大于栈顶元素，那么新加入的元素就不处理。
	3.新加入的元素如果小于等于栈顶元素，那么就将新元素入栈。
	4.出栈元素不等于栈顶元素，不操作。
	5.出栈元素等于栈顶元素，那么就将栈顶元素出栈。

图解：
	入栈 3 
	|   |    |   |
	|   |    |   |
	|_3_|    |_3_|
	stack  minStack
	
	入栈 5 ， 5 大于 minStack 栈顶，不处理
	|   |    |   |
	| 5 |    |   |
	|_3_|    |_3_|
	stack  minStack
	
	入栈 2 ，此时右边的 minStack 栈顶就保存了当前最小值 2 
	| 2 |    |   |
	| 5 |    | 2 |
	|_3_|    |_3_|
	stack  minStack
	
	出栈 2，此时右边的 minStack 栈顶就保存了当前最小值 3
	|   |    |   |
	| 5 |    |   |
	|_3_|    |_3_|
	stack  minStack
	
	出栈 5，右边 minStack 不处理
	|   |    |   |
	|   |    |   |
	|_3_|    |_3_|
	stack  minStack
	
	出栈 3
	|   |    |   |
	|   |    |   |
	|_ _|    |_ _|
	stack  minStack


package com.baidu.test.construct.stack;

import java.util.Stack;

/**
 * 最小栈
 * 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
 *
 * push(x) —— 将元素 x 推入栈中。
 * pop() —— 删除栈顶的元素。
 * top() —— 获取栈顶元素。
 * getMin() —— 检索栈中的最小元素
 *
 */
public class MinStackByTwoStack {

    private Stack<Integer> stack;
    private Stack<Integer> minStack;

    public MinStackByTwoStack() {
        stack = new Stack();
        minStack = new Stack();
    }

    public void push(int x) {
        stack.push(x);
        if (minStack.isEmpty()) { // 第一个元素最小
            minStack.push(x);
        } else {
            int pop = minStack.peek(); // 取出最小栈栈顶数据
            if (x <= pop) { // 当前数据小于等于最小栈栈顶数据，则将该数据压入最小栈栈顶
                minStack.push(x);
            }
        }
    }

    public void pop() {
        int pop = stack.pop();
        int peek = minStack.peek();
        if (pop == peek) { // 栈顶数据等于最小栈栈顶数据时，最小栈出栈
            minStack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }


    public int getMin() {
        return minStack.peek();
    }

    public static void main(String[] args) {
        MinStackByTwoStack stack = new MinStackByTwoStack();
        stack.push(2);
        stack.push(3);
        stack.push(10);
        stack.push(7);
        stack.push(8);
        stack.push(1);
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
        System.out.println("执行一次出栈操作");
        stack.pop();
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
        System.out.println("执行一次出栈操作");
        stack.pop();
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
    }

}
2.2.1 单栈实现
思路：
	1.只需要一个栈了。
	2.当有更小的值来的时候，我们只需要把之前的最小值入栈，当前更小的值再入栈即可。
	3.当这个最小值要出栈的时候，下一个值便是之前的最小值了。

图解：
	入栈 3 
	|   |   min = 3
	|   |     
	|_3_|    
	stack   
	
	入栈 5 
	|   |   min = 3
	| 5 |     
	|_3_|    
	stack  
	
	入栈 2 
	| 2 |   min = 2?
	| 5 |     
	|_3_|    
	stack  

	如果只用一个变量就会遇到一个问题，如果把 min 更新为 2，那么之前的最小值 3 就丢失了。怎么把 3 保存起来呢？把它在 2 之前压入栈中即可。
	
	入栈 2 ，同时将之前的 min 值 3 入栈，再把 2 入栈，同时更新 min = 2
	| 2 |   min = 2
	| 3 |  
	| 5 |     
	|_3_|    
	stack  
	
	入栈 6 
	| 6 |  min = 2
	| 2 |   
	| 3 |  
	| 5 |     
	|_3_|    
	stack  
	
	出栈 6     
	| 2 |   min = 2
	| 3 |  
	| 5 |     
	|_3_|    
	stack  
	
	出栈 2     
	| 2 |   min = 2
	| 3 |  
	| 5 |     
	|_3_|    
	stack  

package com.baidu.test.construct.stack;

import java.util.Stack;

public class MinStackWithOneStack {

    private Stack<Integer> stack;
    private int min;

    public MinStackWithOneStack() {
        this.stack = new Stack<>();
        min = Integer.MAX_VALUE;
    }

    public void push(int x) {
        if (x <= min) { // 如果当前数据小于等于最小值，则把当前最小值先于当前数组压入
            stack.push(min);
            min = x;
        }
        stack.push(x);
    }

    public void pop() {
        if (stack.pop() == min) { // 如果弹出栈顶位置等于最小值，则再一次弹出数据设为最小值
            min = stack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return min;
    }

    public static void main(String[] args) {
        MinStackWithOneStack stack = new MinStackWithOneStack();
        stack.push(2);
        stack.push(3);
        stack.push(10);
        stack.push(7);
        stack.push(8);
        stack.push(1);
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
        System.out.println("执行一次出栈操作");
        stack.pop();
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
        System.out.println("执行一次出栈操作");
        stack.pop();
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
    }
}
2.2.3 基于链表实现
思路：
	在 Node 节点中增加一个 min 字段，这样的话每次加入一个节点的时候，我们同时只要确定它的 min 值即可。

package com.baidu.test.construct.stack;

public class MinStack {

    private Node head;

    public MinStack() {
        this.head = new Node(null, null, null);
    }

    public void push(int x) {
        if (head.next == null) {
            head.next = new Node(x, head.next, x);
        } else {
            head.next = new Node(x, head.next, Math.min(head.next.min, x));
        }
    }

    public void pop() {
        if (head.next != null) {
            head.next = head.next.next;
        }
    }

    public int top() {
        return head.next.data;
    }

    public int getMin() {
        return head.next.min;
    }

    private static class Node {
        private Integer data;
        private Node next;
        private Integer min; // 最小值

        public Node(Integer data, Node next, Integer min) {
            this.data = data;
            this.next = next;
            this.min = min;
        }
    }

    public static void main(String[] args) {
        MinStack stack = new MinStack();
        stack.push(2);
        stack.push(3);
        stack.push(10);
        stack.push(7);
        stack.push(8);
        stack.push(1);
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
        System.out.println("执行一次出栈操作");
        stack.pop();
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
        System.out.println("执行一次出栈操作");
        stack.pop();
        System.out.println("栈顶数据为：" + stack.top());
        System.out.println("最小栈数据为：" + stack.getMin());
    }
}
2.3 实现简单计算器
思路：
	1.利用两个栈实现，一个栈保存原始字符，一个栈保存括号中的元素，
	2.括号中的数据计算完毕压入原始栈，
	3.遍历原始栈得到最终结果

	该问题因为有括号，因此比较复杂，如果没有括号的话，就可以简单：
	1.两个栈，一个数据栈，一个操作符栈。

package com.baidu.test.construct.stack;

import java.util.Stack;

/**
 * 实现一个基本的计算器来计算一个简单的字符串表达式的值。
 *
 * 字符串表达式可以包含左括号 ( ，右括号 )，加号 + ，减号 -，非负整数和空格
 */
public class Calculator {

    public static int calculate(String s) {
        if (s == null && s.length() == 0) {
            throw new RuntimeException("非法数据");
        }
        Stack<String> stack = new Stack<>();
        int length = s.length();
        for(int i=0; i<length; i++) {
            char c = s.charAt(i);
            if (c == ' ') {
                continue;
            }
            if (')' != c) {
                stack.push(c+"");
            } else {
                calculate(stack);
            }
        }

        calculate(stack);
        return Integer.parseInt(stack.pop());
    }

    private static void calculate(Stack<String> stack) {
        int sum = 0;
        Stack<String> tempStack = new Stack<>();
        while (!stack.isEmpty()) {
            String pop = stack.pop();
            if ("(".equals(pop)) {
                break;
            }
            tempStack.push(pop);
        }

        int x = Integer.parseInt(tempStack.pop());
        while (!tempStack.isEmpty()) {
            String p  = tempStack.pop();
            int y  = Integer.parseInt(tempStack.pop());
            sum = calculate(x, p , y);
            x = sum;
        }
        stack.push(sum + "");
    }

    private static int calculate(int x, String p, int y) {
        switch (p) {
            case "+":
                return x + y;
            case "-":
                return x - y;
            default:
                return 0;
        }
    }

    public static void main(String[] args) {
        System.out.println(calculate("(1+(4+5+2)-3)+(6+8)"));
    }
}
坯子蔡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法-栈
weixin_44091205的博客
06-29 141
title: 数据结构与算法-栈 date: 2020-06-10 16:20:09 tags: - 数据结构与算法 1，JS的数组结构，可以直接调用API（编程题考察的一般都是数组，所以JS基础最重要，数组的操作需要进行十分熟练） 数组的插入和删除是比较麻烦，原因是需要不断的移动数据。但是，数组通过下标查询以及修改元素的时候，效率是很高的。 除了数组，其他的结构都是自己构造出来的，一般是利用对象加指针进行实现。（比如树就是递归出来的） 2，栈结构（是要自己实现的？） 因为栈的特点是先进后出，且进出都在一.
数据结构与算法——栈
skyshine94的博客
09-25 675
目录 一、栈 1.1 基本介绍 1.2数组模拟栈 1.3链表模拟栈 二、栈的三种表达式 2.1前缀表达式（波兰表达式 Polish Notation） 2.2 中缀表达式 2.3 后缀表达式（逆波兰表达式 Reverse Polish Notation） 2.4 逆波兰表达式求值 2.5 中缀表达式转后缀表达式 一、栈 1.1 基本介绍 栈（stack）是一种先入后出的有序列表。 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端...
数据结构与算法（栈）
mysterious_z的博客
12-01 429
引言：在上次复习了线性表的基本操作后，现在我们将目光转移到下一数据结构中来。至此，正式开始数据结构——栈的学习 栈1.栈的定义2.栈的表达方式 1.栈的定义 定义：栈是仅在一端进行插入和删除的线性表 2.栈的表达方式 同线性表一样，栈的表达方式也分为顺序与链式两种 ...
JS数据结构与算法.pdf
最新发布
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
恋上数据结构与算法课件.rar
11-23
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。本课程的资源"恋上数据结构与算法课件.rar"涵盖了多个核心概念，旨在...爱数据结构与算法，就立即行动，打开这个压缩包，开始你的学习之旅吧！
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
数据结构与算法---栈
HZS8520223520的博客
11-04 725
栈 基本概念 栈是一种逻辑结构，是特殊的线性表。特殊在： 只能在固定的一端操作 只要满足上述条件，那么这种特殊的线性表就会呈现一种“后进先出”的逻辑，这种逻辑就被称为栈。 由于约定了只能在线性表固定的一端进行操作，于是给栈这种特殊的线性表的插入删除，起个特殊的名称： 栈顶(top of stack)：可以进行插入删除的一端 栈底：栈顶的对立端 入栈：将节点插入栈顶之上，也称为压栈，函数名通常为push() 出栈：将节点从栈顶剔除，也称为弹栈，函数名通常为pop() 取栈顶：取得栈顶元素，但不出栈，函数
数据结构与算法—栈
weixin_49757069的博客
05-09 409
栈：是一种遵循先进后出(LIFO)原则的有序集合。新添加或待删除的元素都保存在栈的同一端，称作栈顶，另一端就叫栈底 1.创建一个基于数组的栈 push: 添加一个（或几个）新元素到栈顶 pop：移除栈顶的元素，同时返回被移除的元素 peek：返回栈顶的元素，不对栈做任何修改 isEmpty: 如果栈里没有任何元素就返回true， 否则返回false size: 返回栈里的元素个数 clear: 移除栈里的所有元素 两种方式： function Stack() { this.items = []
go语言实现顺序栈
u012967763的专栏
10-18 228
package main import "fmt" type Stack struct { element []int } //创建一个新栈 func NewStack()*Stack{ return &Stack{} } //判断栈是否为空 func (s *Stack)IsEmpty()bool{ if len(s.element) == 0 { return tr...
数据结构与算法 | 栈
凌桓丶的博客
02-15 584
栈 栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端为栈顶，另一端为栈底。栈中元素遵循先进后出的原则 假设我们依次将1， 2， 3， 4压入栈中 当我们再全部出栈时，就从1，2，3，4变成了4，3，2，1 这就是栈的先进后出的规则，知晓了原理，下一步就开始实现。 这里我们结合栈的特性，选用顺序表来实现更优一些，而下期的队列则用链表实现 数据结构 ...
【数据结构与算法】：栈
Baridhu的博客
02-15 1972
本文主要争对对栈的运用、基础理解和代码实现，其中对逆波兰表达式等进行了分析、讲解。
数据结构-栈(C语言代码)
weixin_50246370的博客
08-12 5486
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct.
数据结构与算法之栈篇
汤姆鱼
11-17 1205
1、如何理解“栈”？ 栈是一种典型“后进者先出，先进者后出”的结构。从栈的操作特性上来看，栈是一种“操作受限”的线性表，只允许在一端插入和删除数据。 2、如何让实现一个“栈”？ 对于栈，主要包含两个操作，入栈和出栈，也就是在栈顶插入一个数据和从栈顶删除一个数据，实际上栈既可以用数组来实现，也可以用链表来实现。用数组实现的栈我们叫做顺序栈，用链表实现的栈，我们叫作链式栈。 举...
数据结构与算法--栈（Stack）
weixin_42028840的博客
07-14 361
    "数据结构与算法"不管是在Java还是在任何语言中都是核心基础知识，就像是盖楼的地基一样，它被广泛的应用于架构的最底层，对于这部分知识的掌握程度能够决定读者以后的高度。    出于这个初衷开更本系列文章，希望能对读者有所帮助。读者的收获1、了解栈的结构2、栈的特性3、栈的实现方式4、栈的日常应用1栈的结构    ”栈“是一种“操作受限”的数据结构，栈的顶端叫做“栈顶”，栈的底端叫做“栈底”，对于数据的插入操作叫做“入栈”，剔除数据
数据结构与算法 -- 栈 -- 顺序栈&&链栈
Jancoyan
03-28 193
栈 本文为作者学习b站上交版<<数据结构与算法>>, 结合清华大学出版社<<数据结构(C语言版)>> 的学习笔记, 部分内容来自于视频中的的PPT 目录栈栈的定义堆栈的表示和实现栈的表示顺序栈操作初始化销毁判断是否为空长度获得栈顶元素入栈出栈遍历输出链栈操作初始化判断是否为空入栈弹出栈销毁长度获得栈顶元素遍历输出 栈的定义 栈 : 一个只能在栈顶...
数据结构与算法：栈、队列和数组详解
本资源是一份关于数据结构与算法的PPT课件，专注于第四章的内容，主要讲解栈、队列和数组这三个核心主题。栈（Stack）是一种特殊的线性表，其特点是只允许在一端进行插入和删除操作，遵循“后进先出”（LIFO）原则。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值