东北大学考研线性表相关历年真题题目整理

最新推荐文章于 2022-11-04 16:19:21 发布

卖萌书生

最新推荐文章于 2022-11-04 16:19:21 发布

阅读量2.9k

点赞数 4

本文链接：https://blog.csdn.net/sh310059703/article/details/41714263

版权

设指针la指向单链表的首结点：编写算法，从表la中删除第i个元素起共len个元素

/*****************************************************************************
*设指针la指向单链表的首结点：编写算法，从表la中删除第i个元素起共len个元素*
******************************************************************************/
void delete_list(List_Node* la,int i,int len){
    List_Node* p = la;
    int i = 0;
    for(i = 0; i < i-2;i++){//这个for循环使得p指向待删除的第一个元素的前驱
        if(p == NULL){
            return ;
        }
        p = p->next;
    }
    for(i = 0; i < len;i++){//删除第i个元素起共len个元素
        if(p->next == NULL){//当前节点的下一个节点为空则说明已经删到最后一个节点
            return ;
        }
        p->next = p->next->next;
    }
}

整数序列作为输入数据，当输入数据为0是表示输入结束。编写算法，将数据按递增顺序用单链表存放，并打印该链表

/*********************************************************
*整数序列作为输入数据，当输入数据为0是表示输入结束*****
*编写算法，将数据按递增顺序用单链表存放，并打印该链表**
***********************************************************/

List_Node* sort_list(int a[]){//a[]表示题目所给的整数序列
    List_Node* head;//链表头指针
    head = (List_Node*)malloc(List_Node);
    head->next = NULL;
    List_Node* pre;
    List_Node* last;
    List_Node* temp;
    int i = 0;
    while(a[i] != 0){
        pre = head;
        last = head->next;
        while(last != NULL && x >= last->data){//一前一后两个指针，寻找应该插入的位置
            pre = last;
            last = last->next;
        }
        temp = (List_Node*)malloc(sizeof(List_Node));
        temp->data = a[i];
        temp->next = last;
        pre->next = temp;
        i++;
    }
    temp = head->next;
    while(temp != NULL){//打印链表
        printf("%d",temp->data);
        temp = temp->next;
    }
}

假设线性表l用带头结点的单链表存储，且至少有两个结点，每个节点的数据域为整型值。编写算法以判断该链表中每一个结点的值是否等于其后续两个结点值之和，若满足上述要求，返回1 并输出最大值；否则，返回0并输出最小值

/*********************************************************************************
*假设线性表l用带头结点的单链表存储，且至少有两个结点，每个节点的***************
*数据域为整型值。编写算法以判断该链表中每一个结点的值是否等于其后**************
*续两个结点值之和，若满足上述要求，返回1 并输出最大值；否则，返回0并输出最小值*
************************************************************************************/

int judge_list(List_Node* head){
    List_Node* pre = head->next;
    List_Node* mid = pre->next;
    List_Node* last = mid->next;
    int MAX = pre->data + mid->data;
    int temp_sum = 0;
    while(last != NULL){
        temp_sum = mid->data + last->data;
        if(pre->data != temp_sum){
            return 0;
        }
        if(temp_sum > MAX){
            MAX = temp_sum;
        }
    }
    printf("%d",MAX);
    return 1;
}

写出将循环单链表中节点x的直接前驱删除的算法（x为指针，且从x指向节点出发进行删除）

/**************************************************************************************
*写出将循环单链表中节点x的直接前驱删除的算法（x为指针，且从x指向节点出发进行删除)*
***************************************************************************************/

void delete_f(List_Node* x){
    List_Node* p = x;
    List_Node* q;
    while(p->next != x){
        p = p->next;
    }
    q = p->next;
    p->next = s;
    delete q;
}

设单链表的表头指针为h，节点结构有data个next两个域构成，其中data域为字符型。编写算法，判断该链表的前n个字符组成的是否为回文，要求使用栈和队列。（回文是指正读反读均相同的字符序列，如abba和abdba均是回文，但good不是回文）

/**************************************************************************************
*设单链表的表头指针为h，节点结构有data个next两个域构成，其中data域为字符型。编写算法，
判断该链表的前n个字符组成的是否为回文，要求使用栈和队列。（回文是指正读反读均相同的字
符序列，如abba和abdba均是回文，但good不是回文）*
***************************************************************************************/

bool judge_list(List_Node* h,int n){//栈是先进后出、队是先进先出，将前n个元素依次压入栈和队之
    //后，再依次弹出比较（栈弹出是原序列的从后到前、队弹出是原序列的从前到后），恰好是前后依次对比
    List_Node* temp = h->next;
    stack<char> s;
    queue<char> q;
    int i = n;
    char stack_temp;//存从栈中弹出的元素
    char queue_temp;//存从队中弹出的元素
    while(temp != NULL&&i != 0){//依次压入栈和队
        s.push(temp->data);
        q.push(temp->data);
        temp = temp->next;
        i -- ;
    }
    while(!s.empty() && !q.empty()){
        stack_temp = s.top();//取栈顶元素，并不弹出
        queue_temp = q.first();//取队的第一个元素，并不弹出
        if(stack_temp != queue_temp){
            return false;
        }
        s.pop();//将栈顶第一个元素弹出
        q.pop();//将队的第一个元素弹出
    }
    return true;
}

已知f为单链表的表头指针，链表中存储的都是整型数据，试设计算法将此链表的节点按照递增次序进行就地排序

已知l为没有头结点的单链表中第一个节点的指针，每个节点数据域存放一个字符，该字符可能是英文字母字符或数字字符或其他字符。编写算法构造三个以带头结点的单循环链表表示的线性表，使每个表中只含同一类字符（要求用最少的时间个最少的空间）

/**************************************************************************************
已知l为没有头结点的单链表中第一个节点的指针，每个节点数据域存放一个字符，该字符可能
是英文字母字符或数字字符或其他字符。编写算法构造三个以带头结点的单循环链表表示的线性
表，使每个表中只含同一类字符（要求用最少的时间个最少的空间）
***************************************************************************************/
void sort_list(List_Node * head,List_Node* english,List_Node* number,List_Node* other){
    //遍历、分别按要求插入三个链表中，english表示英文、number表示数字、other表示其他字符
    List_Node* p = head;
    List_Node* temp_e = english;
    List_Node* temp_n = number;
    List_Node* temp_o = other;
    while(p != NULL){
        if((p->data >= 'a' && p->data <= 'z') || (p->data >= 'A' && p->data <= 'Z')){
            temp_e = p;
            temp_e = temp_e->next;
        }else if(p->data >= '0' && p->data <= '9'){
            temp_n = p;
            temp_n = temp_n->next;
        }else{
            temp_o = p;
            temp_o = temp_o->next;
        }
    }
}

设有一个正整数序列组成的有序单链表（按递增次序有序，且允许有相等的正整数存在），试编写能实现下列功能的算法（要求用最少的时间和最小的空间）

1）确定在序列中比正整数x大的数有几个（相同的数只计算一次，如序列{20，20,17，16,15,11,10,8,7,7,5,4}中比10打的数有5个）

int judge(List_Node* head,int x){
    if(head == NULL){//带头结点，即head的值域为空
        return;
    }
    List_Node* pre = head->next;
    List_Node* p = head->next->next;
    int num = 0;
    if(pre->data > x){
        num++;
    }
    while(p != NULL){//大于X且与前一个值不同
        if(p->data > x && pre->data != p->data){
            num++;
        }
        pre = p;
        p = p->next;
    }
    return num;
}

2）在单链表将比x小的数按递减次序排列

3）将正整数x打的偶数从单链表中删除

void delete_list(List_Node* head,int x){
    List_Node* p = head->next;
    List_Node* pre = head;
    List_Node* temp;
    while(p != NULL){
        if(p->data > x && p->data%2 == 0){
            temp = p;
            pre->next = p->next;
            p = pre->next;
            delete(temp);
        }else{
            pre = p;
            p = p->next;
        }
    }
}

设有一个有正整数组成的无序（向后）单链表，编写完成下列功能的算法

1）找出最小值节点，且打印该数值

2）若该数值是奇数，则将其与直接后继节点的数值交换

3）若反数值是偶数，则将其直接后继节点删除

void Find_ist(List_Node* head){
    int Min;
    List_Node* record = heea->next;
    if(head->next == NULL){
        return;
    }
    List_Node* p = head->next;
    Min = p->data;
    while(p != NULL){//找最小节点
        if(Min > p->data){
            Min = p->data;
            record = p;
        }
        p = p->next;
    }
    printf("最小节点的数值：%d",Min);
    if(Min%2 != 0){//奇数
        if(record->next != NULL){
            record->data = record->next->data;
            record->next->data = Min;
        }
    }else{//偶数
        if(record->next != NULL){
            List_Node* temp = record->next;
            record->next = record->next->next;
            delete(temp);
        }
    }
}