【PTA】数据结构题库——计算机

填空题

5-1请将程序补充完整，完成顺序查找功能

outcome==-1

a[i]==x

5-2顺序栈入栈出栈操作

*(S.top++)=e

e=*(–S.top)

InitStack(s)

5-3顺序查找

&a[i]

index=-1

break

5-4单链表插入操作

p && j < i - 1

s->next=p->next;

p->next=s;

5-5顺序表插入操作

L.elem[j+1]=L.elem[j]

L.elem[i-1]=e

5-6单链表删除操作

p && j < i - 1

p->next=q->next

5-7完成两个有序顺序表的合并操作

k=0

c[k++]=a[j++]

while(i<M)

i<M+N

函数题

6-2 顺序表基本运算算法的实现

/**
 * 初始化顺序表L。
 */
void InitList(SqList*& L) {
    L = (SqList*)malloc(sizeof(SqList)); 
    L->length = 0;
}

/**
 * 释放顺序表L。
 */
void DestroyList(SqList*& L) {
    free(L);
}

/**
 * 判断顺序表L是否为空表。
 * 空表返回true，非空表返回false。
 */
bool ListEmpty(SqList* L) {
    if (L->length == 0)
        return true;
    else
        return false;

}

/**
 * 返回顺序表L的元素个数。
 */
int ListLength(SqList* L)
{
    return L->length;
}

/**
 * 输出顺序表L。
 */
void DispList(SqList* L) {
    for (int i = 0; i < L->length; i++)
    {
        printf("%c ", L->data[i]);
    }
    printf("\n");
}

/**
 * 获取顺序表L中第i(1≤i≤L->length)个元素，将其值存入e，然后返回true；
 * 如果不能获取到第i个元素，返回false。
 */
bool GetElem(SqList* L, int i, ElemType& e)
{
    if (i<0 || i>L->length)
        return false;
    else
        e = L->data[i - 1];
    return true;
}

/**
 * 在顺序表L中查找元素e。
 * 如果存在e，则返回e的逻辑序号，否则返回0。
 */
int LocateElem(SqList* L, ElemType e) {
    for (int i = 0; i < L->length; i++)
    {
        if (L->data[i] == e)
            return i + 1;
    }
    return 0;
}

/**
 * 在顺序表L中第ii(1≤i≤L->length)个位置上插入元素e。
 * 插入成功，返回true。插入不成功，返回false。
 */
bool ListInsert(SqList*& L, int i, ElemType e) {
    if (i < 1 || i > L->length + 1 || L->length == MaxSize)
        return false;
    for (int j = L->length; j >= i; j--)
        L->data[j] = L->data[j - 1];
    L->data[i - 1] = e;
    L->length++;
    return true;
}

/**
 * 从顺序表L中删除第ii(1≤i≤L->length)个元素。
 * 删除成功，返回true。删除不成功，返回false。
 */
bool ListDelete(SqList*& L, int i, ElemType& e) {
    if (i < 1 || i > L->length)
        return false;
    e = L->data[i - 1];
    for (int j = i; j < L->length; j++)
        L->data[j - 1] = L->data[j];
    L->length--;
    return true;
}

6-3 单链表基本运算算法的实现

/**
 * 头插法建立单链表
 */
void CreateListF(LinkNode*& L, ElemType a[], int n)
{
    if (L == NULL)
        return;
    for (int i = 0; i < n; i++)
    {
        LNode* s = (LNode*)malloc(sizeof(LNode));
        s->data = a[i];
        s->next = L->next;
        L->next = s;
    }
}

/**
 * 尾插法建立单链表
 */
void CreateListR(LinkNode*& L, ElemType a[], int n)
{
    if (L == NULL)
        return;
    LNode* p = L;
    for (int i = 0; i < n; i++)
    {
        LNode* s = (LNode*)malloc(sizeof(LNode));
        s->data = a[i];
        s->next = NULL;
        p->next = s;
        p = s;
    }
}

/**
 * 初始化线性表
 */
void InitList(LinkNode*& L)
{
    L = (LNode*)malloc(sizeof(LNode));
    L->next = NULL;
}

/**
 * 销毁线性表
 */
void DestroyList(LinkNode*& L)
{
    LNode* s = L;
    while (s != NULL) {
        LNode* temp = s;
        s = s->next;
        free(temp);
    }
    L = NULL;
}

/**
 * 判线性表是否为空表。空表返回true，否则返回false。
 */
bool ListEmpty(LinkNode* L)
{
    return L == NULL || L->next == NULL;
}

/**
 * 求线性表的长度
 */
int ListLength(LinkNode* L)
{
    int length = 0;
    LNode* s = L->next;
    while (s != NULL) {
        length++;
        s = s->next;
    }
    return length;
}

/**
 * 输出线性表: 每个数据后面一个空格
 */
void DispList(LinkNode* L)
{
    LNode* s = L->next;
    while (s)
    {
        printf("%c ", s->data);
        s = s->next;
    }
    printf("\n");
}

/**
 * 求线性表中第i个元素值。
 * 存在第i个数据结点,其值存入e,然后返回true。
 * 不存在第i个数据结点,返回false。
 */
bool GetElem(LinkNode* L, int i, ElemType& e)
{
    LNode* s = L->next;
    int j = 1;
    if (i < 1 || L == NULL)
        return false;
    while (s != NULL && j < i) {
        s = s->next;
        j++;
    }
    if (j > i || s == NULL)
        return false;
    else
        e = s->data;
    return true;
}

/**
 * 查找第一个值域为e的元素序号。
 * 若存在，返回其逻辑序号；若不存在，返回0。
 */
int LocateElem(LinkNode* L, ElemType e)
{
    int i = 1;
    LNode* s = L->next;
    while (s != NULL) {
        if (s->data == e) return i;
        s = s->next;
        i++;
    }
    return 0;
}

/**
 * 插入第i个元素。
 * 插入成功，返回true；插入不成功，返回false。
 */
bool ListInsert(LinkNode*& L, int i, ElemType e)
{
    if (L == NULL || i < 1) return false;
    LNode* s = L;
    int j = 0;
    while (s != NULL && j < i - 1) {
        s = s->next;
        j++;
    }
    if (s == NULL) return false;
    LNode* newNode = (LNode*)malloc(sizeof(LNode));
    newNode->data = e;
    newNode->next = s->next;
    s->next = newNode;
    return true;
}

/**
 * 删除第i个元素。
 * 如果第i个元素存在，其值存入e，返回true；
 * 如果第i个元素不存在，返回false。
 */
bool ListDelete(LinkNode*& L, int i, ElemType& e)
{
    if (i < 1) return false;
    LNode* s = L;
    int j = 0;
    while (s != NULL && j < i - 1) {
        s = s->next;
        j++;
    }
    if (s == NULL || s->next == NULL) return false;
    LNode* temp = s->next;
    e = temp->data;
    s->next = temp->next;
    free(temp);
    return true;
}

6-1 十进制转二进制（顺序栈设计和应用）

/*判栈是否为空，空返回true，非空返回false */
bool isEmpty(){
    return top==-1;
}

/* 元素x入栈 */
void Push(int x){
    if(top==MaxSize)
        return;
    mystack[++top]=x;
}

/* 取栈顶元素 */
int getTop(){
    return mystack[top];
}

/* 删除栈顶元素 */
void Pop(){
    if(top==-1)
        return;
    top--;
}

6-4 循环队列操作集

// 创建一个空队列
queue* createQueue() {
    queue* temp = (queue*)malloc(sizeof(queue));
    temp->data = (int*)malloc(sizeof(int) * MAXSIZE);
    temp->rear = 0;
    temp->front = 0;
    return temp;
}

// 入队
void enQueue(queue* q, int x) {
    if (isFull(q))
        return;
    q->data[q->rear] = x;
    q->rear = (q->rear + 1) % MAXSIZE;
}

// 判断队列是否已满
bool isFull(queue* q) {
    return q->front == (q->rear + 1) % MAXSIZE;
}

// 出队
void deQueue(queue* q) {
    if (isEmpty(q))
        return;
    q->front = (q->front + 1) % MAXSIZE;
}

// 得到队头元素的值
int front(queue* q) {
    if (isEmpty(q)) {
        return -1; // 返回-1表示队列为空
    }
    return q->data[q->front];
}

// 判断队列是否为空
bool isEmpty(queue* q) {
    return q->front == q->rear;
}

// 返回队列长度
int size(queue* q) {
    return (q->rear - q->front + MAXSIZE) % MAXSIZE;
}

// 销毁队列
void destroyQueue(queue* q) {
    free(q->data);
    free(q);
}

6-5 二叉树的递归遍历

void PreorderTraversal(BinTree BT)
{
    if(BT==NULL)
        return;
    printf("%c",BT->Data);
    PreorderTraversal(BT->Left);
    PreorderTraversal(BT->Right);
}
void InorderTraversal(BinTree BT)
{
    if(BT==NULL)
        return;
    InorderTraversal(BT->Left);
    printf("%c",BT->Data);
    InorderTraversal(BT->Right);
}
void PostorderTraversal(BinTree BT)
{
    if(BT==NULL)
        return;
    PostorderTraversal(BT->Left);
    PostorderTraversal(BT->Right);
    printf("%c",BT->Data);
}

6-6 统计二叉树结点个数

int NodeCount( BinTree BT ){
    if(BT==NULL)
        return 0;
    return 1+NodeCount(BT->Left)+NodeCount(BT->Right);
}

6-7 在数组中查找指定元素

int search( int list[], int n, int x ){
    for(int i=0;i<n;i++)
        if(list[i]==x)
            return i;
    return -1;
}

6-8 二分法查找

int fun(int a[],int n,int key){
    int left=0,right=n-1,mid;
    while(left<=right)
    {
        mid=(left+right)/2;
        if(a[mid]==key)
            return mid;
        else if(a[mid]<key)
            left=mid+1;
        else if(a[mid]>key)
            right=mid-1;
    }
    return -1;
}

6-9 求二叉树高度

void creat(BiTree &Tree) {
    char ch;
    scanf(" %c", &ch);
    if (ch == '#') {
        Tree = NULL;
    } else {
        Tree = (BiTree)malloc(len);
        Tree->data = ch;
        creat(Tree->lchild);
        creat(Tree->rchild);
    }
}


int Depth(BiTree Tree) {
    if (Tree == NULL) {
        return 0;
    } else {
        int left = Depth(Tree->lchild);
        int right = Depth(Tree->rchild);
        return (left > right ? left : right) + 1;
    }
}

6-10 求二叉树的高度

int Depth(BiTree Tree){
    if(Tree==NULL)
        return 0;
    else{
    int left=Depth(Tree->lchild);
    int right=Depth(Tree->rchild);
    return (left>right?left:right)+1;
    }
}