【经典算法】PTA_数据结构与算法题目集（中文）之函数题

　　PTA_数据结构与算法题目集（中文）　　传送门

　　 6-1 单链表逆转 (20 分)　　传送门

List Reverse(List L)
{
    List p, q;
    p = L;
    q = L;
    L = NULL;
    while (p)
    {
        p = p->Next;
        q->Next = L;
        L = q;
        q = p;
    }
    return L;
}

Gary.c

　　6-2 顺序表操作集 (20 分)　　传送门

//创建并返回一个空的线性表；
List MakeEmpty()
{
    List L;
    L = (List)malloc(sizeof(struct LNode));
    L->Last = -1; //因为插入一个时，Last++，此时需为-1
    return L;
}

//返回线性表中X的位置。若找不到则返回ERROR；
Position Find(List L, ElementType X)
{
    for (int i = 0; i <= L->Last; i++)
    {
        if (L->Data[i] == X)
            return i;
    }
    return ERROR;
}

//将X插入在位置P并返回true。若空间已满，则打印“FULL”并返回false；如果参数P指向非法位置，则打印“ILLEGAL POSITION”并返回false；
bool Insert(List L, ElementType X, Position P)
{
    // 表满
    if (L->Last == MAXSIZE - 1)
    {
        printf("FULL");
        return false;
    }
    // 非法位置
    if (P > L->Last + 1 || P < 0)
    {
        printf("ILLEGAL POSITION");
        return false;
    }
    // 右移P后面的
    for (int i = L->Last + 1; i > P; --i)
    {
        L->Data[i] = L->Data[i - 1];
    }

    L->Data[P] = X;
    L->Last++;
    return true;
}
//将位置P的元素删除并返回true。若参数P指向非法位置，则打印“POSITION P EMPTY”（其中P是参数值）并返回false。
bool Delete(List L, Position P)
{
    // 非法位置
    if (P > L->Last || P < 0)
    {
        printf("POSITION %d EMPTY", P);
        return false;
    }

    for (int i = P; i < L->Last; i++)
    {
        L->Data[i] = L->Data[i + 1];
    }
    L->Last--;
    return true;
}

Gary.c

　　6-3 求链式表的表长 (10 分)　　传送门

Length( List L ){
    int res=0;
    while(L!=NULL){
        res++;
        L=L->Next;
    }
    return res;
}

Gary.c

　　6-4 链式表的按序号查找 (10 分)　　传送门

//L是给定单链表，函数FindKth要返回链式表的第K个元素。如果该元素不存在，则返回ERROR。
ElementType FindKth(List L, int K)
{
    int i = 0;
    while (L != NULL)
    {
        if (i+1 == K)
            return L->Data;
        i++;
        L=L->Next;
    }
    return ERROR;
}

Gary.c

　　6-5 链式表操作集 (20 分)　　传送门

//返回线性表中首次出现X的位置。若找不到则返回ERROR；
Position Find(List L, ElementType X)
{
    while (L != NULL)
    {
        if (L->Data == X)
            return L;
        L = L->Next;
    }
    return ERROR;
}

//将X插入在位置P指向的结点之前，返回链表的表头。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回ERROR；
List Insert(List L, ElementType X, Position P)
{
    List node = (List)malloc(sizeof(struct LNode));
    node->Data = X;
    node->Next = NULL;
    List q = L;
    if (P == L)
    {
        node->Next = q;
        return node;
    }

    while (q != NULL)
    {
        if (q->Next == P)
        {
            List temp=q->Next;
            q->Next = node;
            node->Next = temp;
            return L;
        }
        q=q->Next;
    }
    printf("Wrong Position for Insertion\n");
    return ERROR;
}

//将位置P的元素删除并返回链表的表头。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回ERROR。
List Delete(List L, Position P)
{
    if (L == P)
    {
        L = L->Next;
        return L;
    }

    List q = L;
    while (q != NULL)
    {
        if(q->Next==P){
            List temp=q->Next->Next;
            q->Next=temp;
            return L;
        }
        q=q->Next;
    }
    printf("Wrong Position for Deletion\n");
    return ERROR;
}

Gary.c

　　6-6 带头结点的链式表操作集 (20 分)　　传送门

//创建并返回一个空的线性表；
List MakeEmpty()
{
    List L = (List)malloc(sizeof(struct LNode));
    L->Data = NULL;
    L->Next = NULL;
    return L;
}

//返回线性表中首次出现X的位置。若找不到则返回ERROR；
Position Find(List L, ElementType X)
{
    L = L->Next;
    while (L != NULL)
    {
        if (L->Data == X)
            return L;
        L = L->Next;
    }
    return ERROR;
}

//将X插入在位置P指向的结点之前，返回true。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回false；
bool Insert(List L, ElementType X, Position P)
{
    List node = (List)malloc(sizeof(struct LNode));
    node->Data = X;
    node->Next = NULL;
    List q = L;

    while (q != NULL)
    {
        if (q->Next == P)
        {
            List temp = q->Next;
            q->Next = node;
            node->Next = temp;
            return true;
        }
        q = q->Next;
    }
    printf("Wrong Position for Insertion\n");
    return false;
}

//将位置P的元素删除并返回true。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回false。
bool Delete(List L, Position P)
{
    List q = L;
    while (q != NULL)
    {
        if (q->Next == P)
        {
            List temp = q->Next->Next;
            q->Next = temp;
            return true;
        }
        q = q->Next;
    }
    printf("Wrong Position for Deletion\n");
    return false;
}

Gary.c

　　6-7 在一个数组中实现两个堆栈 (20 分)　　传送门

//如果堆栈已满，Push函数必须输出“Stack Full”并且返回false；如果某堆栈是空的，则Pop函数必须输出“Stack Tag Empty”（其中Tag是该堆栈的编号），并且返回ERROR。
Stack CreateStack(int MaxSize)
{
    Stack sta = (Stack)malloc(sizeof(struct SNode));
    sta->Data = (ElementType*)malloc(MaxSize*sizeof(ElementType));
    sta->Top1 = -1;
    sta->Top2 = MaxSize;
    sta->MaxSize = MaxSize;
    return sta;
}
bool Push(Stack S, ElementType X, int Tag)
{
    if (S == NULL)
        return false;
    if (S->Top1 + 1 == S->Top2)
    {
        printf("Stack Full\n");
        return false;
    }
    if (Tag == 1)
    {
        S->Data[++S->Top1] = X;
    }
    else
    {
        S->Data[--S->Top2] = X;
    }
    return true;
}
ElementType Pop(Stack S, int Tag)
{
    if (S == NULL)
        return ERROR;
    if (Tag == 1)
    {
        if (S->Top1 == -1)
        {
            printf("Stack %d Empty\n", Tag);
            return ERROR;
        }
        return S->Data[S->Top1--];
    }
    else
    {
        if (S->Top2 == S->MaxSize)
        {
            printf("Stack %d Empty\n", Tag);
            return ERROR;
        }
        return S->Data[S->Top2++];
    }
}

Gary.c

　　6-8 求二叉树高度 (20 分)　　传送门

int GetHeight(BinTree BT)
{
    if (BT == NULL)
        return 0;

    int leftH = GetHeight(BT->Left);
    int rightH = GetHeight(BT->Right);
    if (leftH > rightH)
        return leftH + 1;
    else
        return rightH + 1;
}

Gary.c

　　6-9 二叉树的遍历 (25 分)　　传送门

void InorderTraversal(BinTree BT)
{
    if (BT == NULL)
        return;
    InorderTraversal(BT->Left);
    printf(" %c", BT->Data);
    InorderTraversal(BT->Right);
}
void PreorderTraversal(BinTree BT)
{
    if (BT == NULL)
        return;
    printf(" %c", BT->Data);
    PreorderTraversal(BT->Left);
    PreorderTraversal(BT->Right);
}
void PostorderTraversal(BinTree BT)
{
    if (BT == NULL)
        return;
    PostorderTraversal(BT->Left);
    PostorderTraversal(BT->Right);
    printf(" %c", BT->Data);
}
void LevelorderTraversal(BinTree BT)
{
    BinTree que[1000];
    int top = -1;
    int tail = -1;
    if (BT)
        que[++tail] = BT;
    while (top < tail)
    {
        BinTree bt = que[++top];
        printf(" %c",  bt->Data);
        if (bt->Left)
            que[++tail] = bt->Left;
        if (bt->Right)
            que[++tail] = bt->Right;
    }
}

Gary.c

　　6-10 二分查找 (20 分)　　传送门

Position BinarySearch(List L, ElementType X)
{
    int beg = 1;
    int end = L->Last;
    while (beg <= end)
    {
        int mid = (beg + end) / 2;
        if (L->Data[mid] == X)
            return mid;
        else if (L->Data[mid] < X)
            beg = mid + 1;
        else
            end = mid - 1;
    }
    return NotFound;
}

Gary.c

　　6-11 先序输出叶结点 (15 分)　　传送门

//函数PreorderPrintLeaves应按照先序遍历的顺序输出给定二叉树BT的叶结点，格式为一个空格跟着一个字符。
void PreorderPrintLeaves(BinTree BT)
{
    if (BT == NULL)
        return;
    if (BT->Left == NULL && BT->Right == NULL)
        printf(" %c", BT->Data);
    PreorderPrintLeaves(BT->Left);
    PreorderPrintLeaves(BT->Right);
}

Gary.c

　　6-12 二叉搜索树的操作集 (30 分)　　传送门

// 函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针；
BinTree Insert(BinTree BST, ElementType X)
{
    if (BST == NULL)
    {
        BST = (BinTree)malloc(sizeof(BinTree));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    if (X > BST->Data)
        BST->Right = Insert(BST->Right, X);
    if (X < BST->Data)
        BST->Left = Insert(BST->Left, X);
    return BST;
}

// 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针；
BinTree Delete(BinTree BST, ElementType X)
{
    if (BST == NULL)
    {
        printf("Not Found\n");
        return NULL;
    }

    if (X > BST->Data)
        BST->Right = Delete(BST->Right, X);
    else if (X < BST->Data)
        BST->Left = Delete(BST->Left, X);
    else if (X == BST->Data)
    {
        Position node;
        if (BST->Left && BST->Right)
        {
            node = FindMin(BST->Right);
            BST->Data = node->Data;
            BST->Right = Delete(BST->Right, BST->Data);
        }
        else
        {
            node = BST;
            if (BST->Left == NULL)
                BST = BST->Right;
            else if (BST->Right == NULL)
                BST = BST->Left;
            free(node);
        }
    }
    return BST;
}

//函数Find在二叉搜索树BST中找到X，返回该结点的指针；如果找不到则返回空指针；
Position Find(BinTree BST, ElementType X)
{
    while (BST)
    {
        if (X == BST->Data)
            return BST;
        else if (X < BST->Data)
            BST = BST->Left;
        else if (X > BST->Data)
            BST = BST->Right;
    }
    return NULL;
}

//函数FindMin返回二叉搜索树BST中最小元结点的指针；
Position FindMin(BinTree BST)
{
    if (BST == NULL)
        return NULL;
    while (BST->Left)
        BST = BST->Left;
    return BST;
}

//函数FindMax返回二叉搜索树BST中最大元结点的指针。
Position FindMax(BinTree BST)
{
    if (BST == NULL)
        return NULL;
    while (BST->Right)
        BST = BST->Right;
    return BST;
}

Gary.c