数据结构与算法，c语言实现

weixin_64248798

已于 2022-07-18 20:22:09 修改

阅读量326

点赞数 1

文章标签： c语言数据结构算法

于 2022-07-18 20:19:25 首次发布

本文链接：https://blog.csdn.net/weixin_64248798/article/details/125859253

版权

这篇博客介绍了如何使用C语言实现二项队列，包括初始化、插入、删除最小元素等操作，并展示了归并排序的详细过程，包括归并排序的递归部分和非递归部分。内容涵盖了数据结构与算法的基础知识，适合学习数据结构的读者参考。

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

代码：数据结构与算法代码，c语言实现-算法与数据结构文档类资源-CSDN下载

部分代码：

#ifndef __BINQUEUE_H__
#define __BINQUEUE_H__
#define CONFIG
#include "../Config.h"
#define MaxTrees (16)
#define Infinity (65535)
#define Capacity (65535)

typedef struct bin_node
{
    ElementType Element;
    Position LeftChild;
    Position NextSibling;
} BinNode;
typedef BinNode *BinTree;
typedef BinNode *Position;

typedef struct collection
{
    int CurrentSize;
    BinTree TheTrees[MaxTrees];
} Collection;
typedef Collection *BinQueue;

BinQueue Initialize(void);
int IsEmpty(BinQueue H);
BinQueue Merge(BinQueue H1, BinQueue H2);
BinQueue Insert(ElementType X, BinQueue H);
ElementType DeleteMin(BinQueue H);

#endif

//删除并返回二项队列中最小元素
ElementType DeleteMin(BinQueue H)
{
    int i, j;
    int MinTree;
    BinQueue DeletedQueue;
    Position DeletedTree, OldRoot;
    ElementType MinItem;

    if (IsEmpty(H))
    {
        Error("Empty binomial queue");
        return -Infinity;
    }

    MinItem = Infinity;
    for (i = 0; i < MaxTrees; i++)
    {
        if (H->TheTrees[i] && H->TheTrees[i]->Element < MinItem)
        {
            MinItem = H->TheTrees[i]->Element;
            MinTree = i;
        }
    }

    DeletedTree = H->TheTrees[MinTree];
    OldRoot = DeletedTree;
    DeletedTree = DeletedTree->LeftChild;
    free(OldRoot);

    DeletedQueue = Initialize();
    DeletedQueue->CurrentSize = (1 << MinTree) - 1;
    for (j = MinTree - 1; j >= 0; j--)
    {
        DeletedQueue->TheTrees[j] = DeletedTree;
        DeletedTree = DeletedTree->NextSibling;
        DeletedQueue->TheTrees[j]->NextSibling = NULL;
    }

    H->TheTrees[MinTree] = NULL;
    H->CurrentSize -= DeletedQueue->CurrentSize + 1;

    Merge(H, DeletedQueue);
    return MinItem;
}

/* ------------------归并排序------------------ */
//合并部分
void Merge(ElementType A[], ElementType TmpArray[],
           int Lpos, int Rpos, int RightEnd)
{
    int i, LeftEnd, NumElements, TmpPos;

    LeftEnd = Rpos - 1;
    TmpPos = Lpos;
    NumElements = RightEnd - Lpos + 1;

    /* main loop */
    while (Lpos <= LeftEnd && Rpos <= RightEnd)
        if (A[Lpos] <= A[Rpos])
            TmpArray[TmpPos++] = A[Lpos++];
        else
            TmpArray[TmpPos++] = A[Rpos++];

    while (Lpos <= LeftEnd) /* Copy rest of first half */
        TmpArray[TmpPos++] = A[Lpos++];
    while (Lpos <= LeftEnd) /* Copy rest of second half */
        TmpArray[TmpPos++] = A[Rpos++];

    /* Copy TmpArray back */
    for (i = 0; i < NumElements; i++, RightEnd--)
        A[RightEnd] = TmpArray[RightEnd];
}
//递归部分
void MSort(ElementType A[], ElementType TmpArray[],
           int Left, int Right)
{
    int Center;

    if (Left < Right)
    {
        Center = (Left + Right) / 2;
        MSort(A, TmpArray, Left, Center);
        MSort(A, TmpArray, Center + 1, Right);
        Merge(A, TmpArray, Left, Center + 1, Right);
    }
}
//归并排序
void MergeSort(ElementType A[], int N)
{
    ElementType *TmpArray;

    if ((TmpArray = (ElementType *)malloc(N * sizeof(ElementType))) == NULL)
        FatalError("Out of space!!!");
    MSort(A, TmpArray, 0, N - 1);
    free(TmpArray);
}