学妹不会的数据结构-线性表合集

其他 2020-05-02 17:09:15 阅读次数: 0

致读者： 博主是一名数据科学与大数据专业大二的学生，真正的一个互联网萌新，写博客一方面是为了记录自己的学习历程，一方面是希望能够帮助到很多和自己一样处于困惑的读者。由于水平有限，博客中难免会有一些错误，有纰漏之处恳请各位大佬不吝赐教！之后会写大数据专业的文章哦。尽管当前水平可能不及各位大佬，但我会尽我自己所能，做到最好☺。——天地有正气，杂然赋流形。下则为河岳，上则为日星。

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

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

函数接口定义：

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

其中List结构定义如下：

typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

各个操作函数的定义为：

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 )
            printf(" Insertion Error: %d is not in.\n", X);
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        P = Find(L, X);
        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 )
            printf(" Deletion Error.\n");
        if ( Insert(L, 0, P)==false )
            printf(" Insertion Error: 0 is not in.\n");
    }
    return 0;
}

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

输入样例：

6
1 2 3 4 5 6
3
6 5 1
2
-1 6

输出样例：

FULL Insertion Error: 6 is not in.
Finding Error: 6 is not in.
5 is at position 0.
1 is at position 4.
POSITION -1 EMPTY Deletion Error.
FULL Insertion Error: 0 is not in.
POSITION 6 EMPTY Deletion Error.
FULL Insertion Error: 0 is not in.

/* 你的代码将被嵌在这里 */
List MakeEmpty(){
    List L = (List)malloc(sizeof(struct LNode));
    L->Last = -1;
    return L;
}
Position Find( List L, ElementType X ){
    for(int i = 0; i <= L->Last; i++)
        if(X == L->Data[i])
            return i;
    return ERROR;
}
bool Insert( List L, ElementType X, Position P ){
    if(L->Last == MAXSIZE - 1){
        printf("FULL");
        return false;
    }
    //插入的位置是否合法
    if(P < 0 || P > L->Last + 1){
        printf("ILLEGAL POSITION");
        return false;
    }
    for(int i = L->Last + 1; i > P; i--)
        L->Data[i] = L->Data[i - 1];
    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 i = P; i < L->Last; i++)
        L->Data[i] = L->Data[i + 1];
    L->Last--;
    return true;
}

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

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

本题要求实现带头结点的链式表操作集。

函数接口定义：

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

其中List结构定义如下：

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

各个操作函数的定义为：

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

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

bool Insert( List L, ElementType X, Position P )：将X插入在位置P指向的结点之前，返回true。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回false；

bool Delete( List L, Position P )：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回false。

裁判测试程序样例：

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

#define ERROR NULL
typedef enum {false, true} bool;
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

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;
    bool flag;

    L = MakeEmpty();
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        flag = Insert(L, X, L->Next);
        if ( flag==false ) printf("Wrong Answer\n");
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        P = Find(L, X);
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else {
            flag = Delete(L, P);
            printf("%d is found and deleted.\n", X);
            if ( flag==false )
                printf("Wrong Answer.\n");
        }
    }
    flag = Insert(L, X, NULL);
    if ( flag==false ) printf("Wrong Answer\n");
    else
        printf("%d is inserted as the last element.\n", X);
    P = (Position)malloc(sizeof(struct LNode));
    flag = Insert(L, X, P);
    if ( flag==true ) printf("Wrong Answer\n");
    flag = Delete(L, P);
    if ( flag==true ) printf("Wrong Answer\n");
    for ( P=L->Next; P; P = P->Next ) printf("%d ", P->Data);
    return 0;
}
/* 你的代码将被嵌在这里 */

输入样例：

6
12 2 4 87 10 2
4
2 12 87 5

输出样例：

2 is found and deleted.
12 is found and deleted.
87 is found and deleted.
Finding Error: 5 is not in.
5 is inserted as the last element.
Wrong Position for Insertion
Wrong Position for Deletion
10 4 2 5 
/* 你的代码将被嵌在这里 */
List MakeEmpty(){
    //分配空间
    List head = (List)malloc(sizeof(struct  LNode));
    //设置数据和指向
    head->Data = 0;
    head->Next = NULL;
    return head;
}
bool Insert( List L, ElementType X, Position P ){
    List apply = NULL;
    while(L->Next != P && L->Next != NULL)
        L = L->Next;
    if(L->Next == NULL && P != NULL){
        //如果已经到了链尾,说明P肯定不在链表里，而此时P又不为NULL，则一定是P出现了错误 
        printf("Wrong Position for Insertion\n");
        return false;        
    }else{
        //有三种情况：第一种L->Next!=NULL，P！=NULL是普通情况 
        //第二种L->Next!=NULL，P==NULL 这种情况不存在，
        //因为若P==NULL，则退出while循环后L->Next或者走到L->Next=NULL或者L->Next=P仍为NULL，所以此种情况不存在。 
        //第三种L->Next==NULL，P==NULL 则插在链表末尾
        apply = (List)malloc(sizeof(struct LNode));
        apply->Data = X;
        L->Next = apply;
        apply->Next = P;
        return true;
    }
}
Position Find( List L, ElementType X ){
    while(L->Next != NULL){
        if(L->Next->Data == X){
            return L->Next;
        }
        L = L->Next;
    }
    return ERROR;
}
bool Delete( List L, Position P ){
    if(L->Next== NULL||P==NULL){    //如果只有头结点或者删除的位置是NULL，则不能删除 
        printf("Wrong Position for Deletion\n");
        return false;        
    }
    while(L->Next != P && L->Next != NULL)
        L = L ->Next;
    if(L->Next == NULL){    //P一定在链表上，如果始终没有找到P，则删除错误 
        printf("Wrong Position for Deletion\n");
        return false;        
    }
    else{   //否则删除P 
        L->Next = P->Next;
        free(P);
        return true;
    }
}

6-3 合并两个有序数组 (20分)

要求实现一个函数merge，将长度为m的升序数组a和长度为n的升序数组b合并到一个新的数组c，合并后的数组仍然按升序排列。

函数接口定义：

void printArray(int* arr, int arr_size);           /* 打印数组,细节不表 */
void merge(int* a, int m, int* b, int n, int* c);  /* 合并a和b为c */

其中a和b是按升序排列的数组，m和n分别为数组a、b的长度；c为合并后的升序数组。

裁判测试程序样例：

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

void printArray(int* arr, int arr_size);          /* 打印数组,细节不表 */
void merge(int* a, int m, int* b, int n, int* c); /* 合并a和b为c */

int main(int argc, char const *argv[])
{
    int m, n, i;
    int *a, *b, *c;

    scanf("%d", &m);
    a = (int*)malloc(m * sizeof(int));
    for (i = 0; i < m; i++) {
        scanf("%d", &a[i]);
    }

    scanf("%d", &n);
    b = (int*)malloc(n * sizeof(int));
    for (i = 0; i < n; i++) {
        scanf("%d", &b[i]);
    }
    c = (int*)malloc((m + n) * sizeof(int));
    merge(a, m, b, n, c);
    printArray(c, m + n);

    return 0;
}

/* 请在这里填写答案 */

输入样例：

输入包含两行。 第一行为有序数组a，其中第一个数为数组a的长度m，紧接着m个整数。 第二行为有序数组b，其中第一个数为数组b的长度n，紧接着n个整数。

7 1 2 14 25 33 73 84
11 5 6 17 27 68 68 74 79 80 85 87

输出样例：

输出为合并后按升序排列的数组。

1 2 5 6 14 17 25 27 33 68 68 73 74 79 80 84 85 87

void merge(int* a, int m, int* b, int n, int* c){
    int a_index = 0, b_index = 0;
    int c_index = 0;
    while(a_index < m && b_index < n){
        if(*(a + a_index) < *(b + b_index)){
            *(c + c_index) = *(a + a_index);
            c_index++, a_index++;
        }else{
            *(c + c_index) = *(b + b_index);
            c_index++, b_index++;
        }
    }
    while(a_index < m){
        *(c + c_index) = *(a + a_index);
        c_index++, a_index++;
    }
    while(b_index < n){
        *(c + c_index) = *(b + b_index);
        c_index++, b_index++;
    }
}

6-4 线性表元素的区间删除 (20分)

给定一个顺序存储的线性表，请设计一个函数删除所有值大于min而且小于max的元素。删除后表中剩余元素保持顺序存储，并且相对位置不能改变。

函数接口定义：

List Delete( List L, ElementType minD, ElementType maxD );

其中List结构定义如下：

typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

L是用户传入的一个线性表，其中ElementType元素可以通过>、==、<进行比较；minD和maxD分别为待删除元素的值域的下、上界。函数Delete应将Data[]中所有值大于minD而且小于maxD的元素删除，同时保证表中剩余元素保持顺序存储，并且相对位置不变，最后返回删除后的表。

裁判测试程序样例：

#include <stdio.h>

#define MAXSIZE 20
typedef int ElementType;

typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

List ReadInput(); /* 裁判实现，细节不表。元素从下标0开始存储 */
void PrintList( List L ); /* 裁判实现，细节不表 */
List Delete( List L, ElementType minD, ElementType maxD );

int main()
{
    List L;
    ElementType minD, maxD;
    int i;

    L = ReadInput();
    scanf("%d %d", &minD, &maxD);
    L = Delete( L, minD, maxD );
    PrintList( L );

    return 0;
}

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

输入样例：

10
4 -8 2 12 1 5 9 3 3 10
0 4

输出样例：

4 -8 12 5 9 10 
List Delete( List L, ElementType minD, ElementType maxD ){
    int p = 0, i;
    for(i = 0; i < L->Last + 1; i++){
        //如果是合法的数据
        if(L->Data[i] <= minD || L->Data[i] >= maxD)
            L->Data[p++] = L->Data[i];
    }
    L->Last = p - 1;
    return L;
}

完整版

/*
* @Author: wfy
* @Date:   2020-03-05 15:33:01
* @Last Modified by:   wfy
* @Last Modified time: 2020-03-05 15:42:43
*/
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
typedef int ElementType;

typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

List ReadInput(); /* 裁判实现，细节不表。元素从下标0开始存储 */
void PrintList( List L ); /* 裁判实现，细节不表 */
List Delete( List L, ElementType minD, ElementType maxD );

int main()
{
    List L;
    ElementType minD, maxD;

    L = ReadInput();
    scanf("%d %d", &minD, &maxD);
    L = Delete( L, minD, maxD );
    PrintList( L );

    return 0;
}

/* 你的代码将被嵌在这里 */
List ReadInput(){
    List L = (List)malloc(sizeof(LNode));
    int n, i;
    scanf("%d", &n);
    for(i = 0; i < n; i++)
        scanf("%d", &L->Data[i]);
    L->Last = n - 1;
    return L;
}
void PrintList(List L){
    int i;
    for(i = 0; i < L->Last + 1; i++){
        printf("%d%c", L->Data[i], i == L->Last ? '\n' : ' ');
    }
}
List Delete( List L, ElementType minD, ElementType maxD ){
    int p = 0, i;
    for(i = 0; i < L->Last + 1; i++){
        //如果是合法的数据
        if(L->Data[i] <= minD || L->Data[i] >= maxD)
            L->Data[p++] = L->Data[i];
    }
    L->Last = p - 1;
    return L;
}

6-5 递增的整数序列链表的插入 (15分)

本题要求实现一个函数，在递增的整数序列链表（带头结点）中插入一个新整数，并保持该序列的有序性。

函数接口定义：

List Insert( List L, ElementType X );

其中List结构定义如下：

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

L是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Insert要将X插入L，并保持该序列的有序性，返回插入后的链表头指针。

裁判测试程序样例：

#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 Insert( List L, ElementType X );

int main()
{
    List L;
    ElementType X;
    L = Read();
    scanf("%d", &X);
    L = Insert(L, X);
    Print(L);
    return 0;
}

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

输入样例：

5
1 2 4 5 6
3

输出样例：

1 2 3 4 5 6 
List Insert( List L, ElementType X ){
    List p = L;
    List data = (List)malloc(sizeof(List));
    while(p->Next != NULL && p->Next->Data < X){
        p = p->Next;
    }
    data->Data = X;
    data->Next = NULL;
    //插入
    data->Next = p->Next;
    p->Next = data;
    return L;
}

6-6 两个有序链表序列的合并 (15分)

本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。

函数接口定义：

List Merge( List L1, List L2 );

其中List结构定义如下：

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

L1和L2是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Merge要将L1和L2合并为一个非递减的整数序列。应直接使用原序列中的结点，返回归并后的带头结点的链表头指针。

裁判测试程序样例：

#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 ); /* 细节在此不表；空链表将输出NULL */

List Merge( List L1, List L2 );

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

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

输入样例：

3
1 3 5
5
2 4 6 8 10

输出样例：

1 2 3 4 5 6 8 10 
NULL
NULL
List Merge( List L1, List L2 ){
    List head = (List)malloc(sizeof(List));
    List p = head;
    List a = L1->Next;
    List b = L2->Next;
    while(a && b){
        if(a->Data > b->Data){
            p->Next = b;
            b = b->Next;
        }else{
            p->Next = a;
            a = a->Next;
        }
        p = p->Next;
    }
    p->Next = a ? a : b;
    L1->Next = NULL;
    L2->Next = NULL;
    return head;
}

 6-7 求链表的倒数第m个元素 (20分)

请设计时间和空间上都尽可能高效的算法，在不改变链表的前提下，求链式存储的线性表的倒数第m（>0）个元素。

函数接口定义：

ElementType Find( List L, int m );

其中List结构定义如下：

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

L是给定的带头结点的单链表；函数Find要将L的倒数第m个元素返回，并不改变原链表。如果这样的元素不存在，则返回一个错误标志ERROR。

裁判测试程序样例：

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

#define ERROR -1

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

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

ElementType Find( List L, int m );

int main()
{
    List L;
    int m;
    L = Read();
    scanf("%d", &m);
    printf("%d\n", Find(L,m));
    Print(L);
    return 0;
}

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

输入样例：

5
1 2 4 5 6
3

输出样例：

4
1 2 4 5 6

双指针法：

ElementType Find( List L, int m ){
    List p1, p2;
    p1 = L->Next;
    p2 = L->Next;
    int n = m;
    while(n--){
        if(!p2)
           return ERROR; 
        p2 = p2->Next;
    }
    while(p2){
        p2 = p2->Next;
        p1 = p1->Next;
    }
    return p1->Data;
}

6-8 双端队列 (25分)

双端队列（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;
}

/* 你的代码将被嵌在这里 */
//前插：它的判断条件上面已经说过啦，在前面插入，先移动再插入，
//用-1，表示指针像前面移动一个单位，然后在该指针指向的位置进行插入
bool Push( ElementType X, Deque D )
{
    if((D->Rear+1)%D->MaxSize==D->Front)
        return false;
    else
    {
        D->Front = (D->Front-1+D->MaxSize)%D->MaxSize;
        D->Data[D->Front] = X;
        return true;
    }
}
/*前删：判断条件：当头指针和尾指针指向同一个位置时，就说明是空的，为什么呢，
因为尾指针一直指向的都是下一个位置，一直是一个空的。记录此刻头指针的位置上的数值，
然后向后面移动一位。返回数值。*/
ElementType Pop( Deque D )
{
    ElementType rt;
    if(D->Front==D->Rear)
        return ERROR;
    else
    {
        rt = D->Data[D->Front];
        D->Front = (D->Front+1)%D->MaxSize;
        return rt;
    }
}
//后插：判断条件和前插是一样的，后面插入，先插入后移动，
//现在该尾指针指向的位置上进行插入，然后再把尾指针向后面移动一位。
bool Inject( ElementType X, Deque D )
{
    if((D->Rear+1)%D->MaxSize==D->Front)
        return false;
    else
    {
        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;
    else
    {
        D->Rear = (D->Rear-1+D->MaxSize)%D->MaxSize;
        return D->Data[D->Rear];
    }
}

 

ZZULI_星.夜
原创文章 93 获赞 353 访问量 3万+
关注 私信

猜你喜欢

转载自blog.csdn.net/weixin_43906799/article/details/105881318
今日推荐
周排行
Leetcode简单题61~80
解决zookeeper磁盘IO高的问题
多线程相关方法详解
Maven-setting.xml文件详解
Maven 项目的 classpath 理解
渊亭科技大数据笔试题
配置JVM内存分配
计算机网络个人学习笔记 （三）网络层 ：第三部分 连载
js中两个等号(==)和三个等号(===)的区别
用C程序自动打开电脑上的程序
每日归档
更多
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022