C数据结构与算法——顺序栈 应用（C语言纯享版 迷宫）

最新推荐文章于 2025-05-27 22:41:11 发布
最新推荐文章于 2025-05-27 22:41:11 发布
阅读量342 收藏 4
点赞数 1
分类专栏： C 文章标签： c语言 开发语言 经验分享 数据结构 算法 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_55251408/article/details/131878988
版权

实验任务

(1) 掌握顺序栈及其C语言的表示；
(2) 掌握入栈、出栈等基本算法的实现；
(3) 掌握顺序栈的基本应用（求解迷宫通路）。

实验内容

  • 使用C语言实现顺序栈的类型定义与算法函数；
  • 编写main()函数并根据需要修改、补充相关的类型定义与函数，以实现“求解迷宫通路”问题：
  • 求解迷宫通路问题描述：
    • 给定一个M×N的迷宫图，指定一个入口与一个出口；
    • 规定行走规则为：按“上右下左”优先顺序向相邻空位移动1格，用（i，j）表示迷宫中的第i行第j列的一个方块
    • 在迷宫外围加上围墙；
  • 实现指定入口和出口的固定迷宫；
  • 实现随机入口和出口的固定迷宫；
  • 实现障碍、入口和出口都随机的迷宫。

实验源码

注意：必须在Dos窗口下运行，并且以管理员身份打开Dos窗口最佳

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <conio.h>
#include "windows.h"

#define MAXSIZE 1000
#define RATIO 0.6875 // 44/64的比例
#define DFDIR -1 // 方向默认 值
#define DISTOP 8 // 迷宫距离顶端距离格数

#define PASS 0 // 通路
#define WALL 1 // 墙
#define ENTRY 2 // 入口
#define EXIT 3 // 出口
// 可走
#define WALKU 40 // ↑
#define WALKR 41 // →
#define WALKD 42 // ↓
#define WALKL 43 // ←
#define DEAD 5 // 死路

// 延时设置
int walkDelay = 10;
int dirDelay = 10;
// 迷宫大小设置
int row = 20;
int line = 20;  // 这里有一个DOS窗口BUG，未解决

typedef struct {
    int x, y;
    int dir; // 方向
} Node;
typedef struct {
    int top;
    Node *data;
} SqStack;

void Map(int map[][line]); // 生成地图

void KnuthShuffle(int map[], int length); // 洗牌算法

void swapInt(int *a, int *b); // 辅助洗牌算法 交换

void PrintMap(int map[][line]); // 打印迷宫地图

boolean InitStack(SqStack *stack); // 初始化

void Walk(SqStack *stack, int in_x, int in_y, int map[][line]); // 移动迷宫

boolean Push(SqStack *stack, Node node); // 压栈

boolean IsFull(SqStack *stack); // 判栈满

boolean IsEmpty(SqStack *stack); // 判栈空

Node GetTop(SqStack *stack); // 取栈顶元素

void Pop(SqStack *stack); // 出栈 (这里用void是以下代码中保证无需判断)

void GotoXY(int x, int y); // 将光标移至屏幕 第x列，第y行 处

void WalkPath(int map[][line], int dir, int j, int k); // 走过的路径方向设置

void DeadPath(int j, int k); // 置为死路

void DirTest(int map[][line], int dir, int j, int k); // 方向试探

void HideCursor(void); // 隐藏光标

void DisplayStack(SqStack *stack); // 栈动态展示

void Color(short x); // 自定义函根据参数改变颜色

void MazeSize(int key, int map[][line]); // 迷宫大小

void DelaySet(int key, int map[][line]); // 延时设置

void UI(); // 界面设计

/**
 * <h2>顺序栈实验</h2>
 * <h3>随机迷宫问题</h3>
 * <h3>注意：请在Dos窗口↓运行</h3>
 * @return 0
 */
int main() {

    while (1) {
        UI(); // 界面打印

        srand(time(NULL));

        int map[row][line];
        char key;
        MazeSize(key, map); // 迷宫大小
        DelaySet(key, map); // 延时设置

        SqStack stack;
        if (!(InitStack(&stack))) {
            printf("顺序栈初始化失败~~\n");
            return 0;
        }
        int in_x, in_y;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < line; j++) {
                if (map[i][j] == ENTRY) {
                    in_x = i;
                    in_y = j;
                }
            }
        }
        HideCursor();
        DisplayStack(&stack);
        Sleep(3000);
        Walk(&stack, in_x, in_y, map);
        if (IsEmpty(&stack)) {
            GotoXY(0, row + DISTOP + 2);
            printf("无路可走，死翘翘了~~\n");
        }

        char quit;
        GotoXY(0, row + DISTOP + 4);
        printf("任意键继续(q退出)：");
        quit = getch();
        if (quit == 'q') {
            break;
        } else {
            system("cls");
        }

    }

    getchar();
}

void Map(int map[][line]) {
    int length = (row - 2) * (line - 2); // 8 * 8 内区域
    int randArr[length];
    for (int i = 0; i < length; i++) {
        if (i == 0) {
            randArr[i++] = ENTRY;
            randArr[i++] = EXIT;
        }
        if (i < (length * RATIO) + 2) {
            randArr[i] = PASS;
        } else {
            randArr[i] = WALL;
        }
    }
    KnuthShuffle(randArr, length); // 打乱 内区域
    // 赋值整张地图
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < line; j++) {
            // 这里一个小技巧：只要前面四个表达式一个为假，说明未到边界赋值，保证Length不会越界
            if (i != 0 && i != row - 1 && j != 0 && j != line - 1 && length--) {
                map[i][j] = randArr[length];
            } else {
                map[i][j] = WALL;
            }
        }
    }
}

void KnuthShuffle(int map[], int length) {
    for (int i = length - 1; i >= 1; i--) {
        swapInt(&map[i], &map[rand() % (i + 1)]);
    }
}

void swapInt(int *a, int *b) {
    int t;
    t = *a;
    *a = *b;
    *b = t;
}

void PrintMap(int map[][line]) {
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < line; j++) {
            GotoXY(j * 2, i + DISTOP);
            switch (map[i][j]) {
                case PASS:
                    printf("　");
                    break;
                case WALL:
                    Color(10);
                    printf("围");
                    break;
                case ENTRY:
                    Color(9);
                    printf("囚");
                    break;
                case EXIT:
                    Color(11);
                    printf("口");
                    break;
            }
        }
        printf("\n");
    }
}

boolean InitStack(SqStack *stack) {
    stack->data = malloc(sizeof(Node) * MAXSIZE);
    if (!(stack->data)) {
        return FALSE;
    }
    stack->top = 0;
    return TRUE;
}

void Walk(SqStack *stack, int in_x, int in_y, int map[][line]) {
    // 起点先入栈，为后续循环做铺垫
    Node node; // 生成当前位置(起点)
    node.x = in_x;
    node.y = in_y;
    node.dir = DFDIR;
    // 无方向
    Push(stack, node); // 起点入栈

    while (!(IsEmpty(stack))) { // 无路可走的情况，回到起点
        node = GetTop(stack); // 取出当前位置
        if (map[node.x][node.y] == EXIT) { // 判断当前位置是否是终点
            break;
        } else { // 如果不是终点，继续走
            int i, j, k;
            for (i = node.dir + 1; i < 4; i++) { // 判断当前位置各个方向是否可走
                switch (i) {
                    case 0: // 上
                        j = node.x - 1;
                        k = node.y;
                        DirTest(map, i, node.x, node.y);
                        break;
                    case 1: // 右
                        j = node.x;
                        k = node.y + 1;
                        DirTest(map, i, node.x, node.y);
                        break;
                    case 2: // 下
                        j = node.x + 1;
                        k = node.y;
                        DirTest(map, i, node.x, node.y);
                        break;
                    case 3: // 左
                        j = node.x;
                        k = node.y - 1;
                        DirTest(map, i, node.x, node.y);
                        break;
                }
                if (map[j][k] == PASS || map[j][k] == EXIT) { // 判断这个方向 是否可走
                    Node tNode; // 生成下一个位置
                    tNode.x = j;
                    tNode.y = k;
                    tNode.dir = DFDIR;

                    stack->data[stack->top - 1].dir = i; // 记录当前位置行走方向
                    Push(stack, tNode); // 下一个位置入栈
                    if (map[node.x][node.y] != WALL && map[node.x][node.y] != EXIT
                        && map[node.x][node.y] != ENTRY) {
                        WalkPath(map, i, node.x, node.y); // 将当前位置置为下一个要走的位置的方向
                    }
                    break; // 退出这个位置的方向查找循环
                }
            }
            if (i == 4) { // 四个方向都判断完，但是走不通
                if (!(map[node.x][node.y] == ENTRY)) { // 保证起点不被置为ENTRY
                    map[node.x][node.y] = DEAD; // 把当前位置，记为死路
                    DeadPath(node.x, node.y);
                }
                Pop(stack); // 当前位置出栈
            }
        }
    }
}

boolean Push(SqStack *stack, Node node) {
    if (IsFull(stack)) {
        return FALSE;
    }
    stack->data[stack->top++] = node;
    DisplayStack(stack);
    return TRUE;
}

boolean IsFull(SqStack *stack) {
    return stack->top == MAXSIZE;
}

boolean IsEmpty(SqStack *stack) {
    return stack->top == 0;
}

Node GetTop(SqStack *stack) {
    return stack->data[stack->top - 1];
}

void Pop(SqStack *stack) {
    stack->top--;
    DisplayStack(stack);
}

void GotoXY(int x, int y) {
    COORD pos = {x, y}; // 坐标
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); // 获取句柄（标准输出句柄）
    SetConsoleCursorPosition(hOut, pos); // 设置控制台光标位置
}

void WalkPath(int map[][line], int dir, int j, int k) {
    GotoXY(k * 2, j + DISTOP);
    Color(13);
    switch (dir) {
        case 0:
            printf("↑");
            map[j][k] = WALKU;
            break;
        case 1:
            printf("→");
            map[j][k] = WALKR;
            break;
        case 2:
            printf("↓");
            map[j][k] = WALKD;
            break;
        case 3:
            printf("←");
            map[j][k] = WALKL;
            break;
    }
    Sleep(walkDelay);
}

void DeadPath(int j, int k) {
    GotoXY(k * 2, j + DISTOP);
    Color(12);
    printf("Ｘ");
}

void DirTest(int map[][line], int dir, int j, int k) {
    GotoXY(k * 2, j + DISTOP);
    Color(15);
    switch (dir) {
        case 0:
            printf("↑");
            break;
        case 1:
            printf("→");
            break;
        case 2:
            printf("↓");
            break;
        case 3:
            printf("←");
            break;
    }
    Sleep(dirDelay);
    GotoXY(k * 2, j + DISTOP);
    Color(13);
    switch (map[j][k]) {
        case ENTRY:
            Color(9);
            printf("囚");
            break;
        case WALKU:
            printf("↑");
            break;
        case WALKR:
            printf("→");
            break;
        case WALKD:
            printf("↓");
            break;
        case WALKL:
            printf("←");
            break;
    }
}

void HideCursor(void) {
    CONSOLE_CURSOR_INFO cursor_info = {1, 0};
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}

void DisplayStack(SqStack *stack) {
    int len = row - 1;
    Color(12);
    GotoXY(line * 2 + 10, DISTOP);
    printf("|__i__j__di__| <- top");
    for (int j = 1; j <= len; j++) {
        GotoXY(line * 2 + 10, DISTOP + j);
        printf("|____________|\n");
    }
    int length = stack->top;
    for (int i = 0; i < length; i++, len--) {
        if (len == 0) {
            len = row - 1;
            for (int j = 1; j <= len; j++) {
                GotoXY(line * 2 + 10, DISTOP + j);
                printf("|____________|\n");
            }
        }
        Color(11);
        GotoXY(line * 2 + 10 + 3, DISTOP + len);
        printf("%d", stack->data[i].x);
        GotoXY(line * 2 + 10 + 7, DISTOP + len);
        printf("%d", stack->data[i].y);
        GotoXY(line * 2 + 10 + 10, DISTOP + len);
        printf("%d", stack->data[i].dir);
    }
}

void Color(short x) {
    if (x >= 0 && x <= 15) { // 参数在0-15的范围颜色
        SetConsoleTextAttribute( // 调用设置控制台文本属性函数(调用获取句柄函数(不理解), 不理解)
                GetStdHandle(STD_OUTPUT_HANDLE), x);    // 只有一个参数，改变字体颜色
    } else { // 默认的颜色白色
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
    }
}

void MazeSize(int key, int map[][line]) {
    do {
        do {
            UI();
            GotoXY(0, 5);
            printf("迷宫高度(a↑ d↓)：%d 格", row);
            key = getch();
            if (key == 'a') {
                row++;
            }
            if (key == 'd') {
                row--;
            }
            system("cls");
            Map(map); // 生成地图
            PrintMap(map); // 打印初始地图
        } while (key == 'a' || key == 'd');
        do {
            UI();
            GotoXY(0, 5);
            printf("迷宫高度(a↑ d↓)：%d 格", row);
            GotoXY(0, 6);
            printf("迷宫宽度(a↑ d↓)：%d 格", line);
            key = getch();
            if (key == 'a') {
                line++;
            }
            if (key == 'd') {
                line--;
            }
            system("cls"); // 清屏
            Map(map); // 生成地图
            PrintMap(map); // 打印初始地图
        } while (key == 'a' || key == 'd');
    } while (row < 4 || line < 4 || row > 20 || line > 20);
}

void DelaySet(int key, int map[][line]) {
    do {
        do {
            UI();
            GotoXY(0, 5);
            printf("行走延时(a↑ d↓)：%d ms", walkDelay);
            key = getch();
            if (key == 'a') {
                walkDelay += 10;
            }
            if (key == 'd') {
                walkDelay -= 10;
            }
            system("cls");
            PrintMap(map);
        } while (key == 'a' || key == 'd');
        do {
            UI();
            GotoXY(0, 5);
            printf("行走延时(a↑ d↓)：%d ms", walkDelay);
            GotoXY(0, 6);
            printf("方向延时(a↑ d↓)：%d ms", dirDelay);
            key = getch();
            if (key == 'a') {
                dirDelay += 10;
            }
            if (key == 'd') {
                dirDelay -= 10;
            }
            system("cls");
            PrintMap(map);
        } while (key == 'a' || key == 'd');
    } while (dirDelay < 0 || walkDelay < 0);
    UI();
    GotoXY(0, 5);
    printf("行走延时(a↑ d↓)：%d ms", walkDelay);
    GotoXY(0, 6);
    printf("方向延时(a↑ d↓)：%d ms", dirDelay);
}

void UI() {
    GotoXY(0, 0);
    Color(9);
    printf("  使用顺序栈解决迷宫通路问题 \n");
    GotoXY(0, 1);
    printf("==============================\n");
    GotoXY(0, 2);
    Color(12);
    printf("Ｘ--走过的无效通路");
    Color(9);
    printf("  囚--起点\n");
    GotoXY(0, 3);
    Color(13);
    printf("Ｏ--走过的有效通路");
    Color(11);
    printf("  口--终点\n");
    GotoXY(0, 4);
    printf("------------------------------\n");
    GotoXY(0, 7);
    printf("------------------------------\n");
}

/*
解析一波：
Color(0);	printf("黑色\n");
Color(9); 	printf("蓝色\n");
Color(2); 	printf("绿色\n");
Color(3); 	printf("湖蓝色\n");
Color(4);  	printf("红色\n");
Color(5);  	printf("紫色\n");
Color(11); 	printf("黄色\n");
Color(5);  	printf("白色\n");
Color(8);  	printf("灰色\n");
Color(9); 	printf("淡蓝色\n");
Color(2); 	printf("淡绿色\n");
Color(11); 	printf("淡浅绿色\n");
Color(12);  printf("淡红色\n");
Color(13); 	printf("淡紫色\n");
Color(14); 	printf("淡黄色\n");
Color(15); 	printf("亮白色\n");
Color(16);    // 因为这里大于15，恢复默认的颜色
 */

实验结果

在这里插入图片描述

数据结构与算法——BFS(广度优先搜索)
闻道有先后，术业有专攻
08-17 1万+
广度优先搜索（Breadth-First Search，简称BFS）是一种遍历或搜索树和图的算法，也称为宽度优先搜索，BFS算法从图的某个节点开始，依次对其所有相邻节点进行探索和遍历，然后再对这些相邻节点的相邻节点进行探索，直到遍历完所有的节点。
迷宫问题的递归回溯算法c语言,c语言迷宫问题求解——递归、栈回溯
weixin_36345268的博客
05-23 2042
第一次写，见谅以下是求迷宫的实现为什么下面会出现标签啊，有什么简便的方法去掉吗？求告知最后是关于求所有通路，个人愚笨只想到改变搜索方向顺序这种笨方法，总共有16种不同顺序，有兴趣的小伙伴可以试一下/*第一部分使用递归求解为了数据的简单化，不对路口进行数据结构化，将用一个简单的int类型数组来表示迷宫因为每一个路口的四个方向相对于当前路口的位移都是一样的，这样可以用一个int类型二位数据表示四个方向...
C语言求解迷宫问题（顺序栈）
墨城烟柳ベ旧人殇的博客
04-13 3478
本文主要锻炼栈的相关操作 ，并使用完成迷宫求解问题。
C语言 迷宫问题求解（顺序栈应用示例）
热门推荐
思考的力量
12-07 3万+
//顺序栈的应用：迷宫 //作者：nuaazdh //时间：2011年12月7日 #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10
迷宫问题——栈实现（C语言）（数据结构与算法）
qq_46490027的博客
11-08 2万+
本文用栈解决迷宫问题，采用C语言实现，包括问题介绍、算法简介、求解过程、代码实现、结果展示。并附有完整代码。
【C语言】—— 数据结构与算法基础学习
m0_55124878的博客
11-19 1840
这篇博客是我学数据结构随便写写的，就当笔记记的，不要太较真，中间也有好多知识点没写。 数据结构概述 定义 我们如何把大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应的操作，这个相应的操作也叫做算法。 数据结构 = 个体 + 个体的关系 算法 = 对存储数据的操作 算法 解题的方法和步骤 衡量算法的标准： 1.时间复杂度 大概程序要执行的次数，而非执行时间。
数据结构栈——迷宫寻路，C语言（栈）
rabbit_hxh的博客
10-14 1272
记录自己的学习数据结构（C语言版-严蔚敏）的历程 按照书上写的补全，望指教 1.常量声明 constant.h #define TRUE 1 #define FALSE 2 #define OK 3 #define ERROR 4 #define INFEASIBLE 5 #define OVERFLOW 6 栈的基本操作(Get略改动) Stack.h #include "constant.h...
数据结构--栈-C语言实现迷宫求解
qq_43534244的博客
09-14 2818
数据结构–栈C语言实现迷宫求解 前言 代码主要根据《数据结构》（C语言版）严蔚敏提供的C语言伪代码而写，改变了其中的一些小细节。提供这个代码主要不是学习栈，而是学习穷举迷宫求解算法，另外代码中用到了二级指针，必须要对指针熟悉才行。 运行的时候可以改变**“00_stack_maze.h”**中的相关参数来改变迷宫的规模以及迷宫中障碍的数量，开始可以调得小一些。 程序是每个两秒打印一次，程序中的方向用每个方向英文单词首字母表示。 另外推荐学习视频是B站的数据结构官方视频，最后如果觉得代码可读性很差或者有错误
数据结构基础与算法图解（3）—— 栈
zyw2002的博客
05-10 795
文章目录3. 栈3.1 栈的逻辑结构3.1.1 例题3.2 栈的顺序存储表示3.2.1例题3.3 栈的应用3.3.1 编辑命令行3.3.1.1 例题3.3.2 数值转换3.3.3 括号匹配3.3.3.1 例题3.3.4 迷宫求解3.3.5 表达式求值3.3.5.1 前缀表达式3.3.5.2 中缀表达式3.3.5.3 后缀表达式3.4 用栈实现递归3.5八皇后问题3.6 四色问题 3. 栈 3.1 栈的逻辑结构 栈是限定插入和删除只能在“固定端”进行的线性表。 ADT Stack{ 数据对象：
数据结构与算法基础课程 C语言C++程序语言设计教程 3_1栈和队列 共29页.pptx
07-20
### 数据结构与算法基础课程——栈和队列 #### 栈(Stack) 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作。这一端被称为栈顶(top)，而另一端被称为栈底(bottom)。栈的特点是“后进先出”(Last In First ...
数据结构(C语言) - 迷宫求解 - 顺序栈
06-23
在本项目中，我们关注的是一个特定的数据结构——顺序栈，以及如何利用它来解决迷宫求解问题。顺序栈是一种线性数据结构，它的元素按顺序排列，操作主要涉及在栈顶进行插入（压栈）和删除（弹栈）。 首先，让我们...
数据结构（C语言）代码实现（八）——顺序栈实现&数值转换&行编辑程序&括号分配&汉诺塔
weixin_74746867的博客
02-08 1305
接着打开LineEdit.cpp。右键点击源文件，在添加中找到现有项，点击现有项寻找即可（前提是你写了）这里课本的代码没有用栈实现递归，但一直在强调递归函数是通过栈实现的，并从栈的角度解释了递归函数的原理。从元素个数看，结果正确，但不直观，所以将SElemType改为char类型。源文件SqStack.cpp是头文件SqStack.h的实现。为了实现行编辑程序，特别修改两处代码（仅在行编辑程序中使用）。源文件test.cpp ，这个是我复制粘贴的我参考的博客。右键conversion.cpp，点击移除。
使用 C 语言做应用开发的注意事项
Sun_Seeker的博客
05-24 973
笔者在基于 C 语言开发 EdgeX Foundry 设备服务实践之中，遇到如 全局变量的使用、.c 模块文件的划分、多线程编程注意事项、深浅拷贝问题 以及 编译链接时的多重定义问题。本文将对其展开讨论，并提供具体的代码示例和实用建议。
如何选择支持AI接入的开发语言与框架
分享大数据、人工智能领域原创文章
05-24 1244
维度生态成熟度⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐模型对接能力⭐⭐⭐⭐⭐⭐⭐⭐⭐异步任务能力⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐部署灵活性⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐学习成本⭐⭐⭐⭐⭐⭐⭐典型应用模型封装、特征处理业务接入、流程整合网关中转、轻服务。
2025上半年软考高级系统架构设计师经验分享
最新发布
bobshui的博客
05-27 1045
1.这个考试基本不需要脑子，没有临场状态的概念，会就是会，不会就是不会。2.前期准备一定是越充分越好，死记硬背的越多越好；你实际工作中的经验，在考试前两项中起到的作用不大，裸考过很有难度，知识基本是脱产的；3.论文背一两个模板就行了，主要是题目概念要理解对，对于有实际项目经验的友友，基于自己的一个大型项目套套娃就行，实在套不上就假装自己做了嘛，问题不大；4.当天无论状态多差，都建议各位友友去一趟，尤其是第一次，体验一下，不要随便鸽了。
Redis7 新增数据结构深度解析：ListPack 的革新与优化
希望我的博客，能帮上你解决学习中工作中所遇到的问题,也期待与您一起探讨技术问题，共同成长。
05-23 923
Redis 7.0引入了ListPack作为新一代序列化格式，替代了传统的ZipList，成为字符串、哈希、有序集合等数据类型的底层存储引擎。ListPack通过扁平化内存布局、高效的增删操作、优化的遍历机制和兼容性设计，显著提升了内存效率和访问速度。
数据结构 -- 交换排序（冒泡排序和快速排序）
2202_75324779的博客
05-23 407
注：408原题中说，对所有尚未确定最终位置的所有元素进行⼀遍处理称为“⼀趟”排序，因此⼀次“划分”≠⼀趟排序。若每⼀次选中的“枢轴”将待排序序列划分为很不均匀的两个部分，则会导致递归深度增加，算法效率变低。基于“交换”的排序：根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置。若每⼀次选中的“枢轴”将待排序序列划分为均匀的两个部分，则递归深度最⼩，算法效率最⾼。⼀次划分可以确定⼀个元素的最终位置，而⼀趟排序也许可以确定多个元素的最终位置。时间复杂度=O(n*递归层数)
【数据结构 -- AVL树】用golang实现AVL树
2401_87046050的博客
05-20 1178
什么是AVL树，AVL树的思想，以及如何用go语言实现AVL树
【数据结构】
2501_92129429的博客
05-23 297
前引：今天学习的双链表属于链表结构中最复杂的一种（带头双向循环链表），按照安排，我们会先进行复习，如何实现双链表，如基本的头插、头删、尾删、尾插，掌握每个细节，随后进行例题练习，帮助我们了解它的实际挑战，前面的实现只是了解它结构的入门，当然只有打好基础才是最重要的，小编会仔细讲解它的各个环节，正文开始~原文链接：https://blog.youkuaiyun.com/Dovis5884/article/details/147252867。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小丶象

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

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

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

打赏作者

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

抵扣说明：

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

余额充值