考研常考算法总汇

最新推荐文章于 2023-05-19 11:15:30 发布

骑码找马

最新推荐文章于 2023-05-19 11:15:30 发布

阅读量4.4k

点赞数 42

分类专栏：数据结构

本文链接：https://blog.csdn.net/weixin_42034217/article/details/89076920

版权

本文详细介绍了二叉树的各种遍历算法（前序、中序、后序、层次遍历），树的遍历算法，霍夫曼树与霍夫曼编码，字符串匹配的KMP算法，图的最小生成树算法（Prim和Kruskal），最短路径算法（Dijkstra和Floyd），拓扑排序和关键路径算法，以及排序算法（插入、冒泡、选择、堆、归并、基数排序和快速排序）。这些是考研中常见的数据结构与算法知识点。

摘要由CSDN通过智能技术生成

以下代码应该自己去写，不会的再翻书，后面参考代码仅供参考！

二叉树前序递归与非递归遍历算法
二叉树中序递归与非递归遍历算法
二叉树后序递归与非递归遍历算法
二叉树层次遍历算法
树的前序遍历算法
树的后序遍历算法
霍夫曼树建立与霍夫曼编码算法
KMP算法
DFS深度遍历算法
BFS广度遍历算法
普里姆（Prim）最小生成树算法
克鲁斯卡尔（Kruskal）最小生成树算法
Dijkstra最短路径算法
Floyd最短路径算法
拓扑排序算法
关键路径算法
直接插入排序算法
冒泡排序算法
快速排序算法
简单选择排序算法
堆排序算法
而路归并排序算法
基数排序算法
二分法查找算法

二叉树前序递归与非递归遍历算法

//递归方式前序遍历
void PreOrderTraverse(BiTree T)
{
    if (T == NULL)
        return;
/*此处表示对遍历的树结点进行的操作，根据你自己的要求进行操作，这里只是输出了结点的数据*/
    //operation1(T->data);
    operation2(T->data); 
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}


//非递归方式前序遍历
/* 思路：将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。*/
void PreOrder(BiTree T){
    stack<BiTree> stack;
    //p是遍历指针  
    BiTree p = T;
    //p不为空或者栈不空时循环
    while (p || !stack.empty())
{
        if (p != NULL)
                 {
            //存入栈中  
            stack.push(p);
            //对树中的结点进行操作
            operation1(p->data);
             //遍历左子树  
            p = p->lchild;
         }
        else
                {
                 //退栈  
            p = stack.top();
            stack.pop();
            //访问右子树  
            p = p->rchild;
        }
    } 
}

二叉树中序递归与非递归遍历算法

//递归方式中序遍历二叉树

void InOrderTraverse(BiTree T,int level)
{
	if(T==NULL)
		return;
	InOrderTraverse(T->lchild,level+1);
	//operation1(T->data);
	operation2(T->data, level); //输出了层数
	InOrderTraverse(T->rchild,level+1);
}


//非递归中序遍历
void InOrder(BiTree T)
{
    stack<BiTree> stack;
    //p是遍历指针  
    BiTree p = T;
    //p不为空或者栈不空时循环  
    while (p || !stack.empty())
       {
        if (p != NULL)
                  {
            //存入栈中  
            stack.push(p);
            //遍历左子树  
            p = p->lchild;
         }
        else
                {
            //退栈
            p = stack.top();
            operation1(p->data); //对树中的结点进行操作
            stack.pop();
            //访问右子树  
            p = p->rchild;
        }
    } 
}

二叉树后序递归与非递归遍历算法

//递归方式后序遍历二叉树

void PostOrderTraverse(BiTree T,int level)
{
	if(T==NULL)
		return;
	PostOrderTraverse(T->lchild,level+1);
	PostOrderTraverse(T->rchild,level+1);

	//operation1(T->data);
	operation2(T->data, level); //输出了层数
}



//非递归后序遍历
typedef struct BiTNodePost{
    BiTree biTree;
    char tag;
}BiTNodePost, *BiTreePost;

void PostOrder(BiTree T)
{
    stack<BiTreePost> stack;
    //p是遍历指针  
    BiTree p = T;
    BiTreePost BT;
    //栈不空或者p不空时循环  
    while (p != NULL || !stack.empty())
        {
        //遍历左子树  
        while (p != NULL)
               {
            BT = (BiTreePost)malloc(sizeof(BiTNodePost));
            BT->biTree = p;
            //访问过左子树  
            BT->tag = 'L';
            stack.push(BT);
            p = p->lchild;
        }
        //左右子树访问完毕访问根节点  
        while (!stack.empty() && (stack.top())->tag == 'R')
                {
            BT = stack.top();
            //退栈  
            stack.pop();
            p=BT->biTree;
            cout<<BT->biTree->data<<" ";
        }
        //遍历右子树  
        if (!stack.empty())
                {
            BT = stack.top();
            //访问过右子树  
            BT->tag = 'R';
            p = BT->biTree;
            p = p->rchild;
        }
    }
}

二叉树层次遍历算法

//层次遍历  
void LevelOrder(BiTree T)
{
    BiTree p = T; 
    queue<BiTree> queue;
    //根节点入队  
    queue.push(p);
    //队列不空循环  
    while (!queue.empty())
       {
        //对头元素出队  
        p = queue.front();
        //访问p指向的结点  
        operation1(p->data);
        //退出队列  
        queue.pop();
        //左孩子不为空，将左孩子入队  
        if (p->lchild != NULL)
                {
            queue.push(p->lchild);
        }
        //右孩子不空，将右孩子入队  
        if (p->rchild != NULL)
                {
            queue.push(p->rchild);
        }
    }
}

树的前、中、后序遍历算法

// -------- 树的 孩子-兄弟 存储表示法 ------
struct Node{
	char data;
	Node *child;
	Node *brother;
}*CSTree;


void PreOrder(Node *head)		// 前序遍历
{
	if(head==NULL)return;
	printf("%c ",head->data);
	PreOrder(head->child);
	PreOrder(head->brother);
}

void InOrder(Node *head)		// 中序遍历
{
	if(head==NULL)return;
	InOrder(head->child);
	printf("%c ",head->data);
	if(head->child)InOrder(head->child->brother);
}

void PostOrder(Node *head)		// 后序遍历
{
	if(head==NULL)return;
	PostOrder(head->child);
	printf("%c ",head->data);
	PostOrder(head->brother);
}

霍夫曼树建立与霍夫曼编码算法

//haffman 树的结构
typedef struct
{
    //叶子结点权值
    unsigned int weight;
    //指向双亲，和孩子结点的指针
    unsigned int parent;
    unsigned int lChild;
    unsigned int rChild;
} Node, *HuffmanTree;

//动态分配数组，存储哈夫曼编码
typedef char *HuffmanCode;

//选择两个parent为0，且weight最小的结点s1和s2的方法实现
//n 为叶子结点的总数，s1和 s2两个指针参数指向要选取出来的两个权值最小的结点
void select(HuffmanTree *huffmanTree, int n, int *s1, int *s2)
{
    //标记 i
    int i = 0;
    //记录最小权值
    int min;
    //遍历全部结点，找出单节点
    for(i = 1; i <= n; i++)
    {
        //如果此结点的父亲没有，那么把结点号赋值给 min，跳出循环
        if((*huffmanTree)[i].parent == 0)
        {
            min