2. 栈和队列

最新推荐文章于 2024-06-14 14:44:45 发布
最新推荐文章于 2024-06-14 14:44:45 发布
阅读量93 收藏
点赞数
分类专栏： 数据结构 文章标签： 队列 数据结构 c语言 算法 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45634592/article/details/115044984
版权

文章目录

2.1 栈

2.1.1 栈的顺序存储
#include <stdio.h>
#include <stdlib.h>

#define MaxSize 10

typedef struct {
    int data[MaxSize];  // 存储栈元素的静态数组
    int top;    // 栈顶指针，记录的是数组下标
} SqStack;

// 初始化栈
void InitStack(SqStack *s) {
    s->top = -1;
}

// 判断栈是否为空
void StackEmpty(SqStack *s) {
    if (s->top == -1)
        printf("栈为空！\n");
    else
        printf("栈不为空！\n");
}

// 压栈(将元素x添加到栈s中)
void Push(SqStack *s, int x) {
    if (s->top == MaxSize - 1) {    // top记录的是数组下标
        printf("栈已满，无法压栈！\n");
        exit(1);
    }
    s->top++;
    s->data[s->top] = x;
    printf("入栈成功！\n");
}

// 出栈
int Pop(SqStack *s) {
    if (s->top == -1) {
        printf("栈为空，无法出栈！\n");
        exit(1);
    }
    int x = s->data[s->top];
    s->top--;
    return x;
}

// 取栈顶元素
int GetTopStack(SqStack s) {
    if (s.top == -1) {
        printf("栈为空，无法出栈！\n");
        exit(1);
    }
    return s.data[s.top];
}

// 打印栈
void PrintStack(SqStack s) {
    while (s.top != -1) {
        printf("%d\n", s.data[s.top]);
        s.top--;
    }
}

int main() {
    SqStack s;
    InitStack(&s);
    StackEmpty(&s);
    Push(&s, 123);  // 入栈
    Push(&s, 789);
    Push(&s, 0);
    printf("栈顶元素为：%d\n", GetTopStack(s));   // 打印栈顶元素
    PrintStack(s);  // 打印栈

    printf("出栈：%d\n", Pop(&s));     // 出栈
    printf("栈顶元素为：%d\n", GetTopStack(s));   // 打印栈顶元素
    PrintStack(s);  // 打印栈
}
2.1.2 栈的链式存储
#include <stdio.h>
#include <stdlib.h>

typedef struct Snode {
    int data;   // 数据域
    struct Snode *next;    // 每个栈元素的指针域，指向上一个入栈的元素
} StackNode, *LinkStack;

// 初始化链栈
void InitLinkStack(LinkStack *top) {
    *top = (StackNode *) malloc(sizeof(StackNode));
    if (*top == NULL) {
        printf("分配空间失败！\n");
    } else {
        (*top)->next = NULL;
        printf("分配空间成功！\n");
    }
}

// 判断链栈是否为空
void LinkStackEmpty(LinkStack top) {
    if (top->next == NULL)
        printf("栈为空！\n");
    else
        printf("栈不为空！\n");
}

// 压栈(将元素x添加到栈s中)
void Push(LinkStack *top, int x) {
    StackNode *s = (StackNode *) malloc(sizeof(StackNode));
    if (s == NULL) {
        printf("分配空间失败！\n");
        exit(1);
    }

    s->data = x;
    s->next = (*top)->next;
    (*top)->next = s;
    printf("压栈成功！\n");
}

// 出栈
int Pop(LinkStack *top) {
    if ((*top)->next == NULL) {
        printf("栈为空，无法出栈！\n");
        exit(1);
    }
    StackNode *s = (*top)->next;    // 定义一个指针指向要出栈的元素
    int x = s->data;   // 存储要出栈的元素的数据
    (*top)->next = s->next;
    free(s);
    return x;
}

// 取栈顶元素
int GetTopStack(LinkStack top) {
    if (top == NULL) {
        printf("栈为空，无法出栈！\n");
        exit(1);
    }
    return top->next->data;
}

// 打印栈
void PrintStack(LinkStack s) {
    StackNode *point = s->next;
    while (point != NULL) {
        printf("%d\n", point->data);
        point = point->next;
    }
}

int main() {
    LinkStack s;    // 声明指向链栈的指针
    InitLinkStack(&s);
    LinkStackEmpty(s);
    Push(&s, 123);  // 入栈
    Push(&s, 789);
    Push(&s, 0);
    printf("栈顶元素为：%d\n", GetTopStack(s));   // 打印栈顶元素
    PrintStack(s);  // 打印栈

    printf("出栈：%d\n", Pop(&s));     // 出栈
    printf("栈顶元素为：%d\n", GetTopStack(s));   // 打印栈顶元素
    PrintStack(s);  // 打印栈
}

2.2 队列

2.2.1 队列的顺序存储 - 循环队列

以下方案的区别在于，判队空/满的条件不一样（牺牲一个存储单位/增加辅助变量），队头队尾指针指向的位置不一样。

方案一：判空会牺牲掉一个空间
#include <stdio.h>
#include <stdlib.h>

#define MaxSize 10

typedef struct {
    int data[MaxSize];  // 存储队列元素的静态数组
    int front, rear;    // 队头、队尾指针，记录的是数组下标
} SqQueue;

// 初始化队列
void InitQueue(SqQueue *s) {
    s->front = s->rear = 0;
}

// 判断队列是否为空
void EmptyQueue(SqQueue s) {
    if (s.front == s.rear)
        printf("队列为空！\n");
    else
        printf("队列不为空！\n");
}

// 入队(将元素x添加到队列s中)
void InQueue(SqQueue *s, int x) {
    if ((s->rear + 1) % MaxSize == s->front) {    // 如果队尾指针指向的位置的下一个位置和队头指针指向的是一个位置，则队满
        printf("队列已满，无法入队！\n");
        exit(1);
    }
    s->data[s->rear] = x;   // 直接将数据存储到队尾指针指向的位置
    s->rear = (s->rear + 1) % MaxSize;  // 将队尾指针指向下一个位置（所以队尾指针指向的位置总是没有数据）
    printf("入队成功！\n");
}

// 出队
int OutQueue(SqQueue *s) {
    if (s->front == s->rear) {
        printf("队列为空，无法出队！\n");
        exit(1);
    }
    int x = s->data[s->front];
    s->front = (s->front + 1) % MaxSize;        // 让队头指针可以循环移动
    return x;
}

// 取队头元素
int GetHeadQueue(SqQueue s) {
    if (s.front == s.rear) {
        printf("队列为空，无法出队！\n");
        exit(1);
    }
    int x = s.data[s.front];
    return x;
}

// 打印队列
void PrintQueue(SqQueue s) {
    while (s.front != s.rear) {
        printf("%d\n", s.data[s.front]);
        s.front++;
    }
}

// 求队列长度
int GetQueueLength(SqQueue s) {
    return (s.rear - s.front + MaxSize) % MaxSize;
}

int main() {
    SqQueue s;
    InitQueue(&s);
    EmptyQueue(s);
    InQueue(&s, 123);  // 入队
    InQueue(&s, 789);
    InQueue(&s, 0);
    printf("队头元素为：%d\n", GetHeadQueue(s));   // 打印队头元素
    PrintQueue(s);  // 打印队列

    printf("出队：%d\n", OutQueue(&s));     // 出栈
    printf("队头元素为：%d\n", GetHeadQueue(s));   // 打印队头元素
    printf("队长：%d\n", GetQueueLength(s));
    PrintQueue(s);  // 打印对列
}
方案二：判空增加辅助变量size

在定义结构体的时候多设置一个属性size，记录插入数据的个数，这样判空条件就只需要关心size的大小了。

方案三：判空增加辅助变量flag

在定义结构体的时候多设置一个属性flag，记录当前是入队还是出队操作；如果是入队操作导致队头指针等于队尾指针，那么此时队满；如果是出队操作导致队头指针等于队尾指针，那么此时队空。

方案四

如果想要队头和队尾指针都指向当前队列的队头队尾元素，要注意初始化的时候让队尾指针指向0这个位置，让队头指针指向9这个位置；

当入队操作的时候只需要，先将队尾指针 (rear+1)%MaxSize 然后将筑据添加进去即可。

这样不会牺牲一个空间，并且让队头/尾指针实实在在的指向了队头/尾。

注意该方案的判空方式选前面的一种即可

2.2.2 队列的链式存储
带头节点
#include <stdio.h>
#include <stdlib.h>

typedef struct QNode {
    int data;   // 节点的数据域
    struct QNode *next;     // 节点的指针域，指向下一个节点
} QNode;

typedef struct {
    QNode *front;   // 队头指针
    QNode *rear;    // 队尾指针
} LinkQueue;

// 初始化链队（带头节点）
void InitQueue(LinkQueue *q) {
    // 初始化时 front 、rear 都指向头节点
    q->front = q->rear = (QNode *) malloc(sizeof(QNode));
    if (q->front == NULL) {
        printf("初始化分配空间失败！\n");
        exit(1);
    } else {
        printf("初始化分配空间成功！\n");
    }
    q->front->next = NULL;
}

// 判断队列是否为空
void EmptyQueue(LinkQueue q) {
    if (q.front == q.rear)
        printf("链队为空！\n");
    else
        printf("链队不为空！\n");
}

// 入队(将 x 添加到链队 q 中)
void InQueue(LinkQueue *q, int x) {
    QNode *s = (QNode *) malloc(sizeof(QNode));
    if (s == NULL) {
        printf("添加数据分配空间失败！\n");
        exit(1);
    }
    s->data = x;
    s->next = NULL;
    q->rear->next = s;
    q->rear = s;    // 让队尾指针指向最后一个元素
    printf("入队成功！\n");
}

// 出队
int OutQueue(LinkQueue *q) {
    if (q->front == q->rear) {
        printf("队列为空，无法出队！\n");
        exit(1);
    }
    QNode *s = q->front->next;  // 指向头节点的下一个节点
    int x = s->data;
    q->front->next = s->next;
    if (q->rear == s)   // 如果删除的是最后一个节点的话，就得修改队尾指针
        q->rear = q->front;
    free(s);
    return x;
}

// 取队头元素
int GetHeadQueue(LinkQueue q) {
    if (q.front == q.rear) {
        printf("队列为空！\n");
        exit(1);
    }
    return q.front->next->data;
}

// 打印队列(带头节点)
void PrintQueue(LinkQueue q) {
    QNode *s = q.front->next;
    while (s != NULL) {
        printf("%d\n", s->data);
        s = s->next;
    }
}

int main() {
    LinkQueue s;
    InitQueue(&s);
    EmptyQueue(s);
    InQueue(&s, 123);  // 入队
    InQueue(&s, 789);
    InQueue(&s, 0);
    printf("队头元素为：%d\n", GetHeadQueue(s));   // 打印队头元素
    PrintQueue(s);  // 打印队列

    printf("出队：%d\n", OutQueue(&s));     // 出栈
    printf("队头元素为：%d\n", GetHeadQueue(s));   // 打印队头元素
    PrintQueue(s);  // 打印对列
}
不带头节点

2.3 双端队列

1、两端入，两端删

2、一端入，两端删

3、两端入，一端删

常考点：栈的输出序列的合法性

2.4 栈的应用

2.4.1 括号配对
#include <stdio.h>
#include <stdlib.h>

#define MaxSize 10
typedef struct {
    char data[MaxSize];   // 栈的数据域
    int top;     // 栈的头指针
} Stack;

// 初始化栈
void InitStack(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
int EmptyStack(Stack s) {
    if (s.top == -1)
        return 1;   // 返回true，即为空
    else
        return 0;   // 返回false，即不为空
}

// 入栈(将 x 添加到栈 s 中)
void Push(Stack *s, char x) {
    s->top++;
    s->data[s->top] = x;
    printf("入栈成功！\n");
}

// 出栈
char Pop(Stack *s) {
    if (EmptyStack(*s)) {
        printf("栈为空，无法出栈！\n");
        exit(1);
    }
    char x = s->data[s->top];
    s->top--;
    printf("出栈成功！\n");
    return x;
}

// 打印栈
void PrintStack(Stack s) {
    while (s.top != -1) {
        printf("%d\n", s.data[s.top]);
        s.top--;
    }
}

/**
 * 括号匹配
 * @param str 存储需要配对的括号字符数组
 * @param length 该字符数组的长度
 * @return  返回 1-匹配成功，0-匹配失败
 */
int bracketCheck(char str[], int length) {
    Stack s;
    InitStack(&s);  // 初始化栈
    for (int i = 0; i < length; ++i) {
        if (str[i] == '(' || str[i] == '[' || str[i] == '{') {  // 如果扫描到左括号就入栈
            Push(&s, str[i]);
        } else {
            if (EmptyStack(s))  // 如果匹配到右括号且当前栈为空
                return 0;   // 匹配失败

            char topElem = Pop(&s);     // 取出栈顶元素
            if (str[i] == ')' && topElem != '(')
                return 0;
            if (str[i] == ']' && topElem != '[')
                return 0;
            if (str[i] == '}' && topElem != '{')
                return 0;
        }
    }
    return EmptyStack(s);   // 所有括号全部匹配后，栈为空才说明匹配成功
}

int main() {
    char str[] = {'(', '(', '(', '{', '{', '[', '}', '}', ')', ')', ')'};
    if (bracketCheck(str, 10)) {
        printf("匹配成功！\n");
    } else {
        printf("匹配失败！\n");
    }
}
2.4.2 表达式求值

三种算数表达式：

  1. 中缀表达式
  2. 后缀表达式（常考）
  3. 前缀表达式
1、用栈实现中缀表达式转后缀表达式
#include <stdio.h>
#include <stdlib.h>

#define MaxSize 10
typedef struct {
    char data[MaxSize];   // 栈的数据域
    int top;     // 栈的头指针
} Stack;

// 初始化栈
void InitStack(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
int EmptyStack(Stack s) {
    if (s.top == -1)
        return 1;   // 返回true，即为空
    else
        return 0;   // 返回false，即不为空
}

// 入栈(将 x 添加到栈 s 中)
void Push(Stack *s, char x) {
    s->top++;
    s->data[s->top] = x;
    printf("入栈成功！\n");
}

// 出栈
char Pop(Stack *s) {
    if (EmptyStack(*s)) {
        printf("栈为空，无法出栈！\n");
        exit(1);
    }
    char x = s->data[s->top];
    s->top--;
    printf("出栈成功！\n");
    return x;
}

// 取栈顶元素
char GetTopStack(Stack s) {
    if (s.top == -1) {
        printf("栈为空，无法出栈！\n");
        exit(1);
    }
    return s.data[s.top];
}

// 打印栈
void PrintStack(Stack s) {
    while (s.top != -1) {
        printf("%d\n", s.data[s.top]);
        s.top--;
    }
}

/**
 * 用栈实现中缀表达式转后缀表达式
 *
 * 算法思想：
 * 1、初始化一个栈，用于保存暂时还不能确定运算顺序的运算符
 * 2、从左到右处理各个元素，直到末尾。可能遇到三种情况：
 *      ① 遇到操作数。
 *              直接加入后缀表达式。
 *      ②遇到界限符。
 *              遇到"（"直接入栈；遇到"）”则依次弹出栈内运算符并加入后缀表达式，直到弹出"（"为止。注意："（"不加入后缀表达式。
 *      ③遇到运算符。
 *              依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到"（"或栈空则停止。之后再把当前运算符入栈。
 * 3、按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。
 *
 * @param str 存储需要进行转换的中缀表达式
 * @param length 该字符数组的长度
 * @param expression 存放后缀表达式
 * @return  返回转换好后的后缀表达式
 */

void getPostfixNotation(char str[], int length, char expression[]) {
    Stack s;
    InitStack(&s);  // 初始化栈
    int point = 0;  // 记录后缀表达式的长度
    for (int i = 0; i < length; ++i) {
        if (str[i] != '(' && str[i] != ')' && str[i] != '+' && str[i] != '-' && str[i] != '*' &&
            str[i] != '/') {  // 如果是int类型的数据（即操作数）
            expression[point] = str[i]; // 直接加入后缀表达式
            point++;
        }

        if (str[i] == '(') {    // 如果匹配到'('
            Push(&s, str[i]);   // 直接入栈
        } else if (str[i] == ')') { // 如果匹配到')'
            int index = s.top;
            for (int j = 0; j <= index; ++j) {
                char c = GetTopStack(s);
                if (c != '(') { // 依次弹出栈内运算符并加入后缀表达式，直到弹出"（"为止
                    Pop(&s);
                    expression[point] = c;
                    point++;
                } else {
                    Pop(&s);    // 当遇到了'('，也要弹出
                    break;
                }
            }
        }

        if (str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/') { // 如果遇到运算符
            int index = s.top;
            for (int j = 0; j <= index; ++j) {  // 弹出栈中优先级高于或等于当前运算符的所有运算符
                char c = GetTopStack(s);
                if (c == '(' || EmptyStack(s))
                    break;

                if (str[i] == '+' || str[i] == '-') {
                    if (c == '+' || c == '-') {
                        Pop(&s);
                        expression[point] = c;
                        point++;
                    }
                }
                if (str[i] == '*' || str[i] == '/') {
                    if (c == '*' || c == '/') {
                        Pop(&s);
                        expression[point] = c;
                        point++;
                    }
                }
            }
            Push(&s, str[i]);   // 把当前运算符入栈
        }
    }
    // 处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式
    int index = s.top;
    for (int k = index; k >= 0; --k) {
        if (s.data[k] == '+' || s.data[k] == '-' || s.data[k] == '*' || s.data[k] == '/') {
            expression[point] = s.data[k];
            point++;
        }
    }
}

int main() {
    char str[] = "((5/(7'-(1+1)))*3)-(2+(1+1))";
//    char str[] = "1+(1+2)*2";

    char expression[50];
    getPostfixNotation(str, 9, expression);
    printf("%s", expression);
}
2、用栈实现后缀表达式的计算
①从左往右扫描下一个元素，直到处理完所有元素
②若扫描到操作数则压入栈，并回到①；否则执行③
③若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①
3、用栈实现中缀表达式的计算
①初始化两个栈，操作数栈和运算符栈
②若扫描到操作数，压入操作数栈
③若扫描到运算符或界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出一个运算符时，就需要再弹出两个操作数栈的栈顶元素并执行相应运算，运算结果再压回操作数栈）
2.4.3 递归

2.5 队列的应用

  1. 树的层次遍历

  2. 图的广度优先遍历

BUG_GUB
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
栈与队列
Hoppinging的博客
04-03 146
栈与队列都是数据结构的一种，只能在端口进行增删数据操作 栈的特点的先入后出 队列的特点的先入先出 简单的栈(数组栈和链栈) //1. 数组栈 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MaxIndex 100 typedef struct{ char data[MaxIndex]; int top; }Stack; //初始化数组栈 Stack *init(){
栈和队列
qq_52607834的博客
05-04 202
栈与队列的详细讲解，文章超长警告！！！（C语言版）
栈 & 队列
qq_45636631的博客
05-03 84
栈—Stack 定义 栈是限定仅在表尾进行插入和删除操作的线性表 允许插入和删除的一端称为栈顶，另一端称为栈底 不含任何数据元素的栈称为空栈 栈又称为后进先出线性表，简称LIFO结构，或者称为先进后出，简称FILO结构 栈操作 结构体 struct Node { int data; Node *next; }; struct Stack { Node *top; int count; }; 初始化栈 //初始化栈 void InitStack(Stack *s) {
数据结构第三章 栈与队列
YJY131248的博客
06-01 340
文章目录1 栈1.1 栈的定义1.2 栈的表示和实现1.2.1 顺序栈1.2.1.1 顺序栈的存储结构1.2.1.2 顺序栈的初始化1.2.1.3 顺序栈的进栈1.2.1.4 顺序栈的出栈1.2.2 链栈1.2.2.1 链栈的存储结构1.2.2.2 链栈的入栈1.2.2.3 链栈的出栈1.3 栈与递归的实现1.3.1 递归算法的前提1.3.2 递归工作栈2 队列2.1 队列的定义2.2 队列的表示和实现2.2.1 顺序队列2.2.1.1 顺序队列的存储结构2.2.1.2 顺序队列的假溢出2.2.2 循环队列
【题解】牛客挑战赛50
Huah_2018的博客
05-12 459
A Red and Blue and Green 对于所有偶数位置，将它的颜色修改成和两边不同的颜色。 #include<bits/stdc++.h> #define inf 0x3f3f3f3f typedef unsigned long long ull; typedef long long ll; #define rep(i,l,r) for(int i=l;i<=r;i++) #define nep(i,r,l) for(int i=r;i>=l;i--) void sc(i
栈和队列的区别
qq_64008726的博客
05-18 3066
队列 (Queue) 是一种先进先出 (First-In-First-Out, FIFO) 的数据结构，允许在两端进行插入和删除操作，插入在队尾，删除在队头。插入和删除性能不同：由于栈的操作顺序是后进先出，因此在栈中插入或删除操作只涉及到栈顶元素，而在队列中因为是先进先出，每一次插入或删除操作都可能影响到队头或队尾的元素。空间分配不同：在栈中，所有元素都在同一个连续的内存块中，因此栈的空间分配比较简单。而在队列中，元素通常分布在不同的内存块中，因此队列的空间分配比较复杂。
3.栈和队列.ppt
09-02
栈和队列知识点 栈和队列是两种非常重要的数据结构，在软件设计中应用很多。它们都是线性结构，线性表、栈和队列这三种数据结构的数据元素以及数据元素间的逻辑关系完全相同，差别是线性表的操作不受限制，而栈和...
3. 栈和队列1
08-03
定义只能在表的一端进行插入和删除的线性表逻辑结构数据元素之间是一对一的关系存储结构顺序存储或链式存储运算规则只能在栈顶运算，且访问结点时依照后进先出（LIFO）
14.栈和队列.pdf
04-26
14.栈和队列.pdf
zhanheduilie.rar_栈和队列
09-24
数据结构栈与队列PPT，详细讲解栈和队列的意义和使用方法。
02-栈和队列.zip
01-31
02_栈和队列.zip
数据机构之队列和栈
梦的灰色边沿...
01-07 2886
栈和队列一、栈和队列的概念1、栈的概念　　栈是只允许在一端进行插入或者删除操作的线性表。　　栈还涉及一些概念:　　　　栈顶: 线性表允许插入和删除元素的一端。　　　　栈底: 固定的，不允许进行插入和删除的一端。　　栈的输入输出特点是FILO(first in last out)后进先出，假如栈中有四个元素a_1,a_2,a_3,a_4已经全部按顺序入栈，则出栈的顺序是a_4,a_3,a_2,a_1。
三种 Queue 的异同
阿牧路泽
02-11 455
三种 queue 的异同
嵌入式C语言入门——队列（顺序队列）
qq_35599308的博客
12-12 402
数据结构之队列顺序队列构造顺序队列顺序队列的初始化判断队列是否满判断队列是否为空顺序队列的入队顺序队列的出队顺序队列的读取 顺序队列 存放数据的队列数组当做收尾相接的表处理(对长度进行SIZE取余作为数组下标) 若定义队列数组长度为SIZE,能存放数据的只有SIZE-1个元素 队头,队尾指针从前进时从SIZE-1,直接进到0 队列满时,若rear向前进一步则会与front相遇 队头指针向前一...
C++ 数据结构
最新发布
wy749929317的博客
06-14 356
这些数据结构在C++中都有广泛的应用，并且C++的STL（Standard Template Library）提供了丰富的模板类来实现这些数据结构，如。C++支持多种数据结构，这些数据结构根据它们组织数据的方式和访问数据的方式可以分为不同的类型。（红黑树实现的集合）等。（红黑树实现的映射表）、
数据结构【堆排序】
2301_80216111的博客
06-09 1042
向上调整建堆与向下调整建堆的时间复杂度与堆排序
数据结构-哈希表
passworddddddd的博客
06-11 435
他的结构就是数组，但是他神奇的地方在于对下标值的一种变换，这种变换可以称之为哈希函数，通过哈希函数可以获取到HashCode。哈希表不像数组、链表和树一样，直接画出来就知道他的结构，甚至原理。哈希表通常是基于数组进行实现的，但是对于数组，它有很多优势。
数据结构下的线性回归模型
qq_35320456的博客
06-11 649
线性回归是一种强大的统计工具，它可以帮助我们理解和预测数据之间的关系。通过使用适当的数据结构，我们可以有效地构建和训练线性回归模型，从而对新的输入进行准确的预测。在实际应用中，我们需要根据问题的具体情况进行适当的模型调整和优化，以获得最佳的结果。在本文中，我们介绍了线性回归模型的基本概念、原理以及如何在C#中实现一个简单的线性回归模型。通过示例代码，我们展示了如何使用数据结构来存储和处理数据，以及如何训练模型并进行预测。希望这篇博客能够帮助你更好地理解线性回归模型及其在实际中的应用。
【数据结构（邓俊辉）学习笔记】图05——优先级搜索
weixin_44399845的博客
06-10 570
优先级搜索 PFS
巩固栈和队列数据结构，学会运用栈和队列。1.回顾栈和队列的逻辑结构和受限操作特点，栈和队列的物理存储结构和常见操作。2.学习运用栈和队列的知识来解决实际问题。3.进一步巩固程序调试方法。4.进一步巩固模板程序设计。
04-13
2. 栈的物理存储结构和常见操作： - 栈的物理存储结构可以使用数组或链表来实现。 - 常见操作包括： - 入栈（push）：将元素添加到栈顶。 - 出栈（pop）：从栈顶移除元素。 - 取栈顶元素（top）：获取栈顶元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BUG_GUB

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值