第二章顺序表和单链表

最新推荐文章于 2024-03-22 08:40:19 发布

Happy-Dog

最新推荐文章于 2024-03-22 08:40:19 发布

阅读量723

点赞数 2

本文链接：https://blog.youkuaiyun.com/ababychicken/article/details/89337970

版权

判断题

单选题

填空题

程序填空题

函数题

6-1 顺序表操作集（15 分)

本题要求实现顺序表的操作集。
函数接口定义：

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 list;
    list = (List)malloc(sizeof(struct LNode));
    list->Last = -1;
    return list;
}
Position Find( List L, ElementType X ){
int i = 0;
while(i<=L->Last && L->Data[i]!=X)
    i++;
if(i>L->Last)
    return ERROR;
else
    return i;
}
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;
}
int i ;
for( i = L->Last ;i>=P;i--){
        L->Data[i+1] = L->Data[i];
}
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;
}
int i;
for( i = P ;i<=L->Last;i++){
        L->Data[i] = L->Data[i+1];
}
L->Last--;
return true;
}

6-2 线性表元素的区间删除（15 分)

给定一个顺序存储的线性表，请设计一个函数删除所有值大于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 i ,j=0;
    for( i =0; i<=L->Last; i++)
    {
        if(L->Data[i] <= minD || L->Data[i] >= maxD)
        {
                L->Data[j++] = L->Data[i];
        }
    }
    L->Last = j-1;
    return L;
}

6-3 单链表逆转（15 分)

本题要求实现一个函数，将给定的单链表逆转。
函数接口定义：

List Reverse( List L );

其中List结构定义如下：

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

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;
}

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

输入样例：

5
1 3 4 5 2

输出样例：

1
2 5 4 3 1

代码如下

List Reverse( List L )
{
     PtrToNode p,q,tmp;
     p=L;
     q=NULL;
    while(p != NULL){
        tmp = p->Next;  
        p->Next = q;
        q = p;
        p = tmp;  
      
    }
    L = q;  
    return L;
}

6-4 求链式表的表长（10 分)

本题要求实现一个函数，求链式表的表长。
函数接口定义：

int Length( List L );

其中List结构定义如下：

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

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;
}

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

输入样例：

1 3 4 5 2 -1

输出样例：

代码如下

int Length( List L ){
 List t;
 t = L;
 int count =0;
 while(t!=NULL){
    t=t->Next;
    count++;
 }
 return count;
}

6-5 链式表的按序号查找（10 分)

本题要求实现一个函数，找到并返回链式表的第K个元素。
函数接口定义：

ElementType FindKth( List L, int K );

其中List结构定义如下：

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

L是给定单链表，函数FindKth要返回链式表的第K个元素。如果该元素不存在，则返回ERROR。
裁判测试程序样例：

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

#define ERROR -1
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data;
PtrToLNode Next;
};
typedef PtrToLNode List;

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

ElementType FindKth( List L, int K );

int main()
{
int N, K;
ElementType X;
List L = Read();
scanf("%d", &N);
while ( N-- ) {
scanf("%d", &K);
X = FindKth(L, K);
if ( X!= ERROR )
printf("%d ", X);
else
printf("NA ");
}
return 0;
}

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

输入样例：

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

输出样例：

4 NA 1 2 5 3

代码如下

ElementType FindKth( List L, int K ){
List p;
p = L;
int i = 1;
if(p == NULL)
    return ERROR;
while(p!=NULL&&i<K){

    p=p->Next;
    i++;
}
if(i==K&&p!=NULL)
return p->Data;
else
    return ERROR;
}

6-6 带头结点的链式表操作集（15 分)

本题要求实现带头结点的链式表操作集。
函数接口定义：

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 L=(List)malloc(sizeof(struct LNode));
    L->Data=0;
    L->Next=NULL;
    return L;
}
Position Find( List L, ElementType X ){
List p;
p = L;
while(p){
    if(p->Data == X)
       return p;
        p=p->Next;
}
return ERROR;
}
bool Insert( List L, ElementType X, Position P ){
List p ,q;
p=L;
while (p&&p->Next!=P){
    p=p->Next;
}
if(p!= NULL){
    q = (List)malloc(sizeof(struct LNode));
    q->Next = p->Next;
    p->Next = q;
    q->Data = X;
    return true;
}
else{
    printf("Wrong Position for Insertion\n");
    return false;
}
}
bool Delete( List L, Position P ){
    List p ;
p=L;
while (p&&p->Next!=P){
    p=p->Next;
}
if(p!= NULL){
        p->Next = P->Next;
return true;
}
else{
    printf("Wrong Position for Deletion\n");
    return false;
}
}

6-7 求单链表结点的阶乘和（15 分)

本题要求实现一个函数，求单链表L结点的阶乘和。这里默认所有结点的值非负，且题目保证结果在int范围内。
函数接口定义：

int FactorialSum( List L );

其中单链表List的定义如下：

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

裁判测试程序样例：

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

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

int FactorialSum( List L );

int main()
{
int N, i;
List L, p;

scanf("%d", &N);
L = NULL;
for ( i=0; i<N; i++ ) {
    p = (List)malloc(sizeof(struct Node));
    scanf("%d", &p->Data);
    p->Next = L;  L = p;
}
printf("%d\n", FactorialSum(L));

return 0;

}

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

输入样例：

3
5 3 6

输出样例：

846

代码如下

int FactorialSum( List L ){
    int t=1,sum =0;
    int m =0;
List p;
p=L;
while(p!=NULL){
     m = p->Data;
     t=1;
    for(int i= 1 ;i <= m;i++)
        t*=i;
        sum+=t;
        p=p->Next;
}
return sum;
}

6-8 学生成绩链表处理（15 分)

本题要求实现两个函数，一个将输入的学生成绩组织成单向链表；另一个将成绩低于某分数线的学生结点从链表中删除。
函数接口定义：

struct stud_node *createlist();
struct stud_node *deletelist( struct stud_node *head, int min_score );

函数createlist利用scanf从输入中获取学生的信息，将其组织成单向链表，并返回链表头指针。链表节点结构定义如下：

struct stud_node {
int num; /学号/
char name[20]; /姓名/
int score; /成绩/
struct stud_node *next; /指向下个结点的指针/
};

输入为若干个学生的信息（学号、姓名、成绩），当输入学号为0时结束。

函数deletelist从以head为头指针的链表中删除成绩低于min_score的学生，并返回结果链表的头指针。
裁判测试程序样例：

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

struct stud_node {
int num;
char name[20];
int score;
struct stud_node *next;
};

struct stud_node *createlist();
struct stud_node *deletelist( struct stud_node *head, int min_score );

int main()
{
int min_score;
struct stud_node *p, *head = NULL;

head = createlist();
scanf("%d", &min_score);
head = deletelist(head, min_score);
for ( p = head; p != NULL; p = p->next )
    printf("%d %s %d\n", p->num, p->name, p->score);

return 0;

}

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

输入样例：

1 zhang 78
2 wang 80
3 li 75
4 zhao 85
0
80

输出样例：

2 wang 80
4 zhao 85

代码如下
在这里插入图片描述

struct stud_node *createlist(){
    struct stud_node *head, *p, *q;
    head = NULL;
    p=head;
    int n;
    scanf ("%d", &n);
    while (n != 0)
    {
        q = (struct stud_node *)malloc (sizeof (struct stud_node));
        scanf ("%s %d", q->name, &q->score);
        q->num = n;
        if (head == NULL)
            head = q;
        else
            p->next = q;
            p = q;
        scanf ("%d", &n);
    }
    return head;
}
struct stud_node *deletelist( struct stud_node *head, int min_score ){
struct stud_node * L;
L= head;
  while(L->next){
    if(L->next->score < min_score){
        L->next=L->next->next;
    }
    else
        L=L->next;
}
if(head->score < min_score)
return head->next;
    else
    return head;
}

6-9 逆序数据建立链表（15 分)

本题要求实现一个函数，按输入数据的逆序建立一个链表。
函数接口定义：

struct ListNode *createlist();

函数createlist利用scanf从输入中获取一系列正整数，当读到−1时表示输入结束。按输入数据的逆序建立一个链表，并返回链表头指针。链表节点结构定义如下：

struct ListNode {
int data;
struct ListNode *next;
};

裁判测试程序样例：

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

struct ListNode {
int data;
struct ListNode *next;
};

struct ListNode *createlist();

int main()
{
struct ListNode *p, *head = NULL;

head = createlist();
for ( p = head; p != NULL; p = p->next )
    printf("%d ", p->data);
printf("\n");

return 0;

}

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

输入样例：

1 2 3 4 5 6 7 -1

输出样例：

7 6 5 4 3 2 1

代码如下

struct ListNode *createlist()
{
    struct ListNode *L,*s;
    int n;
   L=NULL;
         scanf("%d",&n);
    while(n!=-1)
    {
        s = (struct ListNode*)malloc(sizeof(struct ListNode));
        s->data=n;
        s->next = L;
       L =s;
        scanf("%d",&n);
    }
    return L;
}

6-10 删除单链表偶数节点（15 分)

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中偶数值的结点删除。链表结点定义如下：

struct ListNode {
int data;
struct ListNode *next;
};

函数接口定义：

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );

函数createlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数deleteeven将单链表head中偶数值的结点删除，返回结果链表的头指针。
裁判测试程序样例：

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

struct ListNode {
int data;
struct ListNode *next;
};

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );
void printlist( struct ListNode *head )
{
struct ListNode *p = head;
while § {
printf("%d “, p->data);
p = p->next;
}
printf(”\n");
}

int main()
{
struct ListNode *head;

head = createlist();
head = deleteeven(head);
printlist(head);

return 0;

}

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

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7

代码如下

struct ListNode *createlist(){
struct ListNode * L,*p,*s;
L =NULL;
p = L;
int n;
scanf("%d",&n);
while(n!=-1){
    s = (struct ListNode *)malloc(sizeof(struct ListNode));
    s->next =NULL;
    s->data= n;
    if(L==NULL){
        L = s;
    }
    else
    p->next =s;
    p = s;
    scanf("%d",&n);

}
return L;
}
struct ListNode *deleteeven( struct ListNode *head ){
 struct ListNode *p,*q;
 while(head&&head->data%2==0){
    head=head->next;
 }
 p = head;
    while(p && p->next){
        while(p->next && p->next->data%2==0){
            q = p->next;
            p->next = q->next;
        }
        p = p->next;
    }
    return head;
}

6-11 统计专业人数（15 分)

本题要求实现一个函数，统计学生学号链表中专业为计算机的学生人数。链表结点定义如下：

struct ListNode {
char code[8];
struct ListNode *next;
};

这里学生的学号共7位数字，其中第2、3位是专业编号。计算机专业的编号为02。
函数接口定义：

int countcs( struct ListNode *head );

其中head是用户传入的学生学号链表的头指针；函数countcs统计并返回head链表中专业为计算机的学生人数。
裁判测试程序样例：

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

struct ListNode {
char code[8];
struct ListNode *next;
};

struct ListNode *createlist(); /裁判实现，细节不表/
int countcs( struct ListNode *head );

int main()
{
struct ListNode *head;

head = createlist();
printf("%d\n", countcs(head));

return 0;

}

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

输入样例：

1021202
2022310
8102134
1030912
3110203
4021205

输出样例：

代码如下

int countcs( struct ListNode *head ){
    struct ListNode *p;
    p =head;
        int count = 1;
        if(p==NULL)
            return 0;
        while(head&&head->next==NULL){
            if(head->code[1]=='0'&&head->code[2]=='2')
               return count;
            else
                return 0;
        }
    p =head;
    while(p&&p->next){
        if(p->code[1] =='0'&&p->code[2]=='2')
            count++;
        p=p->next;
    }
    return count;
}

6-12 递增的整数序列链表的插入（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,q;
q = (List)malloc(sizeof(PtrToNode));
p =L;
while(p&&p->Next)
    p = p->Next;
    if(p->Data < X ){
       q->Next = NULL;
        p->Next =q;
        q->Data =X;
        return L;
    }

if(p==NULL){
    p->Data =X;
    return L;
}
p=L;
while(p&&p->Next->Data <= X)
    p = p->Next;
q->Next = p->Next;
p->Next =q;
q->Data =X;
return L;
}

6-13 两个有序链表序列的合并（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 p1 = L1->Next;
	List p2 = L2->Next;
	List L = (List)malloc(sizeof(struct Node));//新链表头节点
	List p = L;
	while(p1!=NULL && p2!=NULL)
	{
		if(p1->Data < p2->Data){
			p->Next = p1;
			p1 = p1->Next;
			L1->Next = p1;
			p = p->Next;
		}
		else{
			p->Next = p2;
			p2 = p2->Next;
			L2->Next = p2;
			p = p->Next;
		}
	}
	if(p1 !=NULL)
	{
		p->Next = p1;
		L1->Next = NULL;
	}
	if(p2 !=NULL)
	{
		p->Next = p2;
		L2->Next = NULL;
	}

		return L;
}

6-14 jmu-ds- 顺序表删除重复元素（25 分)

设计一个算法，从顺序表中删除重复的元素，并使剩余元素间的相对次序保存不变。

输入格式: 第一行输入顺序表长度。 第二行输入顺序表数据元素。中间空格隔开。
输出格式：数据之间空格隔开，最后一项尾部不带空格。
输出删除重复元素后的顺序表。
你需要实现的函数有下面三个：

函数接口定义：

void CreateSqList(List &L,int a[],int n); //创建顺序表
void DispSqList(List L);//输出顺序表
void DelSameNode(List &L) ;//删除顺序表重复元素

L ：顺序表
a ：输入数组
n ：输入数据个数

裁判测试程序样例：

#define maxsize 50
#include
using namespace std;
typedef struct{
int data[maxsize];
int length;
}SqList;
typedef SqList *List;
void CreateSqList(List &L,int a[],int n);
void DispSqList(List L);
void DestroyList(List &L);
void DelSameNode(List &L) ;
void DestroyList(List &L){
delete L;
}
int main()
{
int i,n;
int a[maxsize];
List L;
cin>>n;
for(i=0;i<n;i++)
cin>>a[i];
CreateSqList(L,a,n) ;
DelSameNode(L) ;
DispSqList(L);
DestroyList(L);
}

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

输入样例：

5
1 2 3 2 1

输出样例：

1 2 3

代码如下

在这里插入代码片

6-15 顺序表的插入操作（10 分)

本题要求实现一个函数，在顺序表的第i个位置插入一个新的数据元素e，插入成功后顺序表的长度加1，函数返回值为1；插入失败函数返回值为0；
函数接口定义：

int ListInsert(SqList &L,int i,ElemType e);

其中SqList结构定义如下：

typedef struct{
ElemType *elem;
int length;
}SqList;

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 5
typedef int ElemType;
typedef struct{
ElemType elem;
int length;
}SqList;
void InitList(SqList &L);/细节在此不表/
int ListInsert(SqList &L,int i,ElemType e);
int main()
{
SqList L;
InitList(L);
ElemType e;
int i;
scanf("%d%d",&i,&e);
int result=ListInsert(L,i,e);
if(result0){
printf(“Insertion Error.The value of i is unlawful or the storage space is full!”);
}else if(result1){
printf(“Insertion Success.The elements of the SequenceList L are:”);
for(int j=0;j<L.length;j++){
printf(" %d",L.elem[j]);
}
}
return 0;
}
/ 请在这里填写答案 */

输入格式：

输入数据有1行，首先给出以-1结束的顺序表元素值（不超过100个，-1不属于顺序表元素），然后是插入位置和被插入元素值。所有数据之间用空格分隔。
输入样例：

2 6 4 -1 2 100

输出样例：

Insertion Success.The elements of the SequenceList L are: 2 100 6 4

代码如下

int ListInsert(SqList &L,int i,ElemType e){
 if (i < 1 ||i>L.length+1||L.length >= MAXSIZE)
    {
        return 0;
    }
        else{
            L.length++;
        for(int k = L.length-1;k >=i;k--){
            L.elem[k] = L.elem[k-1];
        }
        L.elem[i-1] = e;
        return 1;
}
}

函数题

7-1 数组循环左移（20 分)

本题要求实现一个对数组进行循环左移的简单函数：一个数组a中存有n（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m（≥0）个位置，即将a中的数据由（a0a1⋯an−1）变换为（am⋯an−1a0a1⋯am−1）（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？
输入格式:

输入第1行给出正整数n（≤100）和整数m（≥0）；第2行给出n个整数，其间以空格分隔。
输出格式:

在一行中输出循环左移m位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。
输入样例：

8 3
1 2 3 4 5 6 7 8

输出样例：

4 5 6 7 8 1 2 3

代码如下

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

int ArrayShift( int a[], int n, int m ){
    int t;
for(int i = 0 ;i < m;i++){
        t= a[0];
        for(int j = 0;j < n;j++){
            a[j]=a[j+1];
        }
    a[n-1] = t;
}
return a[n];
}

int main()
{
    int a[100], n, m;
    int i;

    scanf("%d %d", &n, &m);
    for ( i = 0; i < n; i++ ) scanf("%d", &a[i]);

    ArrayShift(a, n, m);

    for ( i = 0; i < n; i++ ) {
        if (i != 0) printf(" ");
        printf("%d", a[i]);
    }

    return 0;
}

7-2 一元多项式的乘法与加法运算（20 分)

设计函数分别求两个一元多项式的乘积与和。
输入格式:

输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。
输出格式:

输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。
输入样例:

4 3 4 -5 2 6 1 -2 0
3 5 20 -7 4 3 1

输出样例:

15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1
5 20 -4 4 -5 2 9 1 -2 0

代码如下

在这里插入代码片

7-3 一元多项式求导（20 分)

设计函数求一元多项式的导数。
输入格式:

以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。
输出格式:

以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。
输入样例:

3 4 -5 2 6 1 -2 0

输出样例:

12 3 -10 1 6 0

代码如下

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist();
void printlist( struct ListNode *head )
{
     struct ListNode *p = head,*q;
     int flag =0;
     while (p) {
            q = p->next;
            if(q->data!=0){
                    if(flag==1)
                    printf(" ");
                    printf("%d %d", (q->data)*(p->data),(q->data)-1);
                flag=1;}
            if(q->data-1 <0){
                    if(flag == 0)
                printf("0 0");
                break;
            }
           p = p->next->next;
     }

}
int main()
{
    struct ListNode *head;
    head = createlist();
    printlist(head);

    return 0;
}
struct ListNode *createlist(){
struct ListNode *L,*p,*s;
L= NULL;
p=L;
char ch;
do{
    s=(struct ListNode *)malloc(sizeof(struct ListNode));
    s->next =NULL;
    scanf("%d",&s->data);
    if(L==NULL)
        L=s;
    else
        p->next =s;
    p =s;
}while((ch=getchar())!='\n');
return L;
}

7-4 两个有序链表序列的合并（20 分)

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。
输入格式:

输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。
输出格式:

在一行中输出合并后新的非降序链表，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。
输入样例:

1 3 5 -1
2 4 6 8 10 -1

输出样例:

1 2 3 4 5 6 8 10

代码如下
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
void quick_sort(int s[],int l,int r)
{
    if(l < r)
    {
        int i=l,j=r,x=s[l];
        while(i<j)
        {
            while(i<j && s[j]>=x)
                j--;
            if(i<j)
                s[i++]=s[j];

            while(i<j && s[i]<=x)
                i++;
            if(i<j)
                s[j--]=s[i];

        }

        s[i]=x;
        quick_sort(s,l,i-1);
        quick_sort(s,i+1,r);
    }
}

int main()
{
    int a[100],b[100],c[100];
    int n;
    int ka = 0,kb=0,kc=0;
    while((scanf("%d",&n))!=EOF)
    {
        if(n == -1)
            break;
            a[ka++] = n;
    }
    while((scanf("%d",&n))!=EOF)
    {
        if(n == -1)
            break;
            b[kb++] = n;
    }
    for(int i = 0 ; i < ka; i++)
        c[kc++]= a[i];
    for(int j = 0 ; j < kb; j++)
            c[kc++]=b[j];
quick_sort(c,0,kc-1);
    if(kc != 0)
    {
        for(int i = 0 ; i < kc-1; i++)
            printf("%d ",c[i]);
        printf("%d",c[kc-1]);
    }
    else
        printf("NULL");

    return 0;
}

7-5 两个有序链表序列的交集（20 分)

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2的交集新链表S3。
输入格式:

输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。
输出格式:

在一行中输出两个输入序列的交集序列，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。
输入样例:

1 2 5 -1
2 4 5 8 10 -1

输出样例:

2 5

代码如下
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a[100],b[100],c[100];
    int n;
    int ka = 0,kb=0,kc=0;
    while((scanf("%d",&n))!=EOF)
    {
        if(n == -1)
            break;
            a[ka++] = n;
    }
    while((scanf("%d",&n))!=EOF)
    {
        if(n == -1)
            break;
            b[kb++] = n;
    }
    for(int i = 0 ;i < ka;i++){
        for(int j = 0 ;j < kb;j++)
            if(a[i] == b[j]){
                c[kc++] = a[i];
                continue;
            }
    }
    if(kc != 0)
    {
        for(int i = 0 ; i < kc-1; i++)
            printf("%d ",c[i]);
        printf("%d",c[kc-1]);
    }
    else
        printf("NULL");

    return 0;
}