南邮数据结构考研常用算法

于 2023-01-09 13:47:25 发布
阅读量770 收藏 20
点赞数 3
分类专栏： 考研 文章标签： 数据结构 算法 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love521314123/article/details/128613330
版权
本文涵盖了链表的节点删除、插入排序和选择排序，以及二叉搜索树的插入、后序序列生成和完全二叉树的判断。此外，还讨论了图的深度优先遍历、寻找特定路径、连通分量计数、无向图转化为树的条件以及数组的平均值计算和全排列问题。
摘要由CSDN通过智能技术生成

1.链表

  1. 在带头结点的链表中，删除所有值为x的结点
void Del_X(Linklist &L,ElemType x){
    LNode *p=L->next, *pre=L,*q;
    while (p!=null){
        if (p->data==x){
           q=p;
           p=p->next;
           pre->next=p;
           free(q);
        }
        else{
           pre=p;
           p=p->next;
        }
    }
}
  1. 使用单链表进行插入排序
ListNode* insertSort(ListNode *head){
    ListNode *dummy = new ListNode(0),*cur = head;
    while (cur){
       ListNode *pre = dummy,*next = cur->next;
        //找到第一个比cur大的元素
        while (pre->next && pre->next->val<=cur->val)
            pre = pre->next;
        cur->next = pre->next;
        pre->next = cur;
        cur = next;
    }
    return dummy->next;
}
  1. 使用单链表进行简单选择排序
void SelectSort(LinkList L){
    LinkList p,q,min;
    DataType temp;
    p = L->next;
    while (p!=null){
        min = p;
        q = p->next;
        while (q!=null){
            if (q->data<min->data)
                min = q;
            q = q->next;
        }
        if (p->data>min->data){
            temp = p->data;
            p->data = min->data;
            min->data = temp;
        }
        p = p->next;
    }
}
  1. 判断单链表是否有环
int hasLoop(Node *head){
    Node *p1,*p2;
    if (head==null || head->next==null){  //链表为空，或者是单节点链表
        return 0;     
    }
    p1=p2=head;
    while (p1->next!=null && p2->next->next!=null){
        p1 = p1->next;
        p2 = p2->next->next;
        if (p1==p2)
            return 1;
    }
    return 0;
}

2. 二叉树

  1. 使用递归算法在一颗二叉搜索树上插入一个元素
BSTNode* insertIntoBST(TreeNode *root,Element e){
     int k = e.key;
     if (!root){      //root为空
         BSTNode *p = (BSTNode *)malloc(sizeof(BSTNode));
         p->lchild = null;
         p->rchild = null;
         p->val = k;
         return p;
     }
    if (k>root->val){  //插入到右子树
        root->rchild = insertIntoBST(root->rchild,e);
    }
    else if (k<root->val){  //插入到左子树
        root->lchild = insertIntoBST(root->lchild,e);
    }
    return root;
}
  1. 已知满二叉树先序序列，求二叉树的后序序列
void PreToPost(ElemType* pre, int l1, int h1, ElemType* post, int l2, int h2)
{
    int half;
    if(h1>=l1){
        post[h2]=pre[l1];    //先序的第一个变为后序的最后一个
        half=(h1-l1)/2;
        //递归调用
        PreToPost(pre,l1+1,l1+half,post,l2,l2+half-1);
        PreToPost(pre,l1+half+1,h1,post,l2+half,h2-1);
    }
}

image-20221011120000076

  1. 判断一棵树是否为完全二叉树
//空结点使用NULL来表示
bool is_complete_bt(TreeNode* root){
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty()){
        TreeNode* node=q.front();
        q.pop();
        if(node==null)
            break;
        else{
            q.push(node->left);
            q.push(node->right);
        }
    }
    while(!q.empty()){
        TreeNode* node=q.front();
        q.pop();
        if(node!=null)
            return false;
    }
    return true;
}
  1. 给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
vector<vector<int>> lists;
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
    if (root==nullptr)
        return lists;
    vector<int> list;
    dfs(root,targetSum,list);
    return lists;
}
void dfs(TreeNode* root, int targetSum,vector<int> list){
    if (root==nullptr)
        return;
    list.push_back(root->val);
    if (root->val==targetSum && root->left==nullptr && root->right==nullptr)
        lists.push_back(list);
    dfs(root->left,targetSum-root->val,list);
    dfs(root->right,targetSum-root->val,list);
    list.pop_back();
}
  1. 合并二叉排序树
void BSTree_Merge(BiTree &T,BiTree &S){
    if (S->lchild){
        BSTree_Merge(T,S->lchild);
    }
    if (S->rchild){
        BSTree_Merge(T,S->rchild);
    }
    Insert_Node(T,S);
}

void Insert_Node(BSTree &T, BSTree *S){
    if (S->data > T->data){
        if (!T->right)  //T的右子树为空
           T->right = S;
        else{
            Insert_Node(T->right,S);
        }
    }
    else if (S->data < T->data){
        if (!T->left)
           T->left = S;
        else{
            Insert_Node(T->left,S);
        }
    }
    S->left = null;
    S->right = null; //插入的新结点和原来的左右子树断绝关系
}
  1. 验证二叉搜索树
long long pre = LONG_MIN;
bool isValidBST(TreeNode* root) {
    if (root == nullptr)
        return true;
    if (!isValidBST(root->left))
        return false;
    if (root->val <= pre)
        return false;
    pre  = root->val;
    return isValidBST(root->right);
}
  1. 删除二叉搜索树中的最大值
bool DelMax(BSTree &T){
    BSTNode *p = T,*q=p;
    if (!p)       //树为空
        return false;
    while (p->rchild){   //找到最右端的结点
        q=p;
        p=p->rchild;
    }
    if (p==T)         //无右子树
        T=T->lchild;
    else
        q->rchild = p->lchild;
    return true;
}
  1. 输出AVL搜索树中所有结点的平衡因子
int depth(BTree root){
    if (root==null)
        return 0;
    int l = depth(roo->left);
    int r = depth(root->right);
    return (l>r?l:r)+1;
}
    void print_num(BTree root){
    if (root!=null){
        printf("结点%d的平衡因子为%d\n",root->val,depth(root->left) - depth(root->right));
        print_num(root->left);
        print_num(root->right);
    }
}

3. 图

  1. 图的深度优先遍历
void DFS(Graph G,int k){   //对结点k进行深度优先遍历
    visit(k);  //访问k
    visited[k];  //标记为已访问
    //邻接矩阵
    for (int i=0;i<G->n;i++)  //结点k所对应的那一行
        if (D->Edges[k][i]==1 && visited[i]==false)
            DFS(G,i);
    //邻接表
    ENode *p;
    for (p = G->adjList[k]->firstarc;p;p = p->nextarc){
        int temp = p->adjvex;
        if (!visited[temp])
            dfs(G,temp);
    }
}

时间复杂度 O(|V|^2) 空间复杂度O(|V|)

图的深度优先遍历（非递归）

void DFS(Graph G,int v){
    InitStack(S);  //初始化一个栈
    for (int i=0;i<G.vexnum;i++)
        visited[i] = false;
    Push(S,v);
    visited[v] = true;
    while (!isEmpty(S)){
        k = Pop(S);
        visit(k);
        for (int p = G.adjlist[v].firstarc;p; p=p->nextarc){
            if (!visited[p]){
                Push(S,p);
                visited[p]=true;
            }
        }
    }
}
  1. 判断无向图顶点 i 和 j 是否存在长度为k的路径
int visited[MAXSIZE];
int dfs(Graph G,int i,int j,int k){
    if (i==j && k==0)
        return 1;
    ENode *p;
    if (k>0){
        visited[i]=1;
        //p.vertices[i] 邻接表的顶点
        for (p=G.adjList[i].firstarc;p;p=p->nextarc){
            //边表的第一个结点
            int temp = p->adjvex;
            if (!visited[temp] && dfs(G,temp,j,k-1))
                return 1;
        }
        visited[i]=0;
    }
    return 0;
}
  1. 输出图中顶点 i 到顶点 j 的所有路径
void dfs(Graph graph, int v, int end, bool visit[], int path[], int cnt)
{
    visit[v] = true;
    path[cnt++] = v;
    if(v == end)
    {
        for(int i = 0; i < cnt; i++)
        {
            cout<<path[i]<<" ";
        }
        cout<<endl;
        return;
    }
    for(ENode* p = graph.adjList[v].firstarc; p ; p=p->next)
    {
        if(!visit[p->adjvex])
        {
            dfs(graph, p->adjvex, end, visit, path, cnt);
        }
        //回溯
        visit[p->adjvex] = false;
    }
}
  1. 求用邻接表存储的无向图中“节点总数恰好为k”的连通分量数量 (邻接表的题，弄懂这一个就够了)
bool visited[MAXSIZE];
int concomx(Graph G){
    int count = 0;
    int vnum = 0;
    for (int i=0;i<G.vexnum;i++){
        visited[i] = false;
    }
    for (int i=0;i<G.vexnum;i++){
        vnum = 0;
        if (visited[i] == false){
            dfs(G,i,visited,vnum);
        }
        if (vnum==k)
            count++;
    }
    return count;
}
void dfs(Graph G,int v,bool visited,int vnum){
    ENode *p;
    visited[v] = true;
    vnum++;
    for (p=G->adjList[i]->firstarc;p;p=p->nextarc){
        int temp = p->adjvex;
        if (visited[temp]==false){
            dfs(G,temp,visited,vnum);
        }
    }
}
  1. 判断 图是否可以转化为一颗树

图是连通的且无环

bool isTree(Graph &G){
	for(int i=1;i<=G.vexnum;i++){
		visited[i]=FALSE;
	}
	int Vnum=0,Enum=0;
	DFS(G,1,Vnum,Enum,visited);
    //一次遍历，顶点数等于图的顶点数，边数等于2*（n-1），说明可以转化为一棵树
	if(Vnum==G.vexnum&&Enum==2*(G.vexnum-1)){	//无向图，边数应为结点数-1的2倍 
		return true;
	}
	else return false;
} 
void DFS(Graph &G,int v,int& Vnum,int& Enum,bool visted[]){
    ENode *p;
	visited[v]=TRUE;
	Vnum++;
    for (p = G->adjList[i]->firstarc;p;p = p->nextarc){
        Enum++;
        if (!visited[p->adjvex]){
           DFS(G,p->adjvex,Vnum,Enum,visited);
        }
    }
}
  1. 无向图采用邻接表的方式存储，删除边（i，j）
void DeleteArc(Graph G,int i,int j){
    //删除其中一条边 i到j
    ENode *pre = null;
    ENode *p = G->adjList[i].firstarc;  //结点i的第一个相邻结点
    while (p){
        if (p->adjvex==j){
            if (pre==null){
               G->adjList[i]->firstarc = p->nextarc; 
            }
            else
               pre->nextarc = p->nextarc;  
            free(p);
        }
        else{
            pre = p;
            p = p->next;
        }
    }
    //删除另一条边 j到i
    ENode *qpre = null;
    ENode *q = G->adjList[j].firstarc;
    while (q){
        if (q->adjvex==i){
            if (qpre==null){
               adjList[j].firstarc = q->nextarc; 
            }
            else
               pre->nextarc = q->nextarc;  
            free(q);
        }
        else{
            qpre = q;
            q = q->next;
        }
    }
}
  1. 有向无环图，找出能访问图中所有节点的最小点集

思路：找出入度为零的节点即可

 vector<int> findSmallestSetOfVertices(int n, vector<vector<int>>& edges) {
     vector<int> ans;
     vector<int> inDegree(n);
     for (auto &info : edges){
        inDegree[info[1]]++;
     }
     for (int i=0;i<n;i++){
        if (inDegree[i]==0)
            ans.push_back(i);
     }
     return ans;
 }
  1. 求邻接表表示的图的出度和入度
void Degree(int* degree,Graph *G){
    int i;
    ENode *p;
    for (i=0;i<G->n;i++)
        degree[i] = 0;
    for (i=0;i<G->n;i++){
        for (p = G->adjList[i]->firstarc;p;p = p->nextArc){
            degree[i]++;   //求出度
            ingree[p->adjvex]++;   //求入度
        }
    }
}

4. 其他

  1. 使用递归求数组中n个数的平均值
int avg(int a[],int n){
    if (n>0)
        return (a[n-1]+avg(a,n-1)*(n-1))/n;
    return 0;
}
  1. 递归求幂集（全排列）
示例
输入： nums = [1,2,3]
 输出：
[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

vector<int> t;
vector<vector<int>> ans;
void dfs(int cur, vector<int>& nums) {
    ans.push_back(t);
    for (int i = cur;i<nums.size();i++){
        t.push_back(nums[i]);
        dfs(i+1,nums);
        t.pop_back();
    }
}
vector<vector<int>> subsets(vector<int>& nums) {
    dfs(0, nums);
    return ans;
}
  1. 对一个排序去重（有重复的关键字，删除前一个，保留后一个）
void Delete(SqList &L){
    for (int i = 1;i<L.length;i++){
        int j = i-1;
        if (L.data[i]==L.data[j]){
            for (int k=j;k<L.length;k++)
                L.data[k] = L.data[k+1];
            L.length--;
        }
    }
}
  1. 从有序顺序表中删除所有值重复的元素，使表中的值均不相同
bool delete_all(SqList &L) {
	int i;
	int k=0;//k记录重复元素个数 
	for(i=1;i<L.Length;i++){
		if(L.data[i-1]==L.data[i]){
			k++; 
		}
		L.data[i-k]=L.data[i];
	}
	L.Length=L.Length-k;
	return true; 
}
  1. 队列和栈
Stack S;
Top(S,x);  获取栈顶元素并够通过x返回
Push(S,x);
Pop(S);

Queue Q;
Front(Q,x);
EnQueue(Q,x);
DeQueue(Q);
  1. 快速排序
int Partition(ElemType A[],int low,int high){
    ElemType pivot = A[low];
    while (low<high){
        while (low<high && A[high]>=pivot)
            high--;
        while (low<high && A[low]<=pivot)
            low++;
    }
    A[low] = pivot;   //枢轴元素存放到最终位置
    return low;
}

void QuickSort(ElemType A[],int low,int high){
    if (low<high){
        int pivot = Partition(A,low,high);
        QuickSort(A,low,pivot-1);
        QuickSort(A,pivot+1,high);
    }
}
一只不吃老鼠的猫
关注
  • 3
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
南邮数据结构考研真题+答案（1999年_2018年）.rar
05-20
此为南京邮电大学811数据结构考研真题+答案1999-2018（无2012），本人为2018年考研工科生，这门专业课几乎满分，其中上传的真题中2018年回忆版+答案最为珍贵（也是学得好才能全部回忆出来，哈哈！），除了3道选择题没有回忆出来，其他题目几乎一模一样。答案包含算法思想与代码设计。
南邮数据结构历年真题.rar
06-28
南京邮电大学（简称“南邮”）作为一所知名的工科院校，其数据结构课程的重要性不言而喻。这份名为"南邮数据结构历年真题.rar"的压缩包文件，显然包含了南邮在过去若干年中数据结构课程考试的试题，对于准备考南邮的...
数据结构算法【考研】
WU2629409421perfect的博客
11-30 1万+
目录： 1.1 统计出单链表HL中结点的值等于给定值X的结点数 2.1 设有一组初始记录关键字序列（K1，K2，… Kn），要求设计一个算法能够在 O(n) 的时间复杂度内将线性表划分成两部分，其中左半部分的每个关键字均小于 Ki ，右半部分的每个关键字均大于等于 Ki 2.2 设有两个集合A和集合B，要求设计生成集合C=A∩B的算法，其中集合A、B和C用链式存储结构表示 3.1 设...
数据结构算法题（考研）
小白白O快起来
01-03 4538
1、利用结点右孩子指针将一棵二叉树的叶子结点按照从左往右的顺序串成一个单链表（head初值为NULL,定义两个指针head和tail分别指向第一个叶子结点和最后一个叶子结点）？ void link(BTNode *p, BTNode *&head, BTNode *&tail) { if(p != NULL) { if(p-lchild==NULL && p->rchild==NULL) { if(head==NULL) //head刚开
南邮计算机专业考什么,南京邮电大学计算机专业“数据结构”考研初试
weixin_36057373的博客
06-18 1696
本帖为各位想要报考南京邮电大学计算机学院的同学们解答一下关于811数据结构初试的试卷题型以及复习安排，希望能够帮助到正在备战的各位同学。先说一下试卷题型：南邮在2016年之前的题型为15道判断(2*15)，15道选择(2*15)，5道解答(10*5)，以及4道算法编写(10*4)。但在后面几年的初试试卷中去掉了判断题，将题型更改为20道选择题(2*20)，8道综合题(8*10)，以及3道算法题(3...
南邮考研811数据结构经验分享
qq_45838671的博客
07-03 4175
南邮考研811数据结构经验分享 前言 本人21考研上岸南京邮电大学物联网学院电子信息，我的本科是排名400+的末流二本，本科专业计算数学。 专业课我是7月份暑假开始，买的书籍包括：王道数据结构、数据结构—c语言描述(陈惠南)、数据结构—c语言(王海艳)。 Ps：有的人可能会纠结选择王道还是天勤，个人觉得天勤适合基础比较薄弱的人，王道适合有一定基础，或者本科学过数据结构的人。 个人复习经历 暑假期间主要是看基础课，看完视频之后把参考书、王道上的知识点再过一遍，接着做王道书后对应的习题，和参考书的题。 暑假结束
南京邮电大学+811数据结构考研
04-20
### 南京邮电大学811数据结构考研知识点总结 #### 一、绪论 - **数据结构定义**：数据结构是计算机中存储、组织数据的方式，它研究非数值计算的程序设计问题中计算机的操作对象及其关系和操作方法。 - **数据结构...
2010-2018年南京邮电大学811数据结构考研真题及参考答案
07-21
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中高效地组织和管理数据，以...通过深入研究南京邮电大学811数据结构的考研真题，考生不仅能掌握这门学科的核心概念，还能提升自身的编程技能和算法设计能力。
2019年南京邮电大学811数据结构考研真题
07-21
2019年南京邮电大学811数据结构考研真题是针对这一重要课程的一次专业考试，旨在考察考生对数据结构的基本概念、原理和算法的掌握程度。 首先，数据结构的基本概念包括数组、链表、栈、队列、树、图等。数组是最...
南京邮电大学811数据结构考研笔记整理.7z
03-01
南京邮电大学811数据结构考研笔记整理.7z这个压缩包包含的资源，显然是为了帮助考生深入理解和掌握数据结构的重要概念、算法以及解题策略。以下是基于这些资源的详细知识点讲解： 首先，"数据结构套路题.pdf"很可能...
811--《数据结构》考研大纲 南京邮电大学
10-11
811--《数据结构》考研大纲 南京邮电大学 南邮 C C++ 陈慧南
考研数据结构算法总结
02-18
考研数据结构经典算法总结，很全的，很强大。。
考研数据结构常用算法
11-26
408计算机考研数据结构常用算法背诵，经典常考算法代码，适合考试前冲刺背诵。预祝考研成功！
数据结构经典算法（考研需要的都包括）
10-24
数据结构经典算法。基本上需要的都有。考研需要的都包括。
数据结构考研必背算法5星.pdf
05-12
本文档是针对考研专业课《数据结构》所编写的，是对考研数据结构的核心算法进行总结，我们知道，不管是统考还是非统考，都会涉及至少10分的算法题（非统考至少25分），而这些题的答案都是在一些经典算法的思想上进行改进的，本文总结出必须要熟练掌握的算法，这些算法不管是考研初期还是冲刺，都应该高度重视，只要对这些代码进行熟练掌握，才能随机应变，希望对大家有所帮助；
考研学习之数据结构排序算法学习
过客璇璇的博客
10-18 283
一.直接插入排序 1.1代码 #include <stdio.h> /** 直接插入排序 */ void insertSort(int A[],int n){ int i,j; //依次将A[2]~A[n] 插入到前面已排序的序列中 for(i=2;i<=n;i++){ //若 A[i]关键码小于前去，将A[i]插入有序表 if(A[i]<A[i-1]){ A[0] = A[i];//复制哨兵，A[0]不存放元素 //从后往前寻找待插入的位
mark_j 的考研数据结构算法
weixin_43897603的博客
05-21 109
考研算法之找出数组最大子序列长度 下面看看这道题 首先看到这道题的时候有点懵，刚一开始想到的是最大递增子序列应该是3，7，101.为什么又是2，3，7，101. 然后又去仔细看了下题目（意思是可以删除，只要是递增就行了） 然后我想的是栈 ...
考研心得：考研数据结构算法大全
热门推荐
PCGuo999的博客
04-22 1万+
本人考研的算法笔记，包含考研数据结构会涉及到的算法，全部掌握让你考研算法题稳稳拿下！！
数据结构手写算法整理（考研）
永恒之蓝的博客
08-16 1093
数据结构手写代码
数据结构考研复习：选择题解析与算法效率探究
"王道数据结构考研复习指导2022年选择题，涵盖数据结构基本概念、算法和算法评价等内容，包括多项选择题，涉及数据元素、数据对象、数据关系、抽象数据类型、线性与非线性数据结构、逻辑结构与存储结构的关系、数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值