迎战下周自考数据结构实践科目

编写完成重点数据结构和算法： 0.链表 1.栈 2.队列 3.二叉树数据结构和构建 4.前序中序后序遍历二叉树 5.构建哈夫曼树（最优二叉树） 6.图数据结构，图的深度优先遍历和广度优先遍历 7.拓扑排序 8.直接插入排序 9.希尔排序 10.希尔排序 11.冒泡排序 12.快速排序 13.直接选择排序 14.堆排序 15.归并排序 16.箱排序和基数排序 17.顺序查找，二分查找，索引顺序查找 

 

// ExamTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "stdlib.h"
#include <string>
/************************************************************************/
/*                栈数据结构                                              */
/************************************************************************/
#define StackSize 1024    //栈大小
typedef char DataType;
typedef struct  
{
    DataType data[StackSize];    //栈数组
    int top;    //栈顶索引
}Stack;

//清空栈
void InitStack(Stack * s)
{
    if(s == NULL)
        return;
    s->top = -1;
}
//判断是否满栈
bool StatckEmpty(Stack* s)
{
    if(s == NULL)
        return false;
    return s->top == StackSize-1;
}
//进栈
void PushStack(Stack* s,DataType x)
{
    if(s == NULL)
        return;
    if(StatckEmpty(s))
        return;
    else
    {
        //规定当前入栈完成后指向当前的数据
        s->top = s->top +1;
        s->data[s->top] = x;
    }
}
//出栈
DataType PopStack(Stack* s)
{
    if(s == NULL)
    {
        exit(0);
    }
    if(StatckEmpty(s))
    {
        printf("Stack is empty .\n");
        exit(0);
    }
    else
    {
        return s->data[s->top--]; //先用后减
    }
}

//获取栈顶元素
DataType GetTop(Stack* s)
{
    if(s == NULL)
    {
        exit(0);
    }
    if(StatckEmpty(s))
    {
        printf("Stack empty . \n");
        exit(0);
    }
    else
    {
        return s->data[s->top];
    }
}

/************************************************************************/
/*                队列数据结构（循环队列）                              */
/************************************************************************/
#define QUEUESIZE 1024
typedef struct
{
    DataType data[QUEUESIZE];    //队列数组
    int front;    //队列头
    int rear;    //队列尾部
}Queue; 

//初始化队列
void InitQueue(Queue* q)
{
    if(q == NULL)
        return;
    q->front = 0;
    q->rear = 0;
}

//判断栈是否为空
bool QueueEmpty(Queue* q)
{
    if(q == NULL)
        return false;
    else
        return q->front == q->rear;
}

//判断队列是否满
bool QueueFull(Queue* q)
{
    if(q == NULL)
        return false;
    return (q->rear + 1) % QUEUESIZE == q->front; 
}

//入队列
void InsertQueue(Queue* q,DataType x)
{
    if(q == NULL)
        return;
    if(QueueFull(q))
    {
        printf("Queue Full !\n");
    }
    else
    {
        //队尾添加，队尾指向后面一个为空的
        q->data[q->rear] = x;
        q->rear = (q->rear + 1) % QUEUESIZE;
    }
}

//出队列
DataType DelQueue(Queue* q)
{
    DataType x;
    if(QueueEmpty(q))
    {
        printf("Queue is Empty \n");
        exit(0);
    }
    else
    {
        x = q->data[q->front];
        q->front = (q->front + 1) % QUEUESIZE;
        return x;
    }
}

//取队头元素
DataType GetFrontData(Queue* q)
{
    if(QueueEmpty(q))
    {
        printf("queue is empty!\n");
        exit(0);
    }
    else
    {
        return q->data[q->front];
    }
}

//取队尾元素
DataType GetRearData(Queue* q)
{
    if(QueueEmpty(q))
    {
        printf("queue is empty !");
        exit(0);
    }
    else
    {
        return q->data[q->rear];
    }
}
/* 字符串匹配（判断一个子串是否是另一个字符串的子串）*/
bool IsSubString()
{
    char parentString[1024];
    char subString[1024];
    printf("please input parent string!\n");
    scanf("%s",parentString);
    printf("please input sub string!\n");
    scanf("%s",subString);

    int nParent = strlen(parentString);
    int nSub = strlen(subString);
    /*
        1. 如果子串的字符数量大于父串的数量则匹配失败
        2. 子串的数量大于父串的数量，匹配比较。
    */
    if(nSub > nParent)
        return false;
    for(int i = 0; i <= nParent; i++)
    {
        int k = i;
        if((nParent - k) < nSub)
            return false;
        for(int j = 0; j <= nSub; j++)
        {
            if(subString[j] == parentString[k])
            {
                if(j == nSub -1)
                    return true;
                k++;
            }
            else
            {
                break;
            }
        }
    }
    return false;
}
typedef struct BinNode
{
    DataType data;
    BinNode* lChild;
    BinNode* rChild;
}BinNTree;

typedef BinNode* BinTree;
char* str = "ABDH#K###E##CFI###G#J##";
//构造一个二叉树，使用前序创建，#表示对应的节点为NULL
int index = 0;
void creatBinTree(BinNTree** t)
{
    if( (*t) = (BinNTree*) malloc(sizeof(BinNTree)))
    {
        char ch = str[index++];
        if(ch == '#')
        {
            (*t) = NULL;
            return;
        }
        (*t)->data = ch;
        creatBinTree(&(*t)->lChild);
        creatBinTree(&(*t)->rChild);
    }
};

//清空二叉树
void clearBinTree(BinNTree* t)
{
    if(t == NULL)
        return;

    if(t->lChild)
        clearBinTree(t->lChild);
    if(t->rChild)
        clearBinTree(t->rChild);
    free(t);
}
//求二叉树深度
int getBinTreeDeep(BinNTree* & t)
{
    int i = 0;
    int j = 0;
    if(!t)
        return 0;
    if(t->lChild)
        i = getBinTreeDeep(t->lChild);
    if(t->rChild)
        j = getBinTreeDeep(t->rChild);
    return i > j? i+1:j+1;
}

//前序遍历
void preOrder(BinNTree* t)
{
    if(t == NULL)
        return;
    printf("%c ",t->data);
    preOrder(t->lChild);
    preOrder(t->rChild);
}

//中序遍历
void inOrder(BinNTree* t)
{
    if(t == NULL)
        return;
    inOrder(t->lChild);
    printf("%c ",t->data);
    inOrder(t->rChild);
}

//后序遍历
void postOrder(BinNTree* t)
{
    if(t == NULL)
        return;
    postOrder(t->lChild);
    postOrder(t->rChild);
    printf("%c ",t->data);
}

//查找二叉树中是否存在某值
bool find(BinNTree* t,DataType data)
{
    if(t == NULL)
        return false;
    if(t->data == data)
        return true;
    if(find(t->lChild,data))
        return true;
    return find(t->rChild,data);

}

int _tmain(int argc, _TCHAR* argv[])
{
    /*    // 字符串匹配函数测试
    while (1)
    {
        if(IsSubString())
        {
            printf("this is subString for parentString!\n");
        }
        else
        {
            printf("sorry,this is not subString for parentString\n");
        }
    }
    */

    /************************************************************************/
    /*            二叉树测试                                                  */
    /************************************************************************/
    BinTree t = NULL;
    creatBinTree(&t);
    int nDept = getBinTreeDeep(t);
    printf("this BinTree Depth is: %d\n",nDept);
    printf("前序遍历结果:");
    preOrder(t);
    printf("\n后序遍历结果:");
    postOrder(t);
    printf("\n中序遍历结果:");
    inOrder(t);
    getchar();
}