PTA链表函数和编程题

6-1 求单链表的表长 (10分)

本题要求实现一个函数，求带头结点的单链表的表长。

函数接口定义：

int Length ( LinkList L );

其中LinkList结构定义如下：

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

L是带头结点的单链表的头指针，函数Length返回单链表的长度。

裁判测试程序样例：

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

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

LinkList Create();/* 细节在此不表 */

int Length ( LinkList L );

int main()
{
    LinkList L = Create();
    printf("%d\n", Length(L));
    return 0;
}

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

输入样例：

2 1 4 5 3 -1

样例：

5

解题代码：

int Length ( LinkList L ){
    	int l = 0;
        if(L==NULL)
                return 0;
        while(L->next!=NULL&&L->data!=-1)    
        {        
        	l++;        
        	L=L->next;    
        	}    
        return l;
     }

6-2 带头结点的单链表插入操作 (10分)

解题代码：

https://blog.csdn.net/qq_44164791/article/details/104677654

6-3 带头结点的单链表删除操作 (10分)

解题代码：

https://blog.csdn.net/qq_44164791/article/details/104677654

6-5 求单链表元素序号 (10分)

本题要求实现一个函数，求带头结点的单链表中元素序号。

函数接口定义：

int Locate ( LinkList L, ElemType e);

L是带头结点的单链表的头指针，e是要查找的元素值。如果e在单链表中存在，函数Locate返回其序号（序号从1开始）；否则，返回0。

裁判测试程序样例：

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

typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

LinkList Create();/* 细节在此不表 */

int Locate ( LinkList L, ElemType e);

int main()
{
	ElemType e;
	LinkList L = Create();
	scanf("%d",&e);
	printf("%d\n", Locate(L,e));
	return 0;
}

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

输入样例：

2 1 4 5 3 -1
5

输出样例：

4

解题代码：

int Locate ( LinkList L, ElemType e)
{ 
    LNode *p;
    p=L->next;
    int i = 0;
    while(p)
    {
        i++;
        if(p->data==e) return i;
        p=p->next;
    }
}

6-7 带头结点的单链表就地逆置 (10分)

本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。

函数接口定义：

void ListReverse_L(LinkList &L);

其中 L 是一个带头结点的单链表。

裁判测试程序样例：

//库函数头文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

typedef int  Status;
typedef int  ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status ListCreate_L(LinkList &L,int n)
{
    LNode *rearPtr,*curPtr;   //一个尾指针，一个指向新节点的指针
    L=(LNode*)malloc(sizeof (LNode));
    if(!L)exit(OVERFLOW);
    L->next=NULL;               //先建立一个带头结点的单链表
    rearPtr=L;  //初始时头结点为尾节点,rearPtr指向尾巴节点
    for (int i=1;i<=n;i++){  //每次循环都开辟一个新节点，并把新节点拼到尾节点后
        curPtr=(LNode*)malloc(sizeof(LNode));//生成新结点
        if(!curPtr)exit(OVERFLOW);
        scanf("%d",&curPtr->data);//输入元素值
        curPtr->next=NULL;  //最后一个节点的next赋空
        rearPtr->next=curPtr;
        rearPtr=curPtr;
    }
    return OK;
}
void ListReverse_L(LinkList &L);
void ListPrint_L(LinkList &L){
//输出单链表
    LNode *p=L->next;  //p指向第一个元素结点
    while(p!=NULL)
    {
          if(p->next!=NULL)
               printf("%d ",p->data);
          else
               printf("%d",p->data);
          p=p->next;
    }
}
int main()
{
    LinkList L;
    int n;
    scanf("%d",&n);
    if(ListCreate_L(L,n)!= OK) {
          printf("表创建失败！！！\n");
          return -1;
    }
    ListReverse_L(L);
    ListPrint_L(L);
    return 0;
}
/* 请在这里填写答案 */

输入格式：
第一行输入一个整数n，表示单链表中元素个数，接下来一行共n个整数，中间用空格隔开。
输出格式：
输出逆置后顺序表的各个元素，两个元素之间用空格隔开，最后一个元素后面没有空格。

输入样例：

4
1 2 3 4

输出样例：

4 3 2 1

解题代码：

void ListReverse_L(LinkList &L)
{
    if(L == NULL || L->next == NULL || L->next->next == NULL)
        return ;
    LNode *p = L->next->next;
    L->next->next = NULL;
    while(p)
    {
        LNode *q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
}

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

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

函数接口定义：

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

7-1 两个有序链表序列的合并 (17分)

已知两个非降序链表序列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>
#define  ERROR   0
#define  OK            1
typedef int ElemType;
typedef struct LNode{
        ElemType Data;        
        struct LNode * Next;
}LNode, * List;
List Create_L();
List CombineToL(List L1,List L2);
int main(){
        List L,L1,L2;        
        int m,n,i;        
        L1=Create_L();        
        L2=Create_L();        
        L=CombineToL(L1,L2);        
        if(!L)
                printf("NULL");            //链表为空时
        else{         
              while(L->Next){             
                       printf("%d ",L->Data);                        
                       L=L->Next;                
              }                
              printf("%d",L->Data);        
        }        
        return 0;
}List Create_L(){
        List head,L,pro;        
        int n;        
        L=(List)malloc(sizeof(LNode));        
        head=L;        
        scanf("%d",&n);        
        if(n==-1){        
                 L=NULL;                
                 return L;        
        }        
        while(1){       
                if(n==-1){                      //序列结束符号                        
                	pro->Next=NULL;         //序列尾指向NULL                        
                	free(L);                //释放多余节点                        
                	return head;                
                }                
                L->Data=n;                
                L->Next=(List)malloc(sizeof(LNode));               
                pro=L;                
                L=L->Next;                
                scanf("%d",&n);        
         }
}List CombineToL(List L1,List L2){
        List L,head;        
        L=(List)malloc(sizeof(LNode));            //建立一个空节点，起到头结点的作用，便于后续拼接        
        head=L;        
        while(L1&&L2){
                        if(L1->Data<=L2->Data){
                               L->Next=L1;                        
                               L=L->Next;                        
                               L1=L1->Next;                
                        }                
                        else{                
                               L->Next=L2;                        
                               L=L->Next;L2=L2->Next;                
                        }        
        }        
        if(L1){                        //L2进行到空或者L2初始为空                
        	L->Next=L1;                
        	L=head;                
        	head=head->Next;                
        	free(L);                
        	return head;        
        }        
        else if(L2){                   //L1进行到空或者L1初始为空                
        	L->Next=L2;                
        	L=head;                
        	head=head->Next;                
        	free(L);                
        	return head;        
        }        
        else                            //两者初始皆为空                
        return  NULL;
}

7-2 单链表的创建及遍历 (17分)

读入n值及n个整数，建立单链表并遍历输出。

输入格式:

读入n及n个整数。

输出格式:

输出n个整数，以空格分隔（最后一个数的后面没有空格）。

输入样例:

在这里给出一组输入。例如：

2
10 5

输出样例:
在这里给出相应的输出。例如：

10 5

解题代码：

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
    int data;
    struct node*next;
    }linklist;
linklist *CreatListR(int n){
    int i,m;
    linklist  *head,*s,*r;    
    head=(linklist*)malloc(sizeof(linklist));    
    r=head;    
    for(i=0;i<n;i++){                
    s=(linklist*)malloc(sizeof(linklist));        
    scanf("%d",&m);       
     s->data=m;       
      r->next=s;        
      r=s;                    }    
      r->next=NULL;    
      return head;}  
      int main(){    
      int n;   
      scanf("%d",&n);    
      if(n<=0) return 0;    
      linklist *s;    
      s=CreatListR(n);   
      s=s->next;    
      printf("%d",s->data);    
      while(s->next!=NULL){        
      s=s->next;        
      printf(" %d",s->data);
          }     
           return 0;
       }