广东计算机专升本计算机科目（C语言+数据结构）第三篇一文吃透广东计算机专升本计算机科目（C语言+数据结构）第三篇：非线性

一文吃透广东计算机专升本计算机科目（C语言+数据结构）第三篇：非线性结构全考点+查找排序算法+备考全攻略+升学规划指南

在前两篇系列文章中，我们完整拆解了广东专升本《计算机基础与程序设计》统考科目的考情规则，覆盖了C语言从基础语法、核心进阶到指针、结构体的全体系考点，同时完成了数据结构基础概念、线性表、栈与队列等线性结构的全考点拆解。作为本系列的收官篇，我们将攻克这门科目最核心的拉分壁垒——非线性数据结构（树、图）、查找算法、排序算法，这三大模块占了数据结构60%以上的分值，更是综合应用题的固定出题点，是区分高分段与中分段的核心分水岭。

同时，本篇会给大家一套完整的、贴合广东专升本考情的全科目备考全攻略，从基础入门到考前冲刺，覆盖零基础到高分突破的全周期规划。最后，我会针对大家最关心的「考上之后的路该怎么走」，分别给出公办院校、民办院校的学习规划，区分计算机专业与非计算机专业的发展路径，以及专业选择的核心建议，给正在奋力备考的你，一份清晰的升学后成长指南。

本系列三篇内容完整规划回顾：

第一篇：考情全解析+C语言基础到核心语法体系（基础概念、数据类型、运算符、三大程序结构、数组与字符串）
第二篇：C语言进阶核心语法（函数、指针、结构体、编译预处理与文件操作）+数据结构基础与线性结构全考点
第三篇（本篇）：数据结构非线性结构（树、图）全考点+查找与排序算法全拆解+全科目备考全攻略+升学规划指南

无论你是刚结束基础阶段的学习，即将进入算法专项强化，还是已经进入刷题冲刺阶段，这篇文章都能帮你精准抓住算法考点的核心逻辑，搭建完整的知识体系，拿下综合应用题的高分。

第一部分：数据结构非线性结构全考点拆解

线性结构的核心是「一对一」的线性关系，而非线性结构的核心是「一对多」「多对多」的复杂关系，其中树是一对多的典型代表，图是多对多的典型代表。这两个模块是广东专升本数据结构的必考核心，尤其是树与二叉树，每年综合应用题必有一道出自这里，必须100%吃透。

模块八：树与二叉树

考情定位

本模块是数据结构的重中之重，每年必考15-20分，全题型覆盖，单项选择题、填空题、程序阅读题、综合应用题均有高频考查。其中二叉树的遍历、哈夫曼树的构建与计算、二叉树的核心性质是综合应用题的固定出题点，几乎每年必考，是必须拿下的核心模块。同时，树的结构也是后续操作系统、数据库、算法设计等专业课程的核心基础，对计算机专业的长期发展至关重要。

核心知识点拆解

1. 树的基本定义与核心术语

树是n(n≥0)个节点组成的有限集合，是一对多的非线性数据结构。当n=0时称为空树；当n>0时，满足两个核心条件：

有且仅有一个特定的、称为**根（Root）**的节点，它没有前驱节点；
除根节点外，其余节点可以分为m(m≥0)个互不相交的有限集合，每个集合本身又是一棵树，称为根节点的子树（SubTree）。

专升本高频考查的核心术语，必须精准理解：

术语	定义
节点的度	一个节点拥有的子树的个数，称为该节点的度
树的度	树中所有节点的度的最大值
叶子节点（终端节点）	度为0的节点，没有子树的节点
分支节点（非终端节点）	度不为0的节点
孩子节点与双亲节点	一个节点的子树的根，称为该节点的孩子节点；对应的，该节点称为孩子节点的双亲节点
兄弟节点	拥有同一个双亲节点的节点，互称为兄弟节点
节点的层次	根节点的层次为1，根的孩子节点层次为2，以此类推
树的深度（高度）	树中节点的最大层次，称为树的深度
森林	m(m≥0)棵互不相交的树的集合，把一棵树的根节点去掉，就得到了森林

2. 二叉树的定义与核心性质（必考，全题型覆盖）

二叉树是n(n≥0)个节点组成的有限集合，它的每个节点最多有两棵子树，且子树有严格的左右之分，顺序不能颠倒，称为左子树和右子树。二叉树不是树的特殊情况，是独立的一种数据结构。

二叉树的五大核心性质（必考，必须背熟，带公式）

性质1：在二叉树的第i层上，最多有 $\boldsymbol{2^{i-1}}$ 个节点（i≥1）。示例：第1层最多1个节点，第2层最多2个，第3层最多4个，以此类推。
性质2：深度为k的二叉树，最多有 $\boldsymbol{2^k - 1}$ 个节点（k≥1）。示例：深度为3的二叉树，最多有 $2^3-1=7$ 个节点。
性质3（超级核心，每年必考）：对任何一棵非空二叉树，若其叶子节点数为 $\boldsymbol{n_0}$ ，度为2的节点数为 $\boldsymbol{n_2}$ ，则恒有： $\boldsymbol{n_0 = n_2 + 1}$ 推导逻辑：二叉树中总节点数 $n = n_0 + n_1 + n_2$ （ $n_1$ 是度为1的节点数）；总分支数 $B = n-1 = n_1 + 2n_2$ ，联立两个式子即可推导出该公式。
性质4：具有n个节点的完全二叉树的深度为 $\boldsymbol{\lfloor \log_2 n \rfloor + 1}$ （ $\lfloor x \rfloor$ 表示向下取整，即不大于x的最大整数）。
性质5：对一棵有n个节点的完全二叉树，按层次从上到下、从左到右对所有节点从1到n编号，对任意编号为i的节点，有：
1. 若i=1，则该节点是根节点，无双亲；若i>1，则其双亲节点的编号为 $\lfloor i/2 \rfloor$ 。
2. 若2i > n，则该节点无左孩子；否则其左孩子节点的编号为2i。
3. 若2i+1 > n，则该节点无右孩子；否则其右孩子节点的编号为2i+1。

两种特殊的二叉树（选择题高频考点）

满二叉树：深度为k，且有 $2^k -1$ 个节点的二叉树。满二叉树的每一层都达到了最大节点数，所有分支节点的度都是2，没有度为1的节点，所有叶子节点都在最底层。
完全二叉树：深度为k、有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中编号从1到n的节点一一对应时，称为完全二叉树。核心特性：
- 叶子节点只可能出现在最下面两层；
- 最下层的叶子节点都集中在左侧连续位置；
- 度为1的节点最多有1个，且只有左孩子，没有右孩子；
- 满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。

3. 二叉树的存储结构

二叉树有两种核心存储结构：顺序存储和链式存储，专升本重点考查链式存储，是二叉树算法实现的基础。

（1）顺序存储结构

用一组地址连续的数组存储二叉树的节点，按照层次从上到下、从左到右的顺序存储节点，利用完全二叉树的性质5，通过数组下标确定节点之间的父子关系。

适用场景：仅适合完全二叉树和满二叉树，对于普通二叉树，会造成大量的内存空间浪费。
核心特点：支持随机存取，通过下标直接访问节点，时间复杂度O(1)。

（2）链式存储结构（二叉链表，必考）

二叉树的每个节点用一个结构体表示，包含三个部分：数据域、左孩子指针、右孩子指针。这是二叉树最常用的存储结构，也是专升本算法实现的标准写法。

C语言结构体定义：

// 定义二叉树节点结构体
typedef struct BiTNode
{
    int data;               // 数据域，存储节点数据
    struct BiTNode *lchild; // 左孩子指针，指向左子树的根节点
    struct BiTNode *rchild; // 右孩子指针，指向右子树的根节点
} BiTNode, *BiTree;

其中，BiTNode是节点结构体的别名，BiTree是指向节点的指针类型，BiTree T就定义了二叉树的根指针T，等价于BiTNode *T。

4. 二叉树的遍历（超级核心，综合应用题必考）

二叉树的遍历，是指按照某种固定的顺序，依次访问二叉树中的每一个节点，且每个节点仅访问一次。遍历的核心目的，是把非线性的二叉树结构，转化为线性的节点序列，是二叉树所有操作的基础。

专升本重点考查四种遍历方式：前序遍历、中序遍历、后序遍历、层次遍历，其中前三种统称为深度优先遍历（DFS），层次遍历称为广度优先遍历（BFS）。

我们以下面这棵二叉树为例，讲解四种遍历的规则与结果：

（1）前序遍历（根-左-右）

遍历规则：先访问根节点，再前序遍历左子树，最后前序遍历右子树。

示例遍历结果：1 2 4 5 3 6

递归实现代码（C语言，必考）：

// 二叉树前序遍历，递归实现
void PreOrderTraverse(BiTree T)
{
    if(T == NULL) // 递归终止条件：空树
        return;
    printf("%d ", T->data); // 1. 访问根节点
    PreOrderTraverse(T->lchild); // 2. 前序遍历左子树
    PreOrderTraverse(T->rchild); // 3. 前序遍历右子树
}

（2）中序遍历（左-根-右）

遍历规则：先中序遍历左子树，再访问根节点，最后中序遍历右子树。

示例遍历结果：4 2 5 1 3 6

递归实现代码（C语言，必考）：

// 二叉树中序遍历，递归实现
void InOrderTraverse(BiTree T)
{
    if(T == NULL)
        return;
    InOrderTraverse(T->lchild); // 1. 中序遍历左子树
    printf("%d ", T->data);     // 2. 访问根节点
    InOrderTraverse(T->rchild); // 3. 中序遍历右子树
}

（3）后序遍历（左-右-根）

遍历规则：先后序遍历左子树，再后序遍历右子树，最后访问根节点。

示例遍历结果：4 5 2 6 3 1

递归实现代码（C语言，必考）：

// 二叉树后序遍历，递归实现
void PostOrderTraverse(BiTree T)
{
    if(T == NULL)
        return;
    PostOrderTraverse(T->lchild); // 1. 后序遍历左子树
    PostOrderTraverse(T->rchild); // 2. 后序遍历右子树
    printf("%d ", T->data);       // 3. 访问根节点
}

（4）层次遍历

遍历规则：按照节点的层次，从上到下、同一层从左到右依次访问节点，需要借助队列实现，这是队列的经典应用场景。

示例遍历结果：1 2 3 4 5 6
核心实现逻辑：
1. 根节点入队；
2. 队列不为空时，出队队头节点，访问该节点；
3. 若该节点有左孩子，左孩子入队；若有右孩子，右孩子入队；
4. 重复步骤2-3，直到队列为空。

（5）高频考点：由遍历序列还原二叉树

专升本高频选择题、应用题考点：已知中序遍历序列 + 前序/后序/层次遍历序列中的任意一个，可以唯一确定一棵二叉树。注意：仅已知前序和后序序列，无法唯一确定二叉树。

解题核心逻辑：

前序序列的第一个元素，是二叉树的根节点；
后序序列的最后一个元素，是二叉树的根节点；
在中序序列中，根节点左边的元素是左子树的节点，右边的元素是右子树的节点；
递归拆解左右子树，即可还原整棵二叉树。

5. 线索二叉树

线索二叉树的核心作用，是利用二叉链表中的空指针域，存放节点在某种遍历序列中的前驱和后继指针，避免递归遍历的栈开销，加快遍历速度。

核心考点：n个节点的二叉链表，有n+1个空指针域，全部用来存放线索；
分类：前序线索二叉树、中序线索二叉树、后序线索二叉树，其中中序线索二叉树最常用；
考查形式：以选择题为主，仅需掌握核心概念与特性，无需掌握代码实现。

6. 树、森林与二叉树的转换

树和森林都可以唯一地转换为对应的二叉树，核心规则如下：

树转二叉树：
- 加线：所有兄弟节点之间加一条连线；
- 去线：对每个节点，只保留它与第一个孩子节点的连线，删除与其他孩子节点的连线；
- 调整：以根节点为轴心，顺时针旋转45度，形成二叉树结构。
- 核心特性：树转换后的二叉树，根节点没有右子树。
森林转二叉树：
- 先把森林中的每一棵树都转换为二叉树；
- 第一棵二叉树的根作为整个二叉树的根，后一棵二叉树的根作为前一棵二叉树根的右孩子，依次连接。
二叉树还原为树/森林：上述转换的逆过程。

本部分以选择题考查为主，掌握转换规则即可。

7. 哈夫曼树（最优二叉树）与哈夫曼编码（必考综合应用题）

哈夫曼树是专升本综合应用题的高频考点，几乎每年都会出一道计算或构建题，难度低，属于必须拿满分的题型。

核心概念与公式

路径与路径长度：从树中一个节点到另一个节点之间的分支构成的通路，称为路径；路径上的分支数目，称为路径长度。
树的路径长度：从树根到每一个叶子节点的路径长度之和。
节点的带权路径长度（WPL）：从根节点到该节点的路径长度，乘以该节点的权值，记作WPL。
树的带权路径长度：树中所有叶子节点的带权路径长度之和，公式为： $\boldsymbol{WPL = \sum_{i=1}^n w_i l_i}$ 其中， $w_i$ 是第i个叶子节点的权值， $l_i$ 是该叶子节点的路径长度。
哈夫曼树（最优二叉树）：给定n个权值作为n个叶子节点，构造一棵二叉树，若该树的带权路径长度WPL最小，则称这棵二叉树为哈夫曼树。

哈夫曼树的构建步骤（必考）

给定n个权值 $\{w_1, w_2, ..., w_n\}$ ，构建哈夫曼树的步骤：

将这n个权值分别作为n个只有根节点的二叉树，构成一个森林F；
在森林F中，选出两棵根节点权值最小的二叉树，作为左、右子树，构建一棵新的二叉树，新二叉树的根节点权值为左、右子树根节点权值之和；
从森林F中删除这两棵树，把新构建的二叉树加入森林F中；
重复步骤2和3，直到森林F中只剩下一棵二叉树，这棵树就是哈夫曼树。

核心特性：

哈夫曼树中没有度为1的节点，所有节点的度要么是0，要么是2；
n个叶子节点的哈夫曼树，总节点数为2n-1；
权值越大的叶子节点，离根节点越近；权值越小的叶子节点，离根节点越远，保证WPL最小。

哈夫曼编码

哈夫曼编码是哈夫曼树的经典应用，是一种无损数据压缩编码，核心原理是：对出现频率高的字符，分配短的编码；对出现频率低的字符，分配长的编码，从而实现数据压缩。

构建规则：

将字符的出现频率作为权值，构建哈夫曼树；
对哈夫曼树的每个分支，左分支标记为0，右分支标记为1；
从根节点到叶子节点的路径上的0/1序列，就是该叶子节点对应字符的哈夫曼编码。

核心特性：哈夫曼编码是前缀编码，即任何一个字符的编码，都不是另一个字符编码的前缀，保证解码时不会出现歧义。

高频考点真题例题

例1（2025年广东专升本真题·单选题） 已知一棵二叉树的叶子节点数为10，则该二叉树中度为2的节点数为（） A. 8 B. 9 C. 10 D. 11 解：正确答案是B。根据二叉树性质3， $n_0 = n_2 + 1$ ，所以 $n_2 = n_0 -1 = 10-1=9$ 。

例2（2024年广东专升本真题·综合应用题） 给定权值集合{5, 9, 12, 13, 16, 45}，构建对应的哈夫曼树，计算该树的带权路径长度WPL，并给出权值5和45的哈夫曼编码。解：

哈夫曼树构建步骤：
- 第一步：选最小的两个权值5和9，构建新节点14，森林变为{12,13,14,16,45}
- 第二步：选最小的两个权值12和13，构建新节点25，森林变为{14,16,25,45}
- 第三步：选最小的两个权值14和16，构建新节点30，森林变为{25,30,45}
- 第四步：选最小的两个权值25和30，构建新节点55，森林变为{45,55}
- 第五步：选45和55，构建根节点100，哈夫曼树构建完成。
计算WPL： $WPL = 45\times1 + 16\times3 + 13\times3 + 12\times3 + 9\times4 +5\times4 = 224$
哈夫曼编码（左0右1）：
- 权值5的编码：1111
- 权值45的编码：0

易错点避雷

二叉树的左右子树有严格的顺序，不能颠倒，即使只有一棵子树，也要区分是左子树还是右子树，这是二叉树和普通树的核心区别。
二叉树性质3的公式是 $n_0 = n_2 +1$ ，不是 $n_0 = n_2$ ，也不是 $n_0 = n_1 +1$ ，这是选择题的高频陷阱。
只有中序序列+前序/后序/层次序列，才能唯一确定一棵二叉树，仅前序+后序序列无法唯一确定，选择题高频考点。
哈夫曼树构建时，每次必须选权值最小的两棵树，左、右子树的顺序不影响WPL的计算，但会影响哈夫曼编码的结果，通常约定左小右大。
哈夫曼树中没有度为1的节点，n个叶子节点的哈夫曼树，总节点数一定是2n-1，这个结论常用于快速验证构建的树是否正确。
二叉树的递归遍历，必须有明确的终止条件（T==NULL），否则会导致无限递归，栈溢出程序崩溃。

模块九：图

考情定位

本模块是数据结构中最复杂的非线性结构，每年必考8-10分，以单项选择题、填空题为主，偶尔会在综合应用题中考查简单的算法原理，难度中等。广东专升本对图的考查以基础概念、存储结构、遍历方法和核心应用为主，不会考查过于复杂的代码实现，重点掌握核心原理和步骤即可，属于投入少量精力就能拿满分数的模块。

核心知识点拆解

1. 图的基本定义与核心术语

图是由顶点集V和边集E组成的二元组，记作 $G=(V,E)$ ，是多对多的非线性数据结构。其中，V是顶点的非空有限集合，E是顶点之间边的有限集合，边集可以为空。

专升本高频考查的核心术语：

无向图与有向图：
- 无向图：边没有方向，顶点v和w之间的边用无序对 $(v,w)$ 表示， $(v,w)$ 和 $(w,v)$ 是同一条边；
- 有向图：边有方向（也叫弧），从顶点v到顶点w的弧用有序对 $<v,w>$ 表示，v称为弧尾，w称为弧头， $<v,w>$ 和 $<w,v>$ 是两条不同的弧。
完全图：
- 无向完全图：n个顶点的无向图，任意两个顶点之间都有一条边，总边数为 $\boldsymbol{n(n-1)/2}$ ；
- 有向完全图：n个顶点的有向图，任意两个顶点之间都有方向相反的两条弧，总边数为 $\boldsymbol{n(n-1)}$ 。
顶点的度：
- 无向图中，顶点v的度是依附于该顶点的边的数目，记作TD(v)。n个顶点、e条边的无向图，满足 $\sum_{i=1}^n TD(v_i) = 2e$ ，所有顶点的度之和是边数的2倍；
- 有向图中，顶点v的度分为入度ID(v)和出度OD(v)：入度是指向该顶点的弧的数目，出度是从该顶点出发的弧的数目，顶点的度TD(v)=ID(v)+OD(v)。n个顶点、e条边的有向图，满足 $\sum_{i=1}^n ID(v_i) = \sum_{i=1}^n OD(v_i) = e$ 。
路径与回路：
- 路径：从顶点v到顶点w的路径，是顶点序列，路径上边的数目称为路径长度；
- 回路（环）：第一个顶点和最后一个顶点相同的路径，称为回路。
连通图与连通分量：
- 无向图中，若顶点v和w之间有路径，则称v和w是连通的。若图中任意两个顶点都是连通的，则称该图为连通图；
- 无向图中的极大连通子图，称为该图的连通分量，连通图的连通分量就是它本身，非连通图有多个连通分量。
强连通图与强连通分量：
- 有向图中，若任意两个顶点v和w之间，从v到w、从w到v都有路径，则称该图为强连通图；
- 有向图中的极大强连通子图，称为该图的强连通分量。
权与网：
- 给图的边赋予一个具有某种意义的数值，这个数值称为权，权可以表示距离、时间、代价等；
- 带权的图称为网，分为无向网和有向网。

2. 图的存储结构（必考）

广东专升本重点考查两种核心存储结构：邻接矩阵和邻接表，必须掌握两种存储的结构、特点、适用场景和构建方法。

（1）邻接矩阵

邻接矩阵是用一个二维数组来表示图中顶点之间的邻接关系，是图的顺序存储结构。

定义：设图G有n个顶点，则邻接矩阵是一个n×n的方阵 $A$ ，其中：
1. 无向图的邻接矩阵： $A[i][j] = \begin{cases} 1, & \text{若}(v_i, v_j) \in E \\ 0, & \text{其他} \end{cases}$
2. 有向图的邻接矩阵： $A[i][j] = \begin{cases} 1, & \text{若}<v_i, v_j> \in E \\ 0, & \text{其他} \end{cases}$
3. 带权网的邻接矩阵： $A[i][j] = \begin{cases} w_{ij}, & \text{若}<v_i, v_j> \text{或}(v_i, v_j) \in E \\ \infty, & \text{若}i \neq j \text{且边不存在} \\ 0, & \text{若}i = j \end{cases}$ 其中 $w_{ij}$ 是边的权值， $\infty$ 表示无穷大，代表边不存在。
核心特性：
1. 无向图的邻接矩阵是对称矩阵，主对角线为0；有向图的邻接矩阵不一定对称；
2. 无向图中，顶点 $v_i$ 的度等于邻接矩阵第i行（第i列）的元素之和；
3. 有向图中，顶点 $v_i$ 的出度等于第i行的元素之和，入度等于第i列的元素之和；
4. 优点：支持随机存取，判断两个顶点之间是否有边的时间复杂度O(1)，实现简单；
5. 缺点：空间复杂度为 $O(n^2)$ ，对于稀疏图（边数远小于 $n^2$ ），会造成大量的空间浪费。
适用场景：适合顶点数不多的稠密图。

（2）邻接表

邻接表是图的链式存储结构，对图中的每个顶点，建立一个单链表，存储该顶点的所有邻接顶点，称为边链表；所有顶点的头节点组成一个数组，称为顶点表。

C语言结构体定义：

#define MAXVEX 100 // 最大顶点数
// 边链表节点结构
typedef struct EdgeNode
{
    int adjvex;               // 邻接点的索引，即该顶点在顶点表中的下标
    int weight;               // 边的权值，无权图可省略
    struct EdgeNode *nextarc; // 指向下一个边节点的指针
} EdgeNode;

// 顶点表节点结构
typedef struct VexNode
{
    int data;         // 顶点的数据
    EdgeNode *firstarc; // 指向边链表的头指针
} VexNode, AdjList[MAXVEX];

// 图的邻接表结构
typedef struct
{
    AdjList adjList;
    int numVex, numEdge; // 图的顶点数和边数
} GraphAdjList;

核心特性：
1. 无向图的邻接表中，每条边会被存储两次（分别在两个顶点的边链表中），总边节点数为2e；有向图的邻接表中，总边节点数为e；
2. 无向图中，顶点的度等于该顶点边链表的节点个数；
3. 有向图中，顶点的出度等于该顶点边链表的节点个数，入度需要遍历整个邻接表统计；
4. 优点：空间复杂度为 $O(n+e)$ ，对于稀疏图，极大节省存储空间；
5. 缺点：判断两个顶点之间是否有边，需要遍历对应顶点的边链表，时间复杂度最坏为O(n)，不如邻接矩阵方便。
适用场景：适合顶点数多、边数少的稀疏图。

3. 图的遍历（核心考点）

图的遍历是指从图中的某一个顶点出发，按照某种规则访问图中的所有顶点，且每个顶点仅访问一次。图的遍历有两种核心方法：深度优先搜索（DFS）和广度优先搜索（BFS），是图所有算法的基础，也是选择题、应用题的高频考点。

（1）深度优先搜索（DFS，Depth First Search）

深度优先搜索的核心思想是**“一路走到底，走不通再回溯”**，类似于树的前序遍历，是递归的过程。

遍历步骤（以邻接表存储的无向图为例）：

访问起始顶点v，标记为已访问；
找到v的第一个未被访问的邻接顶点w，以w为新的起始顶点，递归执行深度优先搜索；
若v的所有邻接顶点都已被访问，则回溯到上一个顶点，继续搜索；
重复上述步骤，直到所有和起始顶点连通的顶点都被访问。

核心特性：

采用递归实现，需要借助栈来保存递归路径；
遍历序列不唯一，取决于邻接表中顶点的存储顺序；
时间复杂度：邻接矩阵存储为 $O(n^2)$ ，邻接表存储为 $O(n+e)$ ；
空间复杂度： $O(n)$ ，主要是递归栈的开销。

（2）广度优先搜索（BFS，Breadth First Search）

广度优先搜索的核心思想是**“先访问完当前层的所有顶点，再访问下一层”，类似于树的层次遍历，需要借助队列**实现。

遍历步骤：

访问起始顶点v，标记为已访问，将v入队；
队列不为空时，出队队头顶点u；
依次访问u的所有未被访问的邻接顶点，标记为已访问，依次入队；
重复步骤2-3，直到队列为空。

核心特性：

采用队列实现，是非递归的过程；
遍历序列不唯一，取决于邻接表中顶点的存储顺序；
时间复杂度：和DFS一致，邻接矩阵 $O(n^2)$ ，邻接表 $O(n+e)$ ；
空间复杂度： $O(n)$ ，主要是队列的开销。

4. 图的经典应用（必考选择题、应用题）

广东专升本重点考查图的四大经典应用，只需掌握算法的核心原理、适用场景和执行步骤，无需掌握完整的代码实现。

（1）最小生成树

对于一个带权的无向连通图，它的生成树是包含图中所有n个顶点的极小连通子图，生成树有且仅有n-1条边。带权连通图的所有生成树中，带权路径长度之和最小的生成树，称为最小生成树（MST）。

最小生成树的两个核心算法：

Prim算法（普里姆算法）
- 核心思想：加点法，从一个起始顶点出发，每次选择一个与当前生成树集合距离最近的顶点，加入生成树，直到所有顶点都加入。
- 步骤：
  1. 初始化两个集合U（已加入生成树的顶点）和V-U（未加入的顶点），U初始化为起始顶点；
  2. 在U和V-U之间的所有边中，选择权值最小的边，将对应的顶点加入U；
  3. 重复步骤2，直到U包含所有n个顶点。
- 时间复杂度： $O(n^2)$ ，与边数无关；
- 适用场景：适合顶点数少的稠密图。
Kruskal算法（克鲁斯卡尔算法）
- 核心思想：加边法，将图中的所有边按权值从小到大排序，依次选择边，保证选中的边不会形成回路，直到选中n-1条边，构成最小生成树。
- 步骤：
  1. 将图中的所有边按权值升序排序；
  2. 初始化n个连通分量，每个顶点是一个独立的连通分量；
  3. 按权值从小到大遍历边，若该边的两个顶点属于不同的连通分量，则选中这条边，合并两个连通分量；
  4. 重复步骤3，直到选中n-1条边。
- 时间复杂度： $O(e \log e)$ ，与边数e相关；
- 适用场景：适合边数少的稀疏图。

核心结论：一个带权连通图的最小生成树可能不唯一，但最小生成树的总权值一定是唯一的。

（2）最短路径

最短路径是指带权图中，两个顶点之间的路径中，权值之和最小的路径，分为两种场景：单源最短路径和所有顶点对之间的最短路径。

Dijkstra算法（迪杰斯特拉算法）
- 核心作用：求带权有向图中，从一个源点到其他所有顶点的单源最短路径，要求图中所有边的权值非负。
- 核心思想：贪心算法，每次从未确定最短路径的顶点中，选择距离源点最近的顶点，加入已确定集合，然后更新其他顶点到源点的距离，直到所有顶点都加入。
- 时间复杂度： $O(n^2)$ 。
Floyd算法（弗洛伊德算法）
- 核心作用：求带权图中所有顶点对之间的最短路径，允许边的权值为负，但不能有负权回路。
- 核心思想：动态规划，通过中间顶点的迭代，逐步更新任意两个顶点之间的最短路径。
- 时间复杂度： $O(n^3)$ ；
- 优点：实现简单，代码量极少，适合顶点数少的图。

（3）拓扑排序

拓扑排序是对**有向无环图（DAG）**的顶点进行排序，使得对于图中任意一条弧 $<v,w>$ ，顶点v在排序序列中一定出现在顶点w的前面。拓扑排序主要用于解决有先后依赖关系的任务调度问题，比如课程安排、工程进度规划。

拓扑排序的步骤：

在有向无环图中，找到一个入度为0的顶点，输出该顶点；
删除该顶点，以及从该顶点出发的所有弧，更新对应顶点的入度；
重复步骤1和2，直到图中所有顶点都被输出，或者图中不存在入度为0的顶点（说明图中有环，无法拓扑排序）。

核心结论：有向无环图一定存在拓扑排序，有环的有向图无法进行拓扑排序；拓扑排序的序列不一定唯一。

（4）关键路径

关键路径是针对带权有向无环的AOE网（Activity On Edge，边表示活动，顶点表示事件）的应用，核心是求整个工程的最短完成时间，以及决定工程工期的关键活动。

关键路径：AOE网中，从源点到汇点的最长路径，称为关键路径，关键路径的长度就是整个工程的最短完成时间；
关键活动：关键路径上的活动，关键活动的延期会导致整个工程的延期；
考查形式：以选择题为主，掌握核心概念即可，无需深入计算。

高频考点真题例题

例1（2025年广东专升本真题·单选题） 一个有n个顶点的无向连通图，它的最小生成树包含的边数为（） A. n B. n-1 C. n+1 D. 2n 解：正确答案是B。生成树包含图中所有n个顶点，且是极小连通子图，边数一定是n-1。

例2（2024年广东专升本真题·单选题） 以下关于图的遍历的说法，正确的是（） A. 深度优先搜索只能用于无向图，不能用于有向图 B. 广度优先搜索需要借助栈实现，深度优先搜索需要借助队列实现 C. 连通图的一次深度优先搜索，可以访问到图中的所有顶点 D. 图的遍历序列是唯一的，与存储结构无关解：正确答案是C。

A选项：DFS和BFS对无向图和有向图都适用；
B选项：BFS借助队列，DFS借助栈，说法颠倒；
D选项：遍历序列不唯一，与存储结构和遍历顺序相关。

易错点避雷

无向图的总度数是边数的2倍，有向图的入度之和等于出度之和等于边数，这是选择题的高频计算考点，不能搞混。
邻接矩阵中，无向图的矩阵是对称的，有向图不一定对称；无向图的边会在两个位置存储，邻接表中也是如此。
Dijkstra算法不能处理带负权边的图，Floyd算法可以处理负权边，但不能处理有负权回路的图，这是高频易错点。
拓扑排序只能针对有向无环图，有环的有向图无法进行拓扑排序，拓扑排序的序列不一定唯一。
最小生成树的总权值是唯一的，但生成树的形态可能不唯一，只要总权值最小即可。
图的遍历必须标记已访问的顶点，否则会出现重复访问、死循环的问题。

第二部分：查找与排序算法全考点拆解

查找和排序是数据结构的核心算法，是广东专升本考试的绝对重点，每年必考18-25分，全题型覆盖，尤其是排序算法，是程序阅读题、编程题、综合应用题的高频出题点。这两个模块的算法逻辑清晰、考点固定、套路性强，只要掌握核心原理和代码实现，就能轻松拿满分数。

模块十：查找算法

考情定位

本模块每年必考8-10分，单项选择题、填空题、综合应用题均有涉及，核心考查平均查找长度ASL的计算、折半查找的算法与判定树、哈希表的构建与冲突处理，其中折半查找和哈希表是综合应用题的高频考点，难度中等，属于必须拿分的模块。

查找的核心定义：根据给定的关键字，在查找表中确定一个关键字等于给定值的元素的过程。查找算法的核心评价指标是平均查找长度ASL，即查找过程中关键字的平均比较次数，公式为：

\boldsymbol{ASL = \sum_{i=1}^n P_i C_i}

其中， $P_i$ 是查找第i个元素的概率，通常默认等概率查找， $P_i=1/n$ ； $C_i$ 是查找第i个元素时需要的比较次数。

核心知识点拆解

1. 线性表的查找

线性表的查找分为三种：顺序查找、折半查找、分块查找，其中折半查找是必考核心。

（1）顺序查找（线性查找）

顺序查找是最简单的查找算法，核心思想是：从线性表的一端开始，依次将每个元素的关键字与给定值比较，找到匹配的元素则查找成功，遍历完所有元素都没找到则查找失败。

适用场景：顺序存储和链式存储的线性表都适用，对表中元素的顺序没有要求。
平均查找长度：等概率情况下，查找成功的 $ASL=(n+1)/2$ ；查找失败的 $ASL=n$ 。
时间复杂度：最好情况O(1)，最坏情况O(n)，平均时间复杂度O(n)。
优点：实现简单，对表结构无要求；缺点：平均查找长度大，效率低，不适合大规模数据。

（2）折半查找（二分查找，超级核心，必考）

折半查找是效率极高的查找算法，核心思想是分治，但有两个严格的前提条件：

线性表必须采用顺序存储结构；
表中的元素必须按关键字有序排列（升序或降序）。

折半查找的核心步骤（以升序排列的线性表为例）：

初始化两个指针low和high，low指向表的第一个元素，high指向表的最后一个元素；
计算中间位置mid = $\lfloor (low + high)/2 \rfloor$ ；
比较mid位置的元素关键字与给定值key：
- 若相等，查找成功，返回mid；
- 若key < mid位置的关键字，说明目标元素在左半区，令high = mid - 1，重复步骤2；
- 若key > mid位置的关键字，说明目标元素在右半区，令low = mid + 1，重复步骤2；
当low > high时，查找失败，返回-1。

C语言实现代码（必考）：

// 折半查找，升序数组arr，长度n，查找关键字key，找到返回下标，失败返回-1
int BinarySearch(int arr[], int n, int key)
{
    int low = 0, high = n-1, mid;
    while(low <= high)
    {
        mid = (low + high) / 2; // 计算中间位置
        if(arr[mid] == key)
        {
            return mid; // 查找成功
        }
        else if(key < arr[mid])
        {
            high = mid - 1; // 左半区查找
        }
        else
        {
            low = mid + 1; // 右半区查找
        }
    }
    return -1; // 查找失败
}

折半查找判定树：折半查找的过程可以用一棵二叉树来描述，称为判定树。判定树的每个节点对应表中的一个元素，左子树对应左半区，右子树对应右半区。核心特性：
1. 折半查找的过程，就是从判定树的根节点到目标节点的路径，比较次数等于节点在判定树中的层次；
2. 折半查找判定树是一棵平衡二叉树，深度为 $\lfloor \log_2 n \rfloor + 1$ ；
3. 等概率情况下，查找成功的平均查找长度 $ASL \approx \log_2 (n+1) - 1$ ，时间复杂度O(logn)。
优点：查找效率极高，时间复杂度O(logn)，适合大规模有序数据；缺点：仅适用于有序的顺序表，插入删除需要移动大量元素，不适合频繁变动的表。

（3）分块查找（索引顺序查找）

分块查找是顺序查找和折半查找的结合，核心思想是：将线性表分成若干块，块内元素可以无序，但块之间必须有序（前一块的最大关键字小于后一块的最小关键字）；建立一个索引表，存储每个块的最大关键字和块的起始地址。

查找过程分为两步：

先在索引表中查找，确定目标元素所在的块（可以用折半查找或顺序查找）；
在对应的块内进行顺序查找。

平均查找长度：索引表查找的ASL + 块内查找的ASL；
时间复杂度：介于顺序查找和折半查找之间；
优点：插入删除方便，只需要在对应块内操作，适合数据量大、动态变化的线性表；
考查形式：以选择题为主，掌握核心原理即可。

2. 树表的查找

树表查找的核心是二叉排序树（BST），专升本重点考查其定义、插入、删除、查找和平均查找长度，以选择题为主。

（1）二叉排序树（BST，二叉搜索树）

二叉排序树的定义：一棵空树，或者满足以下条件的二叉树：

若左子树非空，则左子树上所有节点的关键字均小于根节点的关键字；
若右子树非空，则右子树上所有节点的关键字均大于根节点的关键字；
左、右子树也分别是二叉排序树。

核心特性：二叉排序树的中序遍历序列是一个升序的有序序列，这是二叉排序树最核心的性质，也是解题的关键。

查找算法：从根节点开始，若根节点关键字等于目标值，查找成功；若目标值小于根节点关键字，递归查找左子树；否则递归查找右子树。查找成功的比较次数等于节点在树中的层次，最坏情况O(n)（单支树），平均情况O(logn)。
插入算法：二叉排序树的插入节点，一定是作为新的叶子节点插入。先查找插入位置，找到父节点后，作为左孩子或右孩子插入。
删除算法：删除节点分三种情况：
1. 叶子节点：直接删除，修改父节点的指针为空；
2. 只有左子树或只有右子树：删除节点后，将其子树直接挂到父节点的对应位置；
3. 既有左子树又有右子树：用该节点的中序前驱（左子树的最大节点）或中序后继（右子树的最小节点）替换该节点，然后删除对应的前驱/后继节点。

（2）平衡二叉树（AVL树）

平衡二叉树是一种特殊的二叉排序树，核心特性是：树中每个节点的左子树和右子树的高度差（平衡因子）的绝对值不超过1。平衡二叉树的目的是避免二叉排序树退化为单支树，保证查找效率稳定在O(logn)。

考查形式：以选择题为主，掌握平衡因子的计算、平衡调整的核心原理即可，无需掌握具体的旋转代码。

3. 哈希表（散列表）（必考综合应用题）

哈希表是专升本综合应用题的高频考点，几乎每年都会出一道构建哈希表、计算ASL的题目，难度低，属于必须拿满分的题型。

核心概念

哈希表的核心思想是：通过一个哈希函数，将元素的关键字映射为该元素在表中的存储地址，实现O(1)时间复杂度的查找，是典型的空间换时间的算法。

哈希函数：将关键字key转换为存储地址的函数，记作 $Addr = H(key)$ 。
哈希冲突：对于两个不同的关键字 $key_1 \neq key_2$ ，但 $H(key_1) = H(key_2)$ ，这种现象称为哈希冲突。哈希冲突无法完全避免，只能通过合理的哈希函数和冲突处理方法减少。

哈希函数的构造方法

专升本重点考查除留余数法，这是最常用、最常考的哈希函数构造方法。

除留余数法公式： $\boldsymbol{H(key) = key \% p}$ 其中，p是一个不大于哈希表长度m的正整数，通常选择小于等于m的最大质数，这样可以最大程度减少哈希冲突。

处理哈希冲突的方法（必考）

专升本重点考查两种冲突处理方法：开放定址法和链地址法（拉链法），其中链地址法是综合应用题的高频考点。

开放定址法 核心思想：当发生哈希冲突时，按照某种规则，在哈希表中寻找下一个空的地址，直到找到空地址为止。通用公式为：

$H_i = (H(key) + d_i) \% m \quad (i=1,2,...,k, k \leq m-1)$

其中，m是哈希表长度， $d_i$ 是增量序列，根据增量序列的不同，分为三种：
- 线性探测法： $d_i = 0,1,2,...,m-1$ ，冲突时依次向后查找空地址。优点：实现简单；缺点：容易产生堆积现象，导致查找效率下降。
- 二次探测法： $d_i = 0, 1^2, -1^2, 2^2, -2^2,...$ ，避免堆积现象，但不能探测到整个哈希表。
- 伪随机探测法： $d_i$ 是伪随机数序列。
链地址法（拉链法，高频考点） 核心思想：将所有哈希地址相同的元素，存储在同一个单链表中，称为同义词链表；哈希表中存储的是每个链表的头指针。
- 优点：不会产生堆积现象，插入删除操作方便，适合关键字数量不确定的场景；
- 缺点：需要额外的指针存储空间；
- 考查重点：构建哈希表、计算查找成功和查找失败的平均查找长度ASL。

哈希表的平均查找长度

哈希表的查找过程和造表过程一致，先通过哈希函数计算地址，若该地址为空，则查找失败；否则比较关键字，相等则查找成功，不相等则按照冲突处理方法继续查找。

平均查找长度ASL的计算：

查找成功的ASL：所有元素查找成功的比较次数之和，除以元素个数n；
查找失败的ASL：所有可能的哈希地址，查找失败的比较次数之和，除以哈希函数的取值个数p。

高频考点真题例题

例1（2025年广东专升本真题·单选题） 长度为16的有序升序数组，采用折半查找，查找一个不存在的元素，最多需要的比较次数是（） A. 3 B. 4 C. 5 D. 16 解：正确答案是C。折半查找判定树的深度为 $\lfloor \log_2 16 \rfloor +1 = 4+1=5$ ，查找失败最多需要比较5次。

例2（2024年广东专升本真题·综合应用题） 给定关键字序列{19, 14, 23, 1, 68, 20, 84, 27, 55, 11, 10, 79}，哈希函数为 $H(key)=key\%13$ ，采用链地址法处理冲突，要求：

画出对应的哈希表；
计算查找成功的平均查找长度ASL。解：
先计算每个关键字的哈希地址：
- 19%13=6，14%13=1，23%13=10，1%13=1，68%13=3，20%13=7，84%13=6，27%13=1，55%13=3，11%13=11，10%13=10，79%13=1
链地址法构建的哈希表（头节点数组下标0-12）：
- 0：空
- 1：14 → 1 → 27 → 79
- 2：空
- 3：68 → 55
- 4：空
- 5：空
- 6：19 → 84
- 7：20
- 8：空
- 9：空
- 10：23 → 10
- 11：11
- 12：空
查找成功的ASL计算：总比较次数=1(14)+2(1)+3(27)+4(79)+1(68)+2(55)+1(19)+2(84)+1(20)+1(23)+2(10)+1(11) = 25 元素个数n=12，所以 $ASL=25/12$ 。

易错点避雷

折半查找有两个严格的前提条件：顺序存储、元素有序，链式存储的线性表不能使用折半查找，这是选择题的高频陷阱。
折半查找的mid计算是 $\lfloor (low+high)/2 \rfloor$ ，向下取整，且每次调整时，high=mid-1，low=mid+1，不能写成high=mid或low=mid，否则会出现死循环。
二叉排序树的中序遍历序列一定是升序的，这是解题的核心，插入的节点一定是叶子节点，删除节点时要分三种情况处理。
除留余数法中，p通常选择小于等于哈希表长度的最大质数，不能随便选，否则会增加哈希冲突的概率。
链地址法计算查找失败的ASL时，分母是哈希函数的取值个数（即p的大小），不是元素个数，也不是哈希表长度，这是高频易错点。
线性探测法处理冲突时，会产生堆积现象，导致查找效率下降，而链地址法不会产生堆积。

模块十一：内部排序算法

考情定位

本模块是数据结构的核心重点，每年必考10-15分，全题型覆盖，单项选择题、程序阅读题、编程题、综合应用题均有高频考查。排序算法是计算机专业的基础算法，也是专升本编程题的高频出题点，尤其是冒泡排序、快速排序、直接插入排序、简单选择排序，必须能手写完整代码，同时要掌握所有排序算法的时间复杂度、空间复杂度、稳定性和适用场景。

排序的核心定义：将一个无序的元素序列，调整为按关键字有序的序列。排序分为内部排序和外部排序，内部排序是指数据全部在内存中进行的排序，外部排序是指数据量过大，需要借助外存的排序。广东专升本仅考查内部排序，我们将内部排序分为五大类：插入排序、交换排序、选择排序、归并排序、基数排序。

排序算法的核心评价指标：

时间复杂度：排序过程中关键字的比较次数和元素移动次数，是最核心的评价指标；
空间复杂度：排序过程中需要的额外辅助存储空间；
稳定性：若序列中两个元素的关键字相等，排序后它们的相对位置保持不变，则称该排序算法是稳定的；否则是不稳定的。

核心知识点拆解

我们按照专升本的考查优先级，逐一拆解每一种排序算法的核心原理、C语言实现、复杂度分析、稳定性和适用场景。

1. 插入排序

插入排序的核心思想是：将无序序列中的元素，逐个插入到前面已经有序的序列中，直到所有元素都插入完成，整个序列有序。专升本重点考查直接插入排序和希尔排序。

（1）直接插入排序

直接插入排序是最简单的插入排序，核心逻辑类似于我们整理扑克牌，逐张将牌插入到已经排好序的牌堆中。

算法步骤：
1. 将序列的第一个元素视为初始的有序序列；
2. 从第二个元素开始，依次取出当前元素作为待插入元素key；
3. 从后往前遍历有序序列，若有序序列中的元素大于key，则将该元素后移一位；
4. 找到key的插入位置，将key插入；
5. 重复步骤2-4，直到所有元素都插入完成。

C语言实现代码（必考，编程题高频考点）：

// 直接插入排序，升序排列，arr是待排序数组，n是数组长度
void InsertSort(int arr[], int n)
{
    int i, j, key;
    for(i = 1; i < n; i++) // 从第二个元素开始
    {
        key = arr[i]; // 待插入元素
        j = i - 1;
        // 从后往前遍历，元素后移，找插入位置
        while(j >= 0 && arr[j] > key)
        {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key; // 插入元素
    }
}

性能分析：
- 时间复杂度：最好情况（序列已有序）O(n)，最坏情况（序列逆序）O(n²)，平均时间复杂度O(n²)；
- 空间复杂度：O(1)，仅需要一个临时变量，是原地排序；
- 稳定性：稳定排序；
- 适用场景：元素数量少、序列基本有序的场景。

（2）希尔排序（缩小增量排序）

希尔排序是直接插入排序的改进版，核心思想是：将整个序列按增量d划分为若干个子序列，对每个子序列分别进行直接插入排序；然后逐步缩小增量d，重复上述过程；当增量d=1时，对整个序列进行一次直接插入排序，此时序列已经基本有序，直接插入排序的效率极高。

核心特性：
- 时间复杂度：平均O(n^1.3)，最坏O(n²)，优于直接插入排序；
- 空间复杂度：O(1)，原地排序；
- 稳定性：不稳定排序；
- 考查形式：以选择题为主，掌握核心原理和增量序列的变化规则即可，无需掌握代码实现。

2. 交换排序

交换排序的核心思想是：两两比较序列中的元素，若两个元素的顺序不符合要求，则交换它们的位置，直到整个序列有序。专升本重点考查冒泡排序和快速排序，其中快速排序是超级核心，必考编程题和综合应用题。

（1）冒泡排序

冒泡排序是最简单的交换排序，核心思想是：通过相邻元素的两两比较和交换，每一轮将最大的元素“冒泡”到序列的末尾，就像水中的气泡向上浮一样。

算法步骤（升序）：
1. 从序列的第一个元素开始，两两比较相邻的元素，若前一个元素大于后一个元素，则交换两者的位置；
2. 第一轮遍历完成后，最大的元素已经被交换到序列的最后一个位置；
3. 第二轮遍历，对前n-1个元素重复上述过程，将第二大的元素冒泡到倒数第二个位置；
4. 重复上述过程，直到某一轮遍历中没有发生任何交换，说明序列已经有序，提前结束排序。

C语言实现代码（必考，编程题高频考点，带优化）：

// 冒泡排序，升序排列，带提前结束优化
void BubbleSort(int arr[], int n)
{
    int i, j, temp;
    int flag; // 标记本轮是否发生交换
    for(i = 0; i < n-1; i++)
    {
        flag = 0; // 初始化为未交换
        for(j = 0; j < n-1 -i; j++) // 每轮减少i次比较，末尾i个元素已有序
        {
            if(arr[j] > arr[j+1])
            {
                // 交换相邻元素
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                flag = 1; // 标记发生了交换
            }
        }
        if(flag == 0) // 本轮没有交换，序列已有序，提前结束
        {
            break;
        }
    }
}

性能分析：
- 时间复杂度：最好情况（序列已有序，带优化）O(n)，最坏情况（序列逆序）O(n²)，平均时间复杂度O(n²)；
- 空间复杂度：O(1)，原地排序；
- 稳定性：稳定排序；
- 适用场景：元素数量少、序列基本有序的场景。

（2）快速排序（超级核心，必考）

快速排序是专升本考试的重中之重，是所有排序算法中考查频率最高的，编程题、综合应用题几乎每年都会涉及，必须能手写完整代码，理解核心原理。

快速排序的核心思想是分治，通过一趟排序，将序列划分为左右两个部分，其中左半部分的所有元素都小于基准元素，右半部分的所有元素都大于基准元素，然后分别对左右两个部分递归进行快速排序，直到整个序列有序。

算法步骤（升序）：
1. 选基准：在序列中选择一个元素作为基准元素pivot（通常选第一个元素、最后一个元素或中间元素）；
2. 分区（partition）：遍历序列，将所有小于基准的元素放到基准的左边，所有大于基准的元素放到基准的右边，分区完成后，基准元素就处于它最终的有序位置；
3. 递归排序：递归地对基准左边的子序列和右边的子序列，重复上述步骤，直到子序列的长度为0或1（递归终止条件）。

C语言实现代码（必考，标准写法）：

// 分区函数，返回基准元素的最终位置
int Partition(int arr[], int low, int high)
{
    int pivot = arr[low]; // 选第一个元素作为基准
    while(low < high)
    {
        // 从右往左找小于基准的元素，移到左边
        while(low < high && arr[high] >= pivot)
        {
            high--;
        }
        arr[low] = arr[high];
        // 从左往右找大于基准的元素，移到右边
        while(low < high && arr[low] <= pivot)
        {
            low++;
        }
        arr[high] = arr[low];
    }
    arr[low] = pivot; // 基准元素放到最终位置
    return low; // 返回基准位置
}

// 快速排序主函数，递归实现
void QuickSort(int arr[], int low, int high)
{
    if(low < high) // 递归终止条件：low >= high，子序列长度为0或1
    {
        int pivot_pos = Partition(arr, low, high); // 分区，得到基准位置
        QuickSort(arr, low, pivot_pos - 1); // 递归排序左半区
        QuickSort(arr, pivot_pos + 1, high); // 递归排序右半区
    }
}

// 快速排序的调用入口：QuickSort(arr, 0, n-1);

性能分析：
- 时间复杂度：最好情况（每次分区都均匀划分）O(nlogn)，最坏情况（序列已有序，每次划分极不均匀）O(n²)，平均时间复杂度O(nlogn)，是所有内部排序中平均性能最好的；
- 空间复杂度：O(logn)，主要是递归栈的开销，最坏情况O(n)；
- 稳定性：不稳定排序；
- 适用场景：元素数量多、序列无序的场景，是实际开发中最常用的排序算法。

3. 选择排序

选择排序的核心思想是：每一轮从无序序列中选出最小（或最大）的元素，放到有序序列的末尾，直到整个序列有序。专升本重点考查简单选择排序和堆排序。

（1）简单选择排序

简单选择排序是最简单的选择排序，核心逻辑是每一轮找最小值，交换到有序序列的末尾。

算法步骤（升序）：
1. 将序列分为有序区和无序区，初始有序区为空，无序区为整个序列；
2. 每一轮从无序区中找到关键字最小的元素；
3. 将最小元素与无序区的第一个元素交换位置，有序区长度加1，无序区长度减1；
4. 重复步骤2-3，直到无序区长度为0。

C语言实现代码（必考）：

// 简单选择排序，升序排列
void SelectSort(int arr[], int n)
{
    int i, j, min_index, temp;
    for(i = 0; i < n-1; i++)
    {
        min_index = i; // 初始化最小值的下标为无序区第一个元素
        // 找无序区中最小值的下标
        for(j = i+1; j < n; j++)
        {
            if(arr[j] < arr[min_index])
            {
                min_index = j;
            }
        }
        // 交换最小值和无序区第一个元素
        if(min_index != i)
        {
            temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;
        }
    }
}

性能分析：
- 时间复杂度：最好、最坏、平均情况都是O(n²)，因为无论序列是否有序，都需要遍历找最小值；
- 空间复杂度：O(1)，原地排序；
- 稳定性：不稳定排序；
- 特点：元素移动次数少，每轮最多交换一次，适合元素移动成本高的场景。

（2）堆排序

堆排序是简单选择排序的改进版，核心是利用堆这种数据结构来选择最小值/最大值，时间复杂度稳定在O(nlogn)。

核心概念：堆是一棵完全二叉树，分为大顶堆和小顶堆。大顶堆中，每个节点的值都大于等于它的左右孩子节点的值，根节点是整个堆的最大值；小顶堆中，每个节点的值都小于等于它的左右孩子节点的值，根节点是最小值。
核心步骤：构建堆 → 交换堆顶元素和堆的最后一个元素 → 调整堆，重复上述过程直到整个序列有序。
性能分析：时间复杂度最好、最坏、平均都是O(nlogn)，空间复杂度O(1)，不稳定排序；
考查形式：以选择题为主，掌握堆的定义、构建和调整的核心原理即可，无需掌握完整代码。

4. 归并排序

归并排序的核心思想是分治，将待排序序列不断划分为两个长度相等的子序列，直到每个子序列只有一个元素（天然有序），然后将两个有序的子序列合并为一个有序的序列，最终得到完整的有序序列。

核心特性：
- 时间复杂度：最好、最坏、平均都是O(nlogn)，性能稳定；
- 空间复杂度：O(n)，需要额外的辅助数组，不是原地排序；
- 稳定性：稳定排序；
- 考查形式：以选择题为主，掌握核心原理即可。

5. 基数排序

基数排序是一种基于关键字各位数字大小进行排序的算法，不需要进行关键字的比较，是借助多关键字排序的思想对单逻辑关键字进行排序的方法。

核心特性：时间复杂度O(d(n+r))，d是关键字的位数，r是基数；空间复杂度O(n+r)；稳定排序；
考查形式：以选择题为主，掌握核心原理和稳定性即可。

6. 排序算法大总结（必考，选择题高频考点）

我们把所有排序算法的核心特性整理成表格，方便大家对比记忆，这是专升本选择题的高频考点，必须背熟。

排序算法	平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
直接插入排序	O(n²)	O(n)	O(n²)	O(1)	稳定
希尔排序	O(n^1.3)	O(n)	O(n²)	O(1)	不稳定
冒泡排序	O(n²)	O(n)（带优化）	O(n²)	O(1)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n²)	O(logn)	不稳定
简单选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
二路归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
基数排序	O(d(n+r))	O(d(n+r))	O(d(n+r))	O(n+r)	稳定

核心记忆点：

平均时间复杂度为O(nlogn)的排序算法：快速排序、堆排序、归并排序、基数排序；
稳定的排序算法：直接插入排序、冒泡排序、归并排序、基数排序；
最坏情况时间复杂度为O(nlogn)的排序算法：堆排序、归并排序、基数排序，快速排序最坏是O(n²)；
原地排序（空间复杂度O(1)）：除了归并排序、基数排序，其余都是原地排序。

高频考点真题例题

例1（2025年广东专升本真题·单选题） 以下排序算法中，平均时间复杂度为O(nlogn)且稳定的是（） A. 快速排序 B. 归并排序 C. 简单选择排序 D. 希尔排序解：正确答案是B。归并排序平均时间复杂度O(nlogn)，且是稳定排序；快速排序不稳定，简单选择排序平均O(n²)，希尔排序不稳定。

例2（2024年广东专升本真题·编程题） 编写C语言函数，实现快速排序算法，对整型数组进行升序排列。解：就是我们上面拆解的快速排序代码，包含Partition分区函数和QuickSort递归主函数，是考试的标准写法。

易错点避雷

快速排序的递归终止条件是low < high，不能写成low <= high，否则会出现数组越界、无限递归的问题。
冒泡排序的优化版本，必须设置交换标记，当某一轮没有交换时，说明序列已有序，可以提前结束，最好情况时间复杂度才能达到O(n)。
直接插入排序的内层循环，是从后往前遍历有序序列，元素后移，不能写成从前往后，否则会覆盖元素。
简单选择排序每轮只需要交换一次元素，找到最小值的下标后，再和无序区第一个元素交换，不要每找到一个更小的元素就交换，会增加不必要的交换次数。
排序算法的稳定性，是指关键字相等的元素，排序后相对位置是否改变，不是指排序算法的时间复杂度是否稳定，这是选择题的高频概念陷阱。
快速排序、希尔排序、简单选择排序、堆排序都是不稳定的排序算法，不能用于需要保持相等元素相对位置的场景。

第三部分：广东计算机专升本计算机科目全备考全攻略

通过三篇系列文章，我们已经把广东专升本《计算机基础与程序设计》科目的所有考点，从C语言基础到数据结构的核心算法，做了完整的体系化拆解。接下来，我给大家一套完整的、贴合广东专升本考情的全周期备考规划，从零基础入门到考前冲刺，覆盖全阶段的核心任务和备考技巧，帮你少走弯路，高效备考。

一、全周期分阶段备考规划

（1）基础阶段（现在-6月）：搭建知识体系，吃透基础概念

这个阶段的核心目标，是把C语言和数据结构的所有知识点完整过一遍，理解每个概念的本质，搭建起完整的知识体系，不要急于刷题，重点是“打地基”。

C语言部分：从基础语法开始，一节一节地学，每个知识点都要亲手写代码验证，不要只看不动手。重点掌握变量、分支、循环、数组、函数、指针、结构体，每学完一个章节，就写对应的代码练习，比如学完循环，就写九九乘法表、素数判断；学完数组，就写冒泡排序、数组逆序；学完指针，就写字符串的相关操作。
数据结构部分：先吃透基础概念，重点理解每种数据结构的逻辑结构、存储结构、核心操作的原理，不要一上来就啃代码。先搞懂“是什么、为什么用、怎么用”，再去看代码实现。重点掌握线性表、栈与队列、树与二叉树的核心概念，查找和排序先掌握核心原理。
核心要求：这个阶段不要追求速度，要追求理解，每个概念都要搞懂，不能似是而非。C语言要做到能独立写出基础的代码，数据结构要能画出每种结构的逻辑图，说出核心操作的步骤。

（2）强化阶段（7月-11月）：专项突破，刷题强化，代码落地

这个阶段的核心目标，是分模块专项突破，通过刷题把知识点转化为得分能力，重点攻克代码实现和算法逻辑，这是备考的黄金时期。

分模块专项刷题：按照我们拆解的模块，一个模块一个模块地突破，学完一个模块，就刷对应的专项习题，从基础题到真题，循序渐进。C语言重点刷程序阅读题、程序填空题、编程题；数据结构重点刷选择题、填空题、算法应用题。
代码手写训练：专升本考试是笔试，需要手写代码，所以必须养成手写代码的习惯，不能只在电脑上敲。C语言的核心编程题（排序、查找、字符串处理、数组操作）、数据结构的核心算法（链表操作、二叉树遍历、哈夫曼树、排序算法），都要能手写完整的代码，保证语法正确、逻辑通顺。
真题为王：2015年到2025年的广东专升本统考真题，是最好的复习资料，至少要刷3遍以上。第一遍按模块刷，第二遍按套卷刷，第三遍重点刷错题和高频考点。刷真题时，不要只对答案，要搞懂每一道题考的是什么知识点，为什么这么做，有没有更优的解法，总结命题规律。
建立错题本：做错的题，一定要整理到错题本上，标注清楚错题题目、错误答案、正确答案、错误原因、考查知识点、解题思路总结。每周、每月都要复盘错题本，把重复错的题重点标记，针对性强化练习，保证同样的错误不会在考试中犯第二次。

（3）冲刺阶段（12月-考试前）：全真模拟，查漏补缺，回归基础

这个阶段的核心目标，是通过全真模拟适应考试节奏，查漏补缺，调整考试状态，把能拿到的分全部拿到。

全真模拟训练：严格按照考试时间（150分钟），做真题套卷和高质量的模拟卷，模拟真实的考试场景，培养时间分配能力。广东专升本的计算机科目题量大，尤其是编程题和综合应用题很耗时间，很多同学会出现做不完题的情况，必须通过模拟训练，提升解题速度和答题节奏。
查漏补缺：做完套卷后，认真分析错题，找到自己的薄弱环节，回头再看对应的知识点，刷对应的习题，补齐短板。对于薄弱模块，不要逃避，针对性地补漏，哪怕是最难的算法，只要搞懂核心逻辑，就能拿到分数。
回归基础，抓大放小：这个阶段不要去啃偏题、怪题、难题了，要回归教材、回归真题、回归基础。把所有的核心公式、核心语法、算法核心步骤、排序查找的复杂度表格，再背一遍；把错题本再看一遍；把基础概念再过一遍，保证基础题不丢分，中档题全拿分，难题尽量拿步骤分。
手写代码复盘：把高频考查的编程题、算法代码，再手写几遍，保证考试时能快速、准确地写出来，不要出现语法错误、逻辑漏洞。

二、核心备考提分技巧

拒绝眼高手低，代码一定要亲手写 很多同学备考时，看着代码觉得懂了，就懒得动手写，结果考试的时候，要么语法写错，要么逻辑有漏洞，白白丢分。C语言和数据结构，从来都不是看会的，而是写会的。哪怕是最简单的冒泡排序，也要亲手写出来，运行、调试、修改，才能真正理解。笔试考试需要手写代码，平时就要多练习手写，保证代码的格式、语法、逻辑都正确。
真题为王，总结命题规律 广东专升本的计算机统考，考点非常固定，命题规律极强，高频考点每年都会反复考，尤其是C语言的指针、数组、函数，数据结构的二叉树、排序、查找、线性表，几乎每年都会出大题。刷真题不是为了背答案，而是为了总结命题规律，搞懂高频考点的考查方式，针对性地强化训练，这样备考才能事半功倍。
错题复盘比盲目刷题更重要 备考不是刷的题越多越好，而是刷一道题，就要搞懂一类题。错题是你备考中最宝贵的财富，它暴露了你的知识漏洞和思维误区。一定要认真整理错题，定期复盘，搞清楚自己为什么错，是知识点没懂，还是粗心大意，还是逻辑错误，然后针对性地解决，保证同样的错误不会犯第二次。盲目刷100道题，不如把10道真题搞透。
编程题拿分技巧：先写框架，再填细节，步骤分一定要拿 专升本的编程题和综合应用题，是按步骤给分的，哪怕你最终的代码不能完全运行，只要核心框架、核心步骤写对了，就能拿到大部分分数。考试时，先写核心的函数框架、变量定义，再写核心的逻辑步骤，哪怕有细节写不出来，也要把整体的结构写对，千万不要空着。比如快速排序，哪怕分区函数写不完整，只要把递归的框架、分治的逻辑写出来，就能拿到一半以上的分数。
建立知识体系，不要碎片化学习 C语言和数据结构的知识点是环环相扣的，不是孤立的。比如指针和数组、函数、结构体紧密关联，链表依赖于结构体和指针，二叉树的遍历依赖于递归和栈，排序算法依赖于数组和循环。备考时，一定要搭建完整的知识体系，搞懂知识点之间的关联，而不是碎片化地记一个个孤立的考点，这样才能真正理解，灵活应对考试中的各种题型。

第四部分：升学规划指南：考上之后的路该怎么走

专升本考试不是终点，而是你人生新的起点。无论你最终考上的是公办院校，还是民办院校，这两年的本科时光，都将是你人生中最关键的成长期，决定了你未来的职业发展高度。接下来，我分别针对公办院校和民办院校，区分计算机专业和非计算机专业，给大家最真诚的建议和规划，同时也给大家专业选择的核心参考。

一、考上公办院校之后的学习计划

公办院校拥有更优质的师资力量、更完善的教学设施、更浓厚的学习氛围、更多的科研和竞赛资源，同时社会认可度更高，考公、考编、校招的优势更大。进入公办院校，核心目标是充分利用优质资源，提升核心竞争力，打造自己的不可替代性。

（1）计算机专业同学的学习计划

夯实专业基础，补齐专科阶段的短板 专科阶段的计算机教学，更偏向于应用和实操，而本科阶段更注重底层原理和系统能力。进入本科后，一定要重点补好四门核心基础课：计算机组成原理、操作系统、计算机网络、数据库系统，这四门课是计算机专业的“四大名捕”，也是校招笔试、考研、考公的核心考点，更是你未来职业发展的底层基础。同时，把专升本阶段学的C语言、数据结构再深化一遍，动手实现更复杂的算法，提升代码能力。
确定技术方向，深耕一个细分领域 计算机行业的细分方向很多，比如Java后端开发、前端开发、Python开发、人工智能、大数据、嵌入式开发、网络安全、游戏开发、软件测试等。进入本科后，不要什么都学一点，什么都不精通，一定要结合自己的兴趣和行业发展趋势，选一个细分方向深耕。比如你想做后端开发，就深耕Java、SpringBoot、SpringCloud、MySQL、Redis这些核心技术；想做网络安全，就深耕渗透测试、漏洞挖掘、代码审计。有一个深耕的方向，校招时才有核心竞争力，而不是一个什么都懂一点的“万金油”。
积极参加竞赛和项目，丰富简历 公办院校有大量的竞赛资源，一定要积极参加含金量高的竞赛，比如蓝桥杯全国软件和信息技术专业人才大赛、ACM-ICPC程序设计竞赛、中国大学生计算机设计大赛、全国大学生数学建模竞赛等。这些竞赛的奖项，是你校招简历上最亮眼的加分项，同时也能极大提升你的代码能力和解决问题的能力。同时，一定要多做实战项目，不要只停留在课本上。可以跟着开源项目学习，自己动手做一个完整的项目，比如个人博客系统、电商系统、管理系统，把项目放到GitHub上，校招时这就是你的作品集。有条件的话，积极联系导师，参与导师的科研项目，提升自己的科研能力和工程能力。
提前规划职业路径，做好准备 本科只有两年时间，非常短暂，一定要提前规划好自己的职业路径，不要等到毕业才临时抱佛脚。计算机专业的主流路径有三条：就业、考研、考公考编。
- 如果你打算就业：大二就开始刷LeetCode算法题，准备校招笔试，大三开始找实习，实习是进入大厂的最佳路径，有了优质的实习经历，校招时会事半功倍；
- 如果你打算考研：专升本上岸后，就可以开始了解考研院校和专业，打好数学、英语和专业课的基础，大三正式开始备考，公办院校的学习氛围和考研资源，会给你很大的助力；
- 如果你打算考公考编：计算机专业是考公的热门专业，岗位很多，提前了解国考、省考、事业单位考试的时间和岗位要求，打好行测和申论的基础，同时不要落下专业课，很多岗位会有专业课笔试。

（2）非计算机专业同学的学习计划

吃透本专业的核心课程，保证学业成绩 对于非计算机专业的同学，比如会计、工商管理、汉语言、机械、电子等专业，首先要保证本专业的核心课程学好，不挂科，拿到学位证是第一要务。同时，尽量提升自己的绩点，绩点高的话，评奖评优、考研、考公、就业都有优势。
结合本专业，打造差异化竞争力 现在的各行各业，都在和计算机、数字化深度融合，懂本专业+懂计算机技能，会让你拥有极强的差异化竞争力。比如会计专业的同学，学好Python、Excel高级功能、财务系统，能极大提升工作效率，在财务数字化的趋势下更有优势；机械专业的同学，学好C语言、嵌入式开发、PLC编程，在智能制造的行业趋势下，就业竞争力会远超同专业的同学；新媒体、汉语言专业的同学，学好Python数据分析、新媒体运营工具，会更有竞争力。不要觉得自己不是计算机专业，就不用学计算机技能，在数字化时代，计算机技能已经成为职场的通用技能，结合你的本专业，会让你脱颖而出。
提前规划职业方向，利用公办院校的资源优势 公办院校的考公、考编、考研氛围更浓厚，资源更多，非计算机专业的同学，大部分会选择考公考编、考研，或者进入本专业对应的行业。
- 如果你打算考公考编：提前了解对应的岗位要求，利用学校的自习室、考公社团、讲座资源，提前备考，公办院校的应届生身份，是考公考编的最大优势；
- 如果你打算考研：提前确定目标院校和专业，利用学校的图书馆、师资资源，打好专业课基础，和同专业的同学一起备考，互相监督；
- 如果你打算就业：利用学校的校招资源，积极参加企业宣讲会、双选会，提前找对应的实习，提升自己的实践能力，同时考取本专业对应的高含金量证书，比如会计的注册会计师、法律的法考、建筑的一建二建等，提升自己的就业竞争力。

二、考上民办院校之后的建议

很多同学会觉得，考上民办院校，学费贵，社会认可度不如公办，就觉得前途渺茫。但我想告诉你，专升本上岸本身，就已经打败了80%以上的专科生，你已经拥有了本科学历，拥有了考公、考研、考编、进入大厂的入场券。民办院校的本科，也是国家承认的全日制本科学历，和公办院校的本科学历拥有同等的法律效力，考公、考研、考编的报名资格完全一样。

进入民办院校，核心目标是弥补院校背景的不足，用硬实力打造自己的核心竞争力，用结果证明自己。学历只是敲门砖，最终决定你职业高度的，还是你的个人能力。

（1）计算机专业同学的建议

把代码能力练到极致，用技术实力弥补院校背景的不足 计算机行业是最不看重学历、最看重技术实力的行业，哪怕你是民办本科毕业，只要你的代码能力够强，技术够扎实，有拿得出手的项目和竞赛奖项，一样能拿到大厂的offer，拿到高薪。进入民办院校，不要抱怨环境，不要被周围躺平的氛围影响，把所有的精力都放在提升技术实力上，把C语言、数据结构、操作系统、计算机网络、数据库这些核心基础打牢，深耕一个技术方向，把代码能力练到极致。每天坚持写代码，刷LeetCode算法题，做实战项目，把自己的项目放到GitHub上，打造自己的技术作品集。技术实力，就是计算机专业同学最大的底气，比学历更重要。
用竞赛、项目、实习，丰富你的简历，抵消院校的劣势 院校背景是你无法改变的，但你可以改变简历的含金量。民办院校的竞赛资源可能不如公办，但蓝桥杯、ACM、计算机设计大赛这些全国性的竞赛，都是开放报名的，你完全可以自己组队参加，拿到省级、国家级的奖项，这些奖项在招聘时，比院校背景更有说服力。同时，一定要多做项目，多找实习。哪怕是远程实习、小公司的实习，也要去做，实习经历是校招时企业最看重的。有了真实的项目经历和实习经历，你的简历就不会因为民办院校的背景被筛掉，你就有了面试的机会，而面试时，拼的就是你的技术实力。
不要放弃考研，考研是你提升学历、改变院校背景的最佳路径 如果你觉得民办院校的背景不够，考研是你最好的选择。专升本上岸后，你已经有了本科身份，可以直接考研，不用再以同等学力报考，没有了额外的限制。每年都有大量民办本科的同学，考上985、211、双一流院校的研究生，实现学历的逆袭。如果你打算考研，从进入本科的第一天开始，就打好英语、数学的基础，确定目标院校和专业，提前备考。民办院校的学习氛围可能不如公办，你要学会自律，找到一起备考的伙伴，互相监督，坚持下去，考研是一场持久战，坚持到最后的人，才能上岸。
考公考编，抓住应届生身份的红利 民办本科的学历，和公办本科一样，拥有考公、考编、考事业单位的报名资格，这是国家法律规定的，没有任何区别。计算机专业是考公的热门专业，国考、省考、事业单位、选调生、公安系统，都有大量的计算机专业岗位，一定要抓住应届生的身份，全力备考。对于考公考编来说，只要你有本科学历，就有报名资格，最终能不能上岸，看的是你的笔试和面试成绩，和你是公办还是民办毕业的，没有任何关系。

（2）非计算机专业同学的建议

保证顺利毕业，拿到学位证，用好应届生身份 对于民办院校的非计算机专业同学，第一要务是保证不挂科，顺利毕业，拿到毕业证和学位证。本科学历和应届生身份，是你最大的资本，尤其是考公考编、国企招聘，大部分岗位都只招应届生，一定要抓住这个机会，这是你和公办院校同学最公平的竞争赛道。
全力备考考公考编、国企、事业单位，这是最适合的路径 对于非计算机专业的同学，尤其是文科、经管类专业，民办院校的校招资源可能不如公办，进入名企的难度较大，而考公考编、国企、事业单位，是最公平、最稳定的路径。只要你有本科学历，就有报名资格，最终能否上岸，完全取决于你的笔试和面试成绩，和院校背景无关。进入本科后，就可以开始了解国考、省考、选调生、事业单位的考试时间和岗位要求，提前备考行测和申论，报班或者自学都可以，关键是坚持刷题和复盘。民办院校的同学，每年考上公务员、事业单位的大有人在，只要你足够努力，就一定能上岸。
考取高含金量的职业证书，提升就业竞争力 如果你打算进入企业就业，一定要考取本专业对应的高含金量职业证书，这是弥补院校背景不足的最好方式。比如会计专业的注册会计师CPA、初级/中级会计职称；法律专业的法律职业资格证；人力资源专业的人力资源管理师；建筑专业的一建、二建、造价工程师；教育专业的教师资格证。这些高含金量的证书，在行业内的认可度极高，有了这些证书，你的就业竞争力会远超同专业的同学，哪怕是公办院校的毕业生。
不要放弃考研，提升学历是改变现状的最佳方式 考研不是公办院校同学的专利，民办院校的同学，一样能考上名校的研究生。每年都有大量民办本科的同学，通过考研，进入双一流院校，彻底改变自己的学历背景和人生轨迹。如果你对自己的院校背景不满意，考研就是你最好的机会，进入本科后，提前确定目标，打好基础，坚持备考，就一定有机会上岸。

三、专升本专业选择的核心建议

很多同学在专升本报名时，都会纠结：是继续考本专业，还是跨考计算机专业？是选好考的专业，还是选有前景的专业？这里给大家几个核心建议，帮你做出最适合自己的选择。

优先选择和专科专业相同或相近的专业 专升本的核心目标是上岸，相同或相近的专业，你有专科阶段的基础，备考起来难度更低，上岸的概率更大。同时，很多本科院校的专业，会要求专科专业必须是相近专业，不能跨考，尤其是医学、教育、建筑等专业性强的专业，一定要提前看目标院校的招生简章，确认报考资格。
跨考计算机专业，一定要谨慎，结合自身情况 计算机专业是专升本的大热门，就业前景好，薪资高，考公岗位多，每年都有大量同学跨考计算机。但我要提醒你，计算机专业的专升本考试，有C语言和数据结构，对于零基础的同学，难度很大，尤其是数据结构，需要很强的逻辑思维和代码能力。如果你是零基础，一定要先试学C语言，看看自己能不能听懂，能不能写代码，有没有兴趣，再决定是否跨考，不要盲目跟风。如果你逻辑思维强，对编程有兴趣，愿意花时间练代码，跨考计算机是很好的选择，未来的职业发展空间很大；如果你对编程完全没兴趣，只是觉得热门，那一定要谨慎，哪怕上岸了，本科阶段的专业课也会让你非常痛苦，未来就业也很难走得远。
选择专业，优先看就业前景和自己的职业规划 选择专业，不要只看哪个好考，更要看这个专业的就业前景，和你未来的职业规划是否匹配。如果你未来打算考公考编，就选择汉语言、法学、会计、计算机这些岗位多的专业；如果你打算进企业就业，就选择计算机、电子信息、机械、电气这些工科专业，就业机会多，薪资高；如果你打算考研，就选择和考研专业对应的本科专业，打好专业课基础。不要为了上岸，选择一个完全没兴趣、就业前景差的专业，哪怕上岸了，本科两年也会学得很痛苦，毕业时也会面临就业难的问题。
能选全日制，就不选非全日制；能选本科，就不局限于专科 最后，我想告诉大家，专升本的全日制本科学历，是你专科阶段能拿到的最有价值的学历，也是唯一一次获得全日制本科学历的机会。无论你考上的是公办还是民办，无论你选择的是什么专业，只要能上岸，就一定要去读。这个本科学历，会给你的人生带来更多的可能性，更多的选择机会，这是专科学历永远无法比拟的。

写在最后

专升本的备考路，是一场孤独的战斗，尤其是计算机专业的备考，C语言的指针、数据结构的算法，无数个熬夜写代码、啃知识点的夜晚，无数次崩溃又重新站起来的瞬间，只有你自己知道。

但请你相信，所有的努力，都不会被辜负。你今天刷的每一道题，写的每一行代码，背的每一个知识点，都在为你未来的人生铺路。专升本不是人生的终点，而是你新的起点，它会给你打开一扇新的大门，让你看到更广阔的世界，拥有更多的人生选择。

无论你现在是刚开始备考，还是已经进入冲刺阶段，都请你坚持下去。不要焦虑，不要迷茫，一步一个脚印，踏踏实实地学，你想要的，终会如约而至。