数据结构与算法题目集--函数题（已完结）

最新推荐文章于 2024-09-05 18:43:54 发布

wuyaxin97

最新推荐文章于 2024-09-05 18:43:54 发布

阅读量1.1k

点赞数 6

分类专栏：数据结构文章标签：数据结构算法

本文链接：https://blog.csdn.net/yaya_12345678/article/details/118282424

版权

这篇博客汇总了数据结构与算法的实践题目，包括链表的逆转、顺序表操作、链式表长度计算、按序号查找、二分查找、二叉树的高度和遍历等。涵盖了单链表、顺序表、二叉树等多种数据结构的操作和算法应用。

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

6-1 单链表逆转

要求实现一个函数，将给定的单链表逆转。

L是给定单链表，函数Reverse要返回被逆转后的链表。

程序：

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct Node *PtrToNode;
struct Node {
    ElementType Data;
    PtrToNode   Next;
};
typedef PtrToNode List;

List Read(); /* 细节在此不表 */
void Print( List L ); /* 细节在此不表 */

List Reverse( List L );

int main()
{
    List L1, L2;
    L1 = Read();
    L2 = Reverse(L1);
    Print(L1);
    Print(L2);
    return 0;
}

/* 你的代码将被嵌在这里 */
List Reverse( List L )
{
    if(!L)
        return 0;
    
    PtrToNode pre,tmp;
    pre=NULL;
    tmp=NULL;
    while(L)         
    {
        tmp=L->Next;      tmp只是暂存节点，使链表节点可链接，它并不参与逆置的主过程
        L->Next=pre;
        pre=L;
        L=tmp;           //头指针随着tmp指针移动，当他们为null时，
                         //链表遍历完毕，退出循环
    }
    return pre;         //L 最后一定为NULL，因此不返回L，
                        //而返回pre，将其作为新链表的头指针
    
}

笔记：

这道题坑就坑在没有头节点，L为头指针，如果没注意到这点，很容易犯错。

当有头节点时，L指向头节点，用就地逆置的方法，程序如下

List Reverse( List L )
{
    
    PtrToNode pre,tmp;
    pre=L->Next;
    L->Next=NULL;
    while(pre)
    {
        tmp=pre->Next;      //tmp只是暂存节点，使链表节点可链接，它并不参与逆置的主过程
        pre->Next=L->Next;
        L->Next=pre;
        pre=tmp;

    }
    return L;
    
}

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

本题要求实现顺序表的操作集。

List MakeEmpty()：创建并返回一个空的线性表；

Position Find( List L, ElementType X )：返回线性表中X的位置。若找不到则返回ERROR；

bool Insert( List L, ElementType X, Position P )：将X插入在位置P并返回true。若空间已满，则打印“FULL”并返回false；如果参数P指向非法位置，则打印“ILLEGAL POSITION”并返回false；

bool Delete( List L, Position P )：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“POSITION P EMPTY”（其中P是参数值）并返回false。

程序：

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 5
#define ERROR -1
typedef enum {false, true} bool;
typedef int ElementType;
typedef int Position;
typedef struct LNode *List;
struct LNode
{
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

List MakeEmpty();
Position Find( List L, ElementType X );
bool Insert( List L, ElementType X, Position P );
bool Delete( List L, Position P );

int main()
{
    List L;
    ElementType X;
    Position P;
    int N;

    L = MakeEmpty();
    scanf("%d", &N);
    while ( N-- )
    {
        scanf("%d", &X);
        if ( Insert(L, X, 0)==false )              //都是从下标为0的位置插入，故数据的存放和输入的顺序刚好相反
            printf(" Insertion Error: %d is not in.\n", X);
    }
    scanf("%d", &N);
    while ( N-- )
    {
        scanf("%d", &X);
        P = Find(L, X);           //从先前建立的L表中查找数
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else
            printf("%d is at position %d.\n", X, P);
    }
    scanf("%d", &N);
    while ( N-- )
    {
        scanf("%d", &P);
        if ( Delete(L, P)==false )             //将P位置的元素删除
            printf(" Deletion Error.\n");
        if ( Insert(L, 0, P)==false )          //将0插入到位置P中
            printf(" Insertion Error: 0 is not in.\n");
    }
    return 0;
}



/* 你的代码将被嵌在这里 */
List MakeEmpty()
{
    List L;
    L=(List)malloc(sizeof(struct LNode));
    L->Last=-1;
    return L;

}
Position Find( List L, ElementType X )
{
    int i;
    for(i=0; i<=4; i++)
    {
        if(X==L->Data[i])
            return i;
    }

    return  ERROR;
}
bool Insert( List L, ElementType X, Position P )
{
    if(L->Last==MAXSIZE-1)   //last 为数组中下标值
    {
        printf("FULL");
        return false;
    }
    if(P<0||P>(L->Last+1))
    {
        printf("ILLEGAL POSITION");
        return false;
    }
    Position j=0;
    for(j=L->Last; j>=P; j--)
    {
        L->Data[j+1]=L->Data[j];
    }
    L->Data[P]=X;
    L->Last++;

    return true;
}
bool Delete( List L, Position P )
{
    if(P<0||P>L->Last)
    {
        printf("POSITION %d EMPTY",P);
        return false;
    }
    for(int j=P; j<L->Last; j++)
    {
        L->Data[j]=L->Data[j+1];
    }
    L->Last--;
    return true;
}

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

本题要求实现一个函数，求链式表的表长。

L是给定单链表，函数Length要返回链式表的长度。

程序：

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode List;

List Read(); /* 细节在此不表 */

int Length( List L );

int main()
{
    List L = Read();
    printf("%d\n", Length(L));
    return 0;
}

/* 你的代码将被嵌在这里 */

//求链式表的表长
int Length( List L )
{
    PtrToLNode p;
    int count=0;
    p=L;
    while(p!=NULL)
    {   
        count++;
        p=p->Next;
       
    }