第7-8周练习题 -- 函数题_#include <stdio.h> #include <stdlib.h> #define ele-CSDN博客

本文链接：https://blog.csdn.net/qq_45475271/article/details/109433842

文章目录

3-1 Deque (20分)

A “deque” is a data structure consisting of a list of items, on which the following operations are possible: Push(X,D): Insert item X on the front end of deque D.
Pop(D): Remove the front item from deque D and return it.
Inject(X,D): Insert item X on the rear end of deque D.
Eject(D): Remove the rear item from deque D and return it. Write routines to support the deque that take O(1) time per operation.

Format of functions:

Deque CreateDeque();
int Push( ElementType X, Deque D );
ElementType Pop( Deque D );
int Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

where Deque is defined as the following:

typedef struct Node *PtrToNode;
struct Node {
    ElementType Element;
    PtrToNode Next, Last;
};
typedef struct DequeRecord *Deque;
struct DequeRecord {
    PtrToNode Front, Rear;
};

Here the deque is implemented by a doubly linked list with a header. Front and Rear point to the two ends of the deque respectively. Front always points to the header. The deque is empty when Front and Rear both point to the same dummy header. Note: Push and Inject are supposed to return 1 if the operations can be done successfully, or 0 if fail. If the deque is empty, Pop and Eject must return ERROR which is defined by the judge program.

Sample program of judge:

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

#define ElementType int
#define ERROR 1e5
typedef enum { push, pop, inject, eject, end } Operation;

typedef struct Node *PtrToNode;
struct Node {
    ElementType Element;
    PtrToNode Next, Last;
};
typedef struct DequeRecord *Deque;
struct DequeRecord {
    PtrToNode Front, Rear;
};
Deque CreateDeque();
int Push( ElementType X, Deque D );
ElementType Pop( Deque D );
int Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

Operation GetOp();          /* details omitted */
void PrintDeque( Deque D ); /* details omitted */

int main()
{
    ElementType X;
    Deque D;
    int done = 0;

    D = CreateDeque();
    while (!done) {
        switch(GetOp()) {
        case push: 
            scanf("%d", &X);
            if (!Push(X, D)) printf("Memory is Full!\n");
            break;
        case pop:
            X = Pop(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            break;
        case inject: 
            scanf("%d", &X);
            if (!Inject(X, D)) printf("Memory is Full!\n");
            break;
        case eject:
            X = Eject(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            break;
        case end:
            PrintDeque(D);
            done = 1;
            break;
        }
    }
    return 0;
}

/* Your function will be put here */

Sample Input:

Pop
Inject 1
Pop
Eject
Push 1
Push 2
Eject
Inject 3
End

Sample Output:

Deque is Empty!
Deque is Empty!
Inside Deque: 2 3

代码如下：
这里的node->Last指向node的前一个结点
画图倒一倒双向链表的插入操作，修改4个指针

Deque CreateDeque(){
	Deque dq = (Deque)malloc(sizeof(struct DequeRecord));
	PtrToNode node = (PtrToNode)malloc(sizeof(struct Node));
	node->Next = NULL;node->Last = NULL;
	dq->Front = node;
	dq->Rear = node;
	return dq;
} 
int Push( ElementType X, Deque D ){ 
	PtrToNode node = (PtrToNode)malloc(sizeof(struct Node));
	node->Element = X;
	if(D->Front==D->Rear){
		node->Next = NULL;
		node->Last = D->Front;
		D->Front->Next = node;
		D->Rear = node;
	}else{
		node->Last = D->Front;
		node->Next = D->Front->Next;
		D->Front->Next = node;
		node->Next->Last = node;
	}
	return 1;
}
ElementType Pop( Deque D ){
	if(D->Front==D->Rear) return ERROR;
	PtrToNode node = D->Front->Next;
	ElementType element = node->Element;
	if(D->Front->Next==D->Rear){
		D->Front->Next = NULL;
		D->Rear = D->Front;
	}else{
		D->Front->Next = node->Next;
		node->Next->Last = D->Front;
	}
	free(node);
	return element;
}
int Inject( ElementType X, Deque D ){
	PtrToNode node = (PtrToNode)malloc(sizeof(struct Node));
	node->Element = X;
	node->Last = D->Rear;
	node->Next = NULL;
	D->Rear->Next = node;
	D->Rear = node;
	return 1;
}
ElementType Eject( Deque D ){
	if(D->Front==D->Rear) return ERROR;
	PtrToNode node = D->Rear;
	ElementType element = node->Element;
	node->Last->Next = NULL;
	D->Rear = node->Last;
	free(node);
	return element;
}

3-3 另类循环队列 (20分)

如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。

函数接口定义：

bool AddQ( Queue Q, ElementType X );
ElementType DeleteQ( Queue Q );

其中Queue结构定义如下：

typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;  /* 存储元素的数组   */
    Position Front;     /* 队列的头指针     */
    int Count;          /* 队列中元素个数   */
    int MaxSize;        /* 队列最大容量     */
};
typedef PtrToQNode Queue;

注意：如果队列已满，AddQ函数必须输出“Queue Full”并且返回false；如果队列是空的，则DeleteQ函数必须输出“Queue Empty”，并且返回ERROR。

裁判测试程序样例：

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

#define ERROR -1
typedef int ElementType;
typedef enum { addq, delq, end } Operation;
typedef enum { false, true } bool;
typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;  /* 存储元素的数组   */
    Position Front;     /* 队列的头、尾指针 */
    int Count;          /* 队列中元素个数   */
    int MaxSize;        /* 队列最大容量     */
};
typedef PtrToQNode Queue; 

Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = 0;
    Q->Count = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

bool AddQ( Queue Q, ElementType X );
ElementType DeleteQ( Queue Q );

Operation GetOp();  /* 裁判实现，细节不表 */

int main()
{
    ElementType X;
    Queue Q;
    int N, done = 0;

    scanf("%d", &N);
    Q = CreateQueue(N);
    while ( !done ) {
        switch( GetOp() ) {
        case addq: 
            scanf("%d", &X);
            AddQ(Q, X);
            break;
        case delq:
            X = DeleteQ(Q);
            if ( X!=ERROR ) printf("%d is out\n", X);
            break;
        case end:
            while (Q->Count) printf("%d ", DeleteQ(Q));
            done = 1;
            break;
        }
    }
    return 0;
}

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

输入样例：

4
Del
Add 5
Add 4
Add 3
Del
Del
Add 2
Add 1
Add 0
Add 10
End

输出样例：

Queue Empty
5 is out
4 is out
Queue Full
3 2 1 0

代码如下：
防止假溢出

入队操作:Q->Rear = (Q->Rear+1)%Q->MaxSize
出队操作:Q->Front = (Q->Front+1)%Q->MaxSize;

bool AddQ( Queue Q, ElementType X ){
	if(Q->Count==Q->MaxSize){
		printf("Queue Full\n");
		return false;
	}else{
		Q->Count++;
		Q->Data[(Q->Front+Q->Count)%(Q->MaxSize)] = X;  //相当于入队操作:Q->Rear=(Q->Rea+1)%Q->MaxSize
		return true;
	}
}
ElementType DeleteQ( Queue Q ){
	if(Q->Count==0){
		printf("Queue Empty\n");
		return ERROR;
	}else{
		Q->Count--; 
		Q->Front = (Q->Front+1)%(Q->MaxSize);  //出队操作
		return Q->Data[Q->Front];
	}
}

3-4 双端队列 (20分)

双端队列（deque，即double-ended queue的缩写）是一种具有队列和栈性质的数据结构，即可以（也只能）在线性表的两端进行插入和删除。若以顺序存储方式实现双端队列，请编写例程实现下列操作：
Push(X,D)：将元素X插入到双端队列D的头；
Pop(D)：删除双端队列D的头元素，并返回；
Inject(X,D)：将元素X插入到双端队列D的尾部；
Eject(D)：删除双端队列D的尾部元素，并返回。

函数接口定义：

bool Push( ElementType X, Deque D );
ElementType Pop( Deque D );
bool Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

其中Deque结构定义如下：

typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;      /* 存储元素的数组   */
    Position Front, Rear;   /* 队列的头、尾指针 */
    int MaxSize;            /* 队列最大容量     */
};
typedef PtrToQNode Deque;

注意：Push和Inject应该在正常执行完操作后返回true，或者在出现非正常情况时返回false。当Front和Rear相等时队列为空，Pop和Eject必须返回由裁判程序定义的ERROR。

裁判测试程序样例：

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

#define ERROR -1
typedef int ElementType;
typedef enum { push, pop, inject, eject, end } Operation;
typedef enum { false, true } bool;
typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;      /* 存储元素的数组   */
    Position Front, Rear;   /* 队列的头、尾指针 */
    int MaxSize;            /* 队列最大容量     */
};
typedef PtrToQNode Deque; 

Deque CreateDeque( int MaxSize )
{   /* 注意：为区分空队列和满队列，需要多开辟一个空间 */
    Deque D = (Deque)malloc(sizeof(struct QNode));
    MaxSize++;
    D->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    D->Front = D->Rear = 0;
    D->MaxSize = MaxSize;
    return D;
}

bool Push( ElementType X, Deque D );
ElementType Pop( Deque D );
bool Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

Operation GetOp();          /* 裁判实现，细节不表 */
void PrintDeque( Deque D ); /* 裁判实现，细节不表 */

int main()
{
    ElementType X;
    Deque D;
    int N, done = 0;

    scanf("%d", &N);
    D = CreateDeque(N);
    while (!done) {
        switch(GetOp()) {
        case push: 
            scanf("%d", &X);
            if (!Push(X, D)) printf("Deque is Full!\n");
            break;
        case pop:
            X = Pop(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            else printf("%d is out\n", X);
            break;
        case inject: 
            scanf("%d", &X);
            if (!Inject(X, D)) printf("Deque is Full!\n");
            break;
        case eject:
            X = Eject(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            else printf("%d is out\n", X);
            break;
        case end:
            PrintDeque(D);
            done = 1;
            break;
        }
    }
    return 0;
}

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

输入样例：

3
Pop
Inject 1
Pop
Eject
Push 2
Push 3
Eject
Inject 4
Inject 5
Inject 6
Push 7
Pop
End

输出样例：

Deque is Empty!
1 is out
Deque is Empty!
2 is out
Deque is Full!
Deque is Full!
3 is out
Inside Deque: 4 5

代码如下：

bool Push( ElementType X, Deque D ){
	if((D->Rear+1)%D->MaxSize==D->Front) return false;  //防止队空与队满无法区分的操作
	D->Front = (D->Front-1+D->MaxSize)%D->MaxSize;
	D->Data[D->Front] = X;
	return true;
}
ElementType Pop( Deque D ){
	if(D->Front==D->Rear) return ERROR;  //队满
	ElementType element = D->Data[D->Front];
	D->Front = (D->Front+1)%D->MaxSize;
	return element;
}
bool Inject( ElementType X, Deque D ){
	if((D->Rear+1)%D->MaxSize==D->Front) return false;
	D->Data[D->Rear] = X;
	D->Rear = (D->Rear+1)%D->MaxSize;
	return true;
}
ElementType Eject( Deque D ){
	if(D->Front==D->Rear) return ERROR; 
	D->Rear = (D->Rear-1+D->MaxSize)%D->MaxSize;
	return D->Data[D->Rear];
}

3-5 单链表分段逆转 (20分)

给定一个带头结点的单链表和一个整数K，要求你将链表中的每K个结点做一次逆转。例如给定单链表 1→2→3→4→5→6 和 K=3，你需要将链表改造成 3→2→1→6→5→4；如果 K=4，则应该得到 4→3→2→1→5→6。

函数接口定义：

void K_Reverse( List L, int K );

其中List结构定义如下：

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

L是给定的带头结点的单链表，K是每段的长度。函数K_Reverse应将L中的结点按要求分段逆转。

裁判测试程序样例：

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

typedef int ElementType;

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

List ReadInput(); /* 裁判实现，细节不表 */
void PrintList( List L ); /* 裁判实现，细节不表 */
void K_Reverse( List L, int K );

int main()
{
    List L;
    int K;

    L = ReadInput();
    scanf("%d", &K);
    K_Reverse( L, K );
    PrintList( L );

    return 0;
}

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

输入样例：

6
1 2 3 4 5 6
4

输出样例：

4 3 2 1 5 6

代码如下：

void K_Reverse( List L, int K ) {
    int cnt,len=0;
    List p=L,r,s,t,q=p->Next,tmp;
    while(q) {  //计算单链表长度
        q=q->Next;
        len++;
    }
    if(!len||K>len||K<=1)return;
    for(int i=0; i<len/K; i++) {  //确定逆转次数，边遍历边翻转
        cnt=0;
        r=p->Next;
        s=r->Next;
        t=r;
        while(cnt!=K-1) {//注意是K-1次
            tmp=s->Next;
            s->Next=r;
            r=s;
            s=tmp;
            cnt++;
        }
        t->Next=s;
        p->Next=r;
        p=t;
    }
}