数据结构笔记--栈与队列，堆

最新推荐文章于 2022-03-14 19:53:10 发布
最新推荐文章于 2022-03-14 19:53:10 发布
阅读量191 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guozhengdong/article/details/107920552
版权

基本定义：

先进后出为栈；先进先出为队列

栈的构造

#include<stdio.h>
#include<stack>

int main()
{

    std::stack<int> S;
    if(S.empty()) //判断栈是否为空
    {
        printf("S is empty!\n");
    }
    S.push(1);//压栈
    S.push(6);
    S.push(10);
    printf("S.top:%d\n",S.top());//打印栈顶
    S.pop();//出栈
    S.pop();
    printf("S.top: %d\n",S.top());
    printf("S.size:%d\n",S.size());
    return 0;
}

其中：

S.top()：取出栈顶

S.empty()：判断栈是否为空

S.push(x)：将x添加至栈

S.pop()·弹出栈顶

S.size()栈的存储元素个数

队列的定义：

#include<stdio.h>
#include<queue>

int main()
{
    std::queue<int> Q;
    if(Q.empty())
    {
        printf("Q is empty!\n");
    }
    Q.push(1);//入队列
    Q.push(6);
    Q.push(10);
    printf("Q.front:%d \n",Q.front());
    Q.pop();
    Q.pop();
    printf("Q.front%d \n",Q.front());
    printf("Q.size:%d\n",Q.size());
    return 0;

}

其中：

Q.empty():判断队列是否为空

Q.front():返回队列头部元素

Q.back():返回队列尾部元素

Q.pop()：出队列头部元素

Q.push(x)：将×添加至队列

Q.size()：返回队列的存储元素的个数

 

225.用队列实现栈：

使用队列实现栈的下列操作：

push(x) -- 元素 x 入栈

pop() -- 移除栈顶元素

top() -- 获取栈顶元素

empty() -- 返回栈是否为空

注意:

你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。

你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

算法思路：

设置临时队列，进行压入队列的位置调换；

class MyStack {
public:
    /** Initialize your data structure here. */
    MyStack() {

    }
    
    /** Push element x onto stack. */
    void push(int x) {
        std::queue<int> temp_queue;
        temp_queue.push(x);
        while(!Q.empty())
        {
            temp_queue.push(Q.front());
            Q.pop();
        }
        while(!temp_queue.empty())
        {
            Q.push(temp_queue.front());
            temp_queue.pop();
        }

    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int x=Q.front();
        Q.pop();
        return x;
    }
    
    /** Get the top element. */
    int top() {
        return Q.front();
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return Q.empty();
    }
    private:
    std::queue<int> Q;
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

232：使用栈表示队列：

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。

pop() -- 从队列首部移除元素。

peek() -- 返回队列首部的元素。

empty() -- 返回队列是否为空。

示例:

MyQueue queue = new MyQueue();

queue.push(1);

queue.push(2);

queue.peek(); // 返回 1

queue.pop(); // 返回 1

queue.empty(); // 返回 false

说明:

你只能使用标准的栈操作 -- 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。

你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）。

 

解法：

方法一：设置临时栈来实现顺序的调换

class MyQueue {
public:
    /** Initialize your data structure here. */
    MyQueue() {

    }
    
    /** Push element x to the back of queue. */
    void push(int x) {
        std::stack<int> temp_stack;
        while(!S.empty())
        {
            temp_stack.push(S.top());
            S.pop();
        }
        temp_stack.push(x);
        while(!temp_stack.empty())
        {
            S.push(temp_stack.top());
            temp_stack.pop();
        }

    }
    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        int x=S.top();
        S.pop();
        return x;
    }
    
    /** Get the front element. */
    int peek() {
        return S.top();
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        return S.empty();    
    }
private:
    std::stack<int> S;
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();

方法二：双栈法：新建一个栈，用来pop操作

待完成

155.最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

push(x) —— 将元素 x 推入栈中。

pop() —— 删除栈顶的元素。

top() —— 获取栈顶元素。

getMin() —— 检索栈中的最小元素。

示例:

输入：

["MinStack","push","push","push","getMin","pop","top","getMin"]

[[],[-2],[0],[-3],[],[],[],[]]

输出：

[null,null,null,null,-3,null,0,-2]

解释：

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

解法：

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {}
    
    void push(int x) {
        SS.push(x);
        if(min_SS.empty())
        {
            min_SS.push(x);
        }
        else
        {
            if(x>min_SS.top())
            {
                x=min_SS.top();
            }
           min_SS.push(x);
        }
    }
    
    void pop() {
        SS.pop();
        min_SS.pop();        
    }
    
    int top() {
        return SS.top();
    }
    
    int getMin() {
        return min_SS.top();
    }
private:
    std::stack<int> SS;
    std::stack<int> min_SS;
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

1363(Poj) 合法的出栈序列

已 知 从 1 至 n 的 数字序列，按顺序入栈，每个数字入栈后即可出栈，也 可 在 栈 中 停 留 ， 等 待 后 面 的 数 字 入 栈 出 栈 后 ， 该 数 字 再 出 栈 ， 求 该 数 字 序 列 的 出 栈 序 列 是 否 合 法 ？

 

https://pic2.zhimg.com/80/v2-09145f597c85c8584f393340a9706627_1440w.jpg

思路：使用栈与队列模拟入栈出栈过程：

算法：1，将出栈序列存入队列中，1到n数字序列压入栈中；

2.每次将元素压入栈栈后与队列头部比较，相同则将队头和栈顶弹出；

3.依次进行若最后栈非空，则不合法

#include<stdio.h>
#include<queue>
#include<stack>


bool cheak_is_order(std::queue<int> &order)
{
    std::stack<int> S;
    int n = order.size();
    for(int i = 1;i<=n;i++)
    {
        S.push(i);
        while(!S.empty() && S.top()==order.front())
        {
            S.pop();
            order.pop();
        }
    }
    if(!S.empty())
    {
        return false;
    }
    return true;
}



int main()
{
  int n;
  int train;
  scanf("%d",&n);
  while(n)
  {
      scanf("%d",&train);
      while(train)
      {
        std::queue<int> order;
        order.push(train);
        for(int i = 1;i<n;i++)
        {
            scanf("%d",&train);
        }
        if(cheak_is_order(order))
          {
               printf("Yes\n");
          }
          else{
            printf("No\n");
          }
          scanf("%d",&train);
      }
      printf("\n");
      scanf("%d",&n);
  }
  return 0;
}

 

224 简单计算器

实现一个基本的计算器来计算一个简单的字符串表达式的值。

字符串表达式可以包含左括号 ( ，右括号 )，加号 + ，减号 -，非负整数和空格 。

示例 1:

输入: "1 + 1"

输出: 2

示例 2:

输入: " 2-1 + 2 "

输出: 3

示例 3:

输入: "(1+(4+5+2)-3)+(6+8)"

输出: 23

预备知识：字符串转数字

void compute(std::stack<int> &number_stack,std::stack<char> &operation_stack)
{
    if(number_stack.size()<2)
    {
        return;
    }
    int num2 = number_stack.top();
    number_stack.pop();
    int num1 = number_stack.top();
    number_stack.pop();
    if(operation_stack.top()=='+')
    {
        number_stack.push(num1+num2);
    }
    else if(operation_stack.top()=='-')
    {
        number_stack.push(num1-num2);
    }
    operation_stack.pop();
}

int main()
{
int number = 0;
std::string s="12345";
for(int i = 0;i<s.length();i++)
{
    number = number * 10 +s[i] -'0';
}
printf("number = %d\n",number);
return 0;
}

字符串处理思路：

https://pic4.zhimg.com/80/v2-cfcfeaf4c6eea0186304717df4ffe856_1440w.jpg

初始状态STATE_BEGIN

如果为数字字符，转入NUMBER_STATE

number=number*10+ch-'0';

否则，转入OPERATION_STATE；根据compute_flag进行计算

如果字符‘+’或者‘-’

压入OPERATION_STATE栈中，并将compute_flag设为1；

如果字符‘（’

设置compute_flag=0；

转入NUMBER_STATE；

如果‘）’进行compute计算

如果'0'到‘9’切换NUMBER_STATE；

void compute(std::stack<int> &number_stack,std::stack<char> &operation_stack)
{
    if(number_stack.size()<2)
    {
        return;
    }
    int num2 = number_stack.top();
    number_stack.pop();
    int num1 = number_stack.top();
    number_stack.pop();
    int i=0;
    if(operation_stack.top() == '+')
    {
        i=num1+num2;
        number_stack.push(i);
    }
    else if(operation_stack.top() == '-')
    {
        i=num1-num2;
        number_stack.push(i);
    }
    operation_stack.pop();
}

class Solution {
public:
    int calculate(string s) {
        const int STATE_BEGIN=0;
        const int STATE_NUMBER=1;
        const int STATE_OPERATOR=2;
        std::stack<int> number_stack;
        std::stack<char> operation_stack;
        int compute_flag=0;
        int number = 0;
        int STATE = STATE_BEGIN;
        for(int i = 0;i<s.length();i++)
        {
            if(s[i]=' ')
            {
                continue;
            }
           switch(STATE)
        {
            case STATE_BEGIN:
            
                if(s[i]>='0'&& s[i]<='9')
                {
                    STATE=STATE_NUMBER;
                }
                else{
                    STATE=STATE_OPERATOR;
                }
                i--;
                break;
            
            case STATE_NUMBER:
            
                if(s[i]>='0'&&s[i]<='9')
                {
                    number=number*10+(s[i]-'0');
                }
                else
                {
                    number_stack.push(number);
                    if(compute_flag==1)
                    {
                        compute(number_stack,operation_stack);
                    }
                    number = 0;
                    i--;
                    STATE=STATE_OPERATOR;
                }
                break;
            case STATE_OPERATOR:
            
                if(s[i]=='+'||s[i]=='-')
                {
                    operation_stack.push(s[i]);
                    compute_flag=1;
                }
                else if(s[i]=='(')
                {
                    STATE=STATE_NUMBER;
                    compute_flag=0;
                }
                else if(s[i]>='0'&&s[i]<='9')
                {
                    STATE=STATE_NUMBER;
                    i--;
                }
                else if(s[i]==')')
                {
                    //compute_flag=1;
                    compute(number_stack,operation_stack);
                }
                break;
        }
        }
        if(number!=0)
        {
            number_stack.push(number);
            compute(number_stack,operation_stack);
        }
        if(number==0 && number_stack.empty())
        {
            return 1;
        }
        return number_stack.top();
        }
};

215.数组中第K个大的数

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2

输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4

输出: 4

第一种方法：排序算法：

bool cmp(int a,int b)
{
    return a>b;
}
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        std::sort(nums.begin(),nums.end(),cmp);
        return nums[k-1];

    }
};

方法二 最小堆

预备知识：优先级队列：普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。

定义：priority_queue<Type, Container, Functional>

Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 就是比较的方式。

完全二叉树：若二叉树的深度为h，则除第h层外，其他层的结点全部达到最大值，且第h层的所有结点都集中在左子树

二叉堆：最大（小）值先出的完全二叉树

堆是一颗完全二叉树；堆中的某个结点的值总是大于等于（最大堆）或小于等于（最小堆）其孩子结点的值；堆中每个结点的子树都是堆树。

最大堆的构造

#include<stdio.h>
#include<queue>

int main()
{
    std::priority_queue<int> big_heap; //默认构造的是最大堆
    std::priority_queue<int,std::vector<int>,std::greater<int>> small_heap;
    std::priority_queue<int,std::vector<int>,std::less<int>> big_heap2;

    if(big_heap.empty())
    {
        printf("big_heap is empty!\n");
    }
    int test[]={6,10,1,7,99,4,33};
    for(int i = 0;i<7;i++)
    {
        big_heap.push(test[i]);
    }
    printf("big_heap.top=%d\n",big_heap.top());

    big_heap.push(1000);
    printf("big_heap.top=%d\n",big_heap.top());
    for(int i = 0;i<3 ;i++)
    {
        big_heap.pop();

    }
    printf("big_heap.top=%d\n",big_heap.top());
    printf("big_heap.size = %d\n",big_heap.size());
    return 0;
}

解题思路：

维护一个最小堆，将比第k个大的数push入堆中，则栈顶即为第k个大的数

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        std::priority_queue<int,std::vector<int>,std::greater<int>> small_heap;
        for(int i=0;i<nums.size();i++)
        {
            if(small_heap.size()<k)
            {
                small_heap.push(nums[i]);
            }
            else if(small_heap.top()<nums[i])
            {
                small_heap.pop();
                small_heap.push(nums[i]);
            }
        }
    return small_heap.top();
    }
};

295.数据流中位数

中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。

例如，

[2,3,4] 的中位数是 3

[2,3] 的中位数是 (2 + 3) / 2 = 2.5

设计一个支持以下两种操作的数据结构：

void addNum(int num) - 从数据流中添加一个整数到数据结构中。

double findMedian() - 返回目前所有元素的中位数。

示例：

addNum(1)

addNum(2)

findMedian() -> 1.5

addNum(3)

findMedian() -> 2

 

算法思路：

设置一个最大堆和最小堆，分别各自存放一半数据，则中位数即为堆顶

class MedianFinder {
public:
    /** initialize your data structure here. */
    MedianFinder() {

    }
    
    void addNum(int num) {
        if(big_heap.empty())
        {
            big_heap.push(num);
            return; //注意当big_heap初始化后需要返回，否则可能会重复压入num
        }
        if(big_heap.size()==small_heap.size())
        {
            if(num<big_heap.top())
            {
                big_heap.push(num);
            }
            else
            {
                small_heap.push(num);
            }

        }
        else if(big_heap.size()<small_heap.size())
        {
            if(num<small_heap.top())
            {
                big_heap.push(num);
            }
            else
            {
                big_heap.push(small_heap.top());
                small_heap.pop();
                small_heap.push(num);
            }

        }
        else if(big_heap.size()>small_heap.size())
        {
            if(num>big_heap.top())
            {
                small_heap.push(num);
            }
            else{
                small_heap.push(big_heap.top());
                big_heap.pop();
                big_heap.push(num);
            }

        }

    }
    
    double findMedian() {
        if(big_heap.size()==small_heap.size())
        {
            return (big_heap.top()+small_heap.top())*0.5;
        }
        else if(big_heap.size()>small_heap.size())
        {
            return big_heap.top();
        }
        else
        {
            return small_heap.top();
        }

    }
private:
    std::priority_queue<int,std::vector<int>,std::greater<int>> small_heap;
    std::priority_queue<int,std::vector<int>,std::less<int>> big_heap;
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder* obj = new MedianFinder();
 * obj->addNum(num);
 * double param_2 = obj->findMedian();
 */

 

5guo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
LeetCode刷题记录——队列、栈
驼君的小小博客园
05-05 320
20. 有效的括号 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 输入: "()" 输出: true 示例 2: 输入: "()[]{}" 输出: true 示例 3: 输入: "(]" 输出: fals...
栈与队列--进/出-栈/队
了不起的阿港的博客
06-28 1229
数组栈 完成void Push(Stack S,ElemType x);函数，该函数把数据x进栈，如果栈已满，则什么都不做。 完成void Pop(Stack S)函数，该函数把栈顶数据出栈，如果栈已空，则什么都不做。typedef int ElemType; struct StackRecord; typedef struct StackRecord *Stack; struct StackR
堆的操作——push/pop
我在浪里
03-24 1791
#include #include #include #include #include #include #include #include using namespace std; #define PI 3.1415926535897932 #define E 2.718281828459045 #define INF 0x3f3f3f3f #defin
深入理解数据结构——二叉树线索树基本操作
seek97的博客
08-09 280
#include <iostream> #include <string> using namespace std; typedef char EType; struct BinaryTreeNode { EType data; BinaryTreeNode* LChird;//左孩地址 bool Lflag; BinaryTreeNode* RChird;//右孩地址 bool Rflag; }; typedef BinaryTreeNode* BinaryTr.
数据结构和算法——栈、队列、堆
zxr916的博客
03-25 246
文章目录1.预备知识1.1 栈1.2 队列1.3 堆2.用队列实现栈2.1 题目描述2.2 解题思路2.3 C++实现3.用栈实现队列3.1 题目描述3.2 解题思路3.3 C++实现4.最小栈4.1 题目描述4.2 解题思路5.合法的出栈序列5.1 题目描述5.2 解题思路5.3 C++实现6.基本计算器6.1 题目描述6.2 解题思路7.数组中的第K个最大元素7.1 题目描述7.2 解题思路7.3 C++实现8.数据流的中位数8.1 题目描述8.2 解题思路8.3 C++实现 1.预备知识 1.1 栈
数据结构笔记：双端队列
01-21
分类目录——数据结构笔记 双端队列（deque，double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中每一端，都可以进行存入和取出，去其中一段，都像一个栈一样。 存取也只限定在两端，不能在中间...
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
【数据结构】第五周 栈与队列.pdf
01-19
该资源为个人观看青岛大学王卓老师数据结构课程课堂笔记
[栈与队列] LeetCode 225. 用队列实现栈
LittleTime_cc的博客
02-18 121
225. 用队列实现栈 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： void push(int x) 将元素 x 压入栈顶。 int pop() 移除并返回栈顶元素。 int top() 返回栈顶元素。 boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。 注意： 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop
leetcode 刷题 之 栈和队列
weixin_41734373的博客
06-15 164
文章目录225 用队列实现栈232 用栈实现队列155 最小栈（返回最小值）合法的出栈顺序（栈+队列） 225 用队列实现栈 思路： 举例： 通过修改push 操作 ，实现 将123 以 321 的形式 存储在队列中 此时队列的front 为 3 ，队列的pop 是弹出3 ； 队列的push 是将321 变为 4321. 代码： //请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。 // // 实现 MyStack
Queue（单项队列）和Deque（双端队列）的知识点整理
qq_42148002的博客
03-14 2077
1、Queue（单向队列） 1.1 定义 常见队列就是FIFO（先进先出）队列，可以实现前端删除（peek/pop from front），后端添加（push to back）的功能。 1.2 实现（既可以用数组-顺序队列，也可以用链表-链式队列） 子接口：BlockingQueue Java中的单项队列是用链表实现的； 后面的Deque（双端队列）继承了Queue，是重点，也是一个好东西。 Queue本身是一个接口，继承了Collection集合； 其中有基本的队列抽象方法，三类，队尾插入元素，队头取
数据结构----顺序栈
qq_38345598的博客
05-13 304
#include&lt;stdio.h&gt; #define m0 20 struct stack { int s[m0+1]; int t; }; void push(struct stack *p,int x) { if(p-&gt;t==m0) printf("栈已满无法插入\n"); else { p-&gt;t=p-&gt;t+1; p-...
leetcode 225.用队列实现栈
janyoo的博客
04-29 102
使用队列实现栈的下列操作： push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty() – 返回栈是否为空 注意: 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque...
数据结构算法经常看到的形如"int InitStack(Stack &S)"和"int Empty(Stack S)"的解释
热门推荐
小桥流水丿小溪
04-22 1万+
本文由江伟原创，如要转载请注明出处，谢谢！ 　　 　　在很多算法中我们经常看到形如"int InitStack(Stack &S)"和"int Empty(Stack S)"的两种形式，即有"&"和没有"&"两种。相信很多人还没弄清楚这是怎么回事。其实这是函数传参的两种形式—按值传递和按址传递。 　　 　　我们都知道以前学c++时一个经典例子用来解释这两种传参方式的区别，就是调
Python学习笔记（七）--------Python数据结构
Baldwin_KeepMind
03-20 5959
一、相关 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 Python中的绝大部分数据结构可以最终分解成三种类型：集合（Set），序列（Sequence），映射（Mapping）。 1、集合是独立于标量，序列和映射之外的特殊数据结构，它支持数学理论的各种集合的运算。它的存在使得用程序代码实现数学理论变得方便。 2、序列是Python中最为...
Pandas两种主要的数据结构
Emily
05-23 8368
OUTLINE Series pandas pandas中的数据结构主要包括两种，一种是Series，一种是dataframe。 Series Series表示一维数据，可以简单理解为一个向量，但是不同于向量的是，Series会自动为这一维数据创建行索引。 ① 创建Series import pandas as pd series_obj = pd.Series(['a'...
我是一个“栈”
程序员小灰的博客
03-28 1546
点击上方“程序员小灰”，选择“置顶公众号”有趣有内涵的文章第一时间送达！本文转载自公众号  Hollis我是一个栈，先来跟你介绍一下我的家族，我的家族是一个很古老的家族，家族成员很多，外界称呼我们这个家族为数据结构。我们是计算机世界中存储和组织数据的。数据结构家族在计算机世界中是至关重要的，因为我们家族功能的强大，现代编程语言及其API中都有我们家族成员的身影。我的家族是一个庞大的家族。家族中也有
数据结构——绪论以及线性表的顺序表示
Tyler_Zx的博客
07-17 5544
绪论 数据类型 数据类型是一个值的集合和定义在此集合上一组操作的总称。 (1)原子类型：其值不可再分的数据类型，如int，char，float。 (2)结构类型：其值可以再分解为若干成分的数据类型。 struct Student { long no; char name[10]; float score; }; (3)抽象数据类型(ADT)：是指一个数学...
数据结构与算法c++笔记
最新发布
08-31
很高兴回答你关于数据结构与算法的问题！以下是一些关于C语言中数据结构和算法的笔记： 1. 数据结构： - 数组（Array）：一组相同类型的元素按顺序存储在连续的内存空间中。 - 链表（Linked List）：由节点（Node）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值