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

news2024/11/16 12:53:18

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);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/150803.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数组常用方法总结 (1) ：pop / push / shift / unshift

数组常用方法总结 (1) ：pop / push / shift / unshift

pop 从尾部删除一项。改变原有数组。返回删除掉的内容。 <template><div class"myBlock"><div class"tableBlock"><div class"title">{{ newObject ? "操作后的数组" : "操作前的数组" }}</d…
阅读更多...
从0到1完成一个Vue后台管理项目（十、列表API封装、Table列表渲染、表格数据转换）

从0到1完成一个Vue后台管理项目（十、列表API封装、Table列表渲染、表格数据转换）

往期 从0到1完成一个Vue后台管理项目&#xff08;一、创建项目&#xff09; 从0到1完成一个Vue后台管理项目&#xff08;二、使用element-ui&#xff09; 从0到1完成一个Vue后台管理项目&#xff08;三、使用SCSS/LESS&#xff0c;安装图标库&#xff09; 从0到1完成一个Vu…
阅读更多...
docker安装及安装过程中遇到的问题

docker安装及安装过程中遇到的问题

安装Docker-CE 备注&#xff1a;Docker 安装&#xff0c;请参考 Docker 官⽅⽂档: Install Docker Engine on Ubuntu | Docker Documentation 也可参照如下命令进行快速安装。 Ubuntu 卸载旧版本&#xff08;视需要&#xff09; $ sudo apt-get remove docker docker-engin…
阅读更多...
Java并发（4）- synchronized与CAS

Java并发（4）- synchronized与CAS

引言 上一篇文章中我们说过&#xff0c;volatile通过lock指令保证了可见性、有序性以及“部分”原子性。但在大部分并发问题中&#xff0c;都需要保证操作的原子性&#xff0c;volatile并不具有该功能&#xff0c;这时就需要通过其他手段来达到线程安全的目的&#xff0c;在Ja…
阅读更多...
因子图--isam相关内容总结

因子图--isam相关内容总结

编辑切换为居中添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09;编辑切换为居中添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09;平方根法--通过平方根的方法&#xff0c;发现矩阵新增加的变量都会出现在最后一行。Givens旋转方法求解Ax…
阅读更多...
Linux环境下，java调用C/C++动态库

Linux环境下，java调用C/C++动态库

目录 一、环境准备 1、安装gcc/g 2、下载jdk库并配置运行环境 二、配合Java程序创建C程序的动态库 1、生成要求清单 2、交给C 去实现 (1) 接口函数实现 (2) 创建动态库 (3) 检查动态库是否正常链接 3、测试&#xff1a;Java程序调用C动态库 一、环境准备 既然是同时…
阅读更多...
百万级数据以Excel形式导出

百万级数据以Excel形式导出

(1).主要考虑到两个方面&#xff0c;第一个方面是内存溢出问题&#xff0c;所以选用阿里的EasyExcel因为它对POI进行了封装功能强大&#xff1b;第二个方面是由于excel版本导致Sheet存储容量不一样&#xff0c;cexcel2003(.xls)每个Sheet只能存6万多条数据而cexcel2007(xlsx)能…
阅读更多...
【自学Python】Python布尔型(bool)

【自学Python】Python布尔型(bool)

Python布尔型(bool) Python布尔型(bool)教程 Python 布尔类型也叫 bool 类型&#xff0c;Python 布尔类型取值为 True 和 False。Python bool 类型的 True 表示条件为真&#xff0c; False 表示条件为假。 Python布尔型(bool) Python 中的布尔类型可以当做 整数 来对待&…
阅读更多...
LeetCode 287. 寻找重复数难度中等2004

LeetCode 287. 寻找重复数难度中等2004

&#x1f308;&#x1f308;&#x1f604;&#x1f604;欢迎来到茶色岛独家岛屿&#xff0c;本期将为大家揭晓LeetCode 287. 寻找重复数难度中等2004&#xff0c;做好准备了么&#xff0c;那么开始吧。&#x1f332;&#x1f332;&#x1f434;&#x1f434;一、题目名称LeetCo…
阅读更多...
怎么在Gitee（码云）上传一个项目（一分钟）

怎么在Gitee（码云）上传一个项目（一分钟）

目录怎么在Gitee&#xff08;码云&#xff09;上传一个项目1、工具1.1、Git1.2、新建仓库2、上传流程3、回答上传项目流程中的几个疑问&#xff1f;怎么在Gitee&#xff08;码云&#xff09;上传一个项目 1、工具 1.1、Git 在Git官网或者利用镜像下载符合自己电脑操作系统版…
阅读更多...
小众企业在选购低代码平台时需要注意什么

小众企业在选购低代码平台时需要注意什么

编者按&#xff1a;企业个性化定制需求如何实现&#xff1f;本文介绍了小众企业在选择低代码平台需要注意的点&#xff0c;帮助企业选出更合适得的软件平台。关键词&#xff1a;源码交付&#xff0c;数据整合&#xff0c;前后端分离&#xff0c;私有化部署&#xff0c;安全技术…
阅读更多...
IB生物笔记：细胞学说

IB生物笔记：细胞学说

国际学校生物老师从0开始解读IB生物&#xff0c;感兴趣的同学记得收藏哦~IB生物分为SL(standard level)和HL(higher level)SL有6个topic∶细胞生物&#xff0c;分子生物&#xff0c;遗传学&#xff0c;生态学&#xff0c;物种进化以及多样性和人体生理。HL除了上述6个topic外还…
阅读更多...
【pat】出租

【pat】出租

下面是新浪微博上曾经很火的一张图&#xff1a;一时间网上一片求救声&#xff0c;急问这个怎么破。其实这段代码很简单&#xff0c;index数组就是arr数组的下标&#xff0c;index[0]2 对应 arr[2]1&#xff0c;index[1]0 对应 arr[0]8&#xff0c;index[2]3 对应 arr[3]0&#…
阅读更多...
年底清货刻不容缓！3天清空库存的服装老板是怎么做到的？

年底清货刻不容缓！3天清空库存的服装老板是怎么做到的？

春节气氛越来越浓厚&#xff0c; 服装人的心情却是越来越着急——眼看着要过年了&#xff0c;气候也马上回暖了&#xff0c;我店里的库存可咋办&#xff1f;做服装零售的老板都知道&#xff0c;大部分时候压垮服装店的不是淡季、不是租金、不是人工费&#xff0c;而是库存积压。…
阅读更多...
Java IO流 - 对象序列化和对象反序列化

Java IO流 - 对象序列化和对象反序列化

文章目录序列化对象对象序列化对象反序列化序列化对象 对象序列化 对象序列化概念: 作用&#xff1a;以内存为基准&#xff0c;把内存中的对象存储到磁盘文件中去&#xff0c;称为对象序列化。 使用到的流是对象字节输出流&#xff1a;ObjectOutputStream ObjectOutputStream构…
阅读更多...
Navicat远程连接ubuntu数据库

Navicat远程连接ubuntu数据库

关于这个问题&#xff0c;我看许多博主也给出了解答&#xff0c;但作者此次遇到的问题也是略微特殊&#xff0c;希望其他人遇到同样的问题能得到启发。 首先是MySQL的安装&#xff0c;我是用的是Xubuntu系统&#xff0c;按照ubuntu系统安装MySQL的步骤即可。如下&#xff1a; …
阅读更多...
关系运算符shell

关系运算符shell

关系运算符只支持数字&#xff0c;不支持字符串&#xff0c;除非字符串的值是数字。下表列出了常用的关系运算符&#xff0c;假定变量 a 为 10&#xff0c;变量 b 为 20&#xff1a;运算符说明举例-eq检测两个数是否相等&#xff0c;相等返回 true。[ $a -eq $b ] 返回 false。…
阅读更多...
Mask RCNN网络源码解读（Ⅲ） --- FCN网络

Mask RCNN网络源码解读（Ⅲ） --- FCN网络

目录 1.FCN网络简介 2.FCN-32S 3.FCN-16S 4.FCN-8S 5.膨胀卷积&#xff08;空洞卷积&#xff09; 6.pytorch中FCN的实现 6.1 代码地址 1.FCN网络简介 首个端对端的针对像素级预测的全卷积网络。全卷积网络即将分类网络中的全连接层全部替换为卷积层。 从数据可以看出…
阅读更多...
微服务自动化管理【etcd快速集群】

微服务自动化管理【etcd快速集群】

概述 1.etcd构建自身高可用集群主要有三种形式&#xff1a; 静态发现 预先已知etcd集群中有哪些节点&#xff0c;在启动时通过–initial-cluster参数直接指定好etcd的各个节点地址 etcd动态发现 静态配置前提是在搭建集群之前已经提前知道各节点的信息&#xff0c;而实际应用中…
阅读更多...
使用VS Code创建第一个Flutter工程

使用VS Code创建第一个Flutter工程

一、前言 你可以使用任意文本编辑器&#xff0c;再结合命令行工具来开发 Flutter 应用。然而&#xff0c;我们推荐使用本文接下来介绍的编辑器插件以获取更好的开发体验。这些插件提供了代码补全、代码高亮、widget 辅助编辑的功能&#xff0c;以及为项目的运行和调试提供支持…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023