SDUT---OJ《資料結構與演算法》實踐能力專題訓練2 連結串列

@小阿寶發表於2020-11-11
資料結構演算法

A - 資料結構實驗之連結串列一：順序建立連結串列

Description

輸入N個整數，按照輸入的順序建立單連結串列儲存，並遍歷所建立的單連結串列，輸出這些資料。

Input

第一行輸入整數的個數N；
第二行依次輸入每個整數。

Output

輸出這組整數。

Sample

Input 

8
12 56 4 6 55 15 33 62

Output 

12 56 4 6 55 15 33 62

Hint

不得使用陣列！

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
struct node
{
    int data;
    struct node *next;
};
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1;i<=n;i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        tail->next=p;
        tail=p;
    }
    return head;
};
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}
int main()
{
    int n;
    struct node*head1;
    scanf("%d",&n);
    head1=(struct node*)malloc(sizeof(struct node));
    head1=creat(head1,n);
    show(head1);
    printf("\n");
    return 0;
}

B - 資料結構實驗之連結串列二：逆序建立連結串列

Description

輸入整數個數N，再輸入N個整數，按照這些整數輸入的相反順序建立單連結串列，並依次遍歷輸出單連結串列的資料。

Input

第一行輸入整數N;；
第二行依次輸入N個整數，逆序建立單連結串列。

Output

依次輸出單連結串列所存放的資料。

Sample

Input 

10
11 3 5 27 9 12 43 16 84 22

Output 

22 84 16 43 12 9 27 5 3 11

Hint

不能使用陣列！

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
struct node
{
    int data;
    struct node *next;
};
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1;i<=n;i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*creat1(struct node*head,int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p,*tail;
    tail=head;
    for(int i=0;i<n;i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;

    }
    return head;
};
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}
int main()
{
    int n;
    struct node*head1;
    scanf("%d",&n);
    head1=(struct node*)malloc(sizeof(struct node));
    head1=creat1(head1,n);
    show(head1);
    printf("\n");
    return 0;
}

C - 資料結構實驗之連結串列三：連結串列的逆置

Description

輸入多個整數，以-1作為結束標誌，順序建立一個帶頭結點的單連結串列，之後對該單連結串列的資料進行逆置，並輸出逆置後的單連結串列資料。

Input

輸入多個整數，以-1作為結束標誌。

Output

輸出逆置後的單連結串列資料。

Sample

Input 

12 56 4 6 55 15 33 62 -1

Output 

62 33 15 55 6 4 56 12

Hint

不得使用陣列。

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
struct node
{
    int data;
    struct node *next;
};
struct node*creat(struct node*head)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1;;i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        if(p->data==-1)
        {
            break;
        }
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*creat1(struct node*head,int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p,*tail;
    tail=head;
    for(int i=0;i<n;i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;

    }
    return head;
};
struct node*nizhi(struct node*head)
{
    struct node*p,*q;
    p=head->next;
    q=p->next;
    head->next=NULL;
    while(q)
    {
        p->next=head->next;
        head->next=p;
        p=q;
        q=q->next;
    }
    p->next=head->next;
    head->next=p;
    return head;
};
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}
int main()
{
    int n;
    struct node*head1;
    head1=(struct node*)malloc(sizeof(struct node));
    head1=creat(head1);
    nizhi(head1);
    show(head1);
    printf("\n");
    return 0;
}

D - 資料結構實驗之連結串列四：有序連結串列的歸併

Description

分別輸入兩個有序的整數序列（分別包含M和N個資料），建立兩個有序的單連結串列，將這兩個有序單連結串列合併成為一個大的有序單連結串列，並依次輸出合併後的單連結串列資料。

Input

第一行輸入M與N的值；
第二行依次輸入M個有序的整數；
第三行依次輸入N個有序的整數。

Output

輸出合併後的單連結串列所包含的M+N個有序的整數。

Sample

Input 

6 5
1 23 26 45 66 99
14 21 28 50 100

Output 

1 14 21 23 26 28 45 50 66 99 100

Hint

不得使用陣列！

#include <bits/stdc++.h>
using namespace std;
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int n,m;
    struct node *head, *head1, *q, *tail, *p,*p1,*head2;
    head=(struct node*)malloc(sizeof(struct node));
    head1=(struct node*)malloc(sizeof(struct node));
    head2=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    head1->next=NULL;
    head2->next=NULL;
    scanf("%d %d",&m,&n);
    tail=head;
    while(m--)
    {
        p=(struct node*)malloc(sizeof(struct node));
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;
        tail=p;
    }
    tail=head1;
    while(n--)
    {
        p=(struct node*)malloc(sizeof(struct node));
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;
        tail=p;
    }
    p=head->next;
    p1=head1->next;
    head->next=NULL;
    tail=head;
    while(p1&&p)
    {
       if(p->data<p1->data)
       {
           tail->next=p;
           tail=p;
           p=p->next;
           tail->next=NULL;
       }
       else
       {
          tail->next=p1;
          tail=p1;
          p1=p1->next;
          tail->next=NULL;
       }
    }
    if(p)
    {
       tail->next=p;
    }
    else
    {
       tail->next=p1;
    }
    p=head->next;
    printf("%d",p->data);
    p=p->next;
    while(p!=NULL)
    {
       printf(" %d",p->data);
       p=p->next;
    }
    printf("\n");
    return 0;
}

E - 資料結構實驗之連結串列五：單連結串列的拆分

Description

輸入N個整數順序建立一個單連結串列，將該單連結串列拆分成兩個子連結串列，第一個子連結串列存放了所有的偶數，第二個子連結串列存放了所有的奇數。兩個子連結串列中資料的相對次序與原連結串列一致。

Input

第一行輸入整數N;；
第二行依次輸入N個整數。

Output

第一行分別輸出偶數連結串列與奇數連結串列的元素個數；
第二行依次輸出偶數子連結串列的所有資料；
第三行依次輸出奇數子連結串列的所有資料。

Sample

Input 

10
1 3 22 8 15 999 9 44 6 1001

Output 

4 6
22 8 44 6 
1 3 15 999 9 1001

Hint

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

struct node
{
    int data;
    struct node *next;
};
int main()
{
    int n,m,x,y;
    struct node *head1, *p, *p1, *tail, *p2, *head2;
    head1=(struct node*)malloc(sizeof(struct node));
    head2=(struct node*)malloc(sizeof(struct node));
    head1->next=NULL;
    head2->next=NULL;
    scanf("%d",&n);
    p1=head1;
    p2=head2;
    x=y=0;
    while(n--)
    {
        scanf("%d",&m);
        if(m%2==0)
        {
            p=(struct node*)malloc(sizeof(struct node));
            p->data=m;
            p->next=NULL;
            p->next=p1->next;
            p1->next=p;
            p1=p;
            x++;
        }
        else
        {
            p=(struct node*)malloc(sizeof(struct node));
            p->data=m;
            p->next=NULL;
            p->next=p2->next;
            p2->next=p;
            p2=p;
            y++;
        }
    }
    printf("%d %d\n",x,y);
    p=head1->next;
    printf("%d",p->data);
    p=p->next;
    while(p!=NULL)
    {
        printf(" %d",p->data);
        p=p->next;
    }
    printf("\n");
    p=head2->next;
    printf("%d",p->data);
    p=p->next;
    while(p!=NULL)
    {
        printf(" %d",p->data);
        p=p->next;
    }
    printf("\n");
    return 0;
}

F - 資料結構實驗之連結串列六：有序連結串列的建立

Description

輸入N個無序的整數，建立一個有序連結串列，連結串列中的結點按照數值非降序排列，輸出該有序連結串列。

Input

第一行輸入整數個數N；
第二行輸入N個無序的整數。

Output

依次輸出有序連結串列的結點值。

Sample

Input 

6
33 6 22 9 44 5

Output 

5 6 9 22 33 44

Hint

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
struct node
{
    int data;
    struct node *next;
};
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1;i<=n;i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*search(struct node*head1,int n)
{
    while(n--)
    {

        struct node*tail=head1;
        int key;
        scanf("%d",&key);
        while(tail->next)
        {

            if(tail->next->data>key)
            {
                struct node*p;
                p=(struct node*)malloc(sizeof(struct node));
                p->next=NULL;
                p->data=key;
                p->next=tail->next;
                tail->next=p;
                tail=head1;
                break;
            }
            else
            {
                tail=tail->next;
            }
        }
        if(tail->next==NULL)
        {
            struct node*p=(struct node*)malloc(sizeof(struct node));
            p->next=NULL;
            p->data=key;
            tail->next=p;
        }
    }
    return head1;
};
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}
int main()
{
    int n,n1=0,n2=0;
    scanf("%d",&n);
    struct node*head1=(struct node*)malloc(sizeof(struct node));
    head1->next=NULL;
    head1=search(head1,n);
    show(head1);
    printf("\n");
    return 0;
}

 

G - 資料結構實驗之連結串列七：單連結串列中重複元素的刪除

Description

按照資料輸入的相反順序（逆位序）建立一個單連結串列，並將單連結串列中重複的元素刪除（值相同的元素只保留最後輸入的一個）。

Input

第一行輸入元素個數 n (1 <= n <= 15)；
第二行輸入 n 個整數，保證在 int 範圍內。

Output

第一行輸出初始連結串列元素個數；
第二行輸出按照逆位序所建立的初始連結串列；
第三行輸出刪除重複元素後的單連結串列元素個數；
第四行輸出刪除重複元素後的單連結串列。

Sample

Input 

10
21 30 14 55 32 63 11 30 55 30

Output 

10
30 55 30 11 63 32 55 14 30 21
7
30 55 11 63 32 14 21
#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int n, m, x, i;
    scanf("%d",&n);
    struct node *head, *p, *q, *t;
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    for(i=0; i<n; i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        scanf("%d",&p->data);
        p->next=head->next;
        head->next=p;
    }
    printf("%d\n",n);
    p=head->next;
    printf("%d",p->data);
    p=p->next;
    while(p)
    {
        printf(" %d",p->data);
        p=p->next;
    }
    printf("\n");
    p=head->next;
    while(p->next!=NULL)
    {
        q=p->next;
        t=p;
        while(q)
        {
            if(p->data==q->data)
            {
                q=q->next;
                t->next=q;
                n--;
            }
            else
            {
                t=t->next;
                q=q->next;
            }
        }
        if(p->next==NULL)
        {
            break;
        }
        else
        {
            p=p->next;
        }
    }
    printf("%d\n",n);
    p=head->next;
    printf("%d",p->data);
    p=p->next;
    while(p)
    {
        printf(" %d",p->data);
        p=p->next;
    }
    printf("\n");
    return 0;
}

H - 資料結構實驗之連結串列八：Farey序列

Description

Farey序列是一個這樣的序列：其第一級序列定義為（0/1，1/1），這一序列擴充套件到第二級形成序列（0/1，1/2，1/1），擴充套件到第三極形成序列（0/1，1/3，1/2，2/3，1/1），擴充套件到第四級則形成序列（0/1，1/4，1/3，1/2，2/3，3/4，1/1）。以後在每一級n，如果上一級的任何兩個相鄰分數a/c與b/d滿足（c+d）<=n，就將一個新的分數(a+b)/(c+d)插入在兩個分數之間。對於給定的n值，依次輸出其第n級序列所包含的每一個分數。

Input

輸入一個整數n(0<n<=100)

Output

依次輸出第n級序列所包含的每一個分數，每行輸出10個分數，同一行的兩個相鄰分數間隔一個製表符的距離。

Sample

Input 

6

Output 

0/1   1/6   1/5   1/4   1/3   2/5   1/2   3/5   2/3   3/4
4/5   5/6   1/1

Hint

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
struct node
{
    int data1,data2;
    struct node *next;
};
/*
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1;i<=n;i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        if(p->data==-1)
        {
            break;
        }
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*creat1(struct node*head,int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p,*tail;
    tail=head;
    for(int i=0;i<n;i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;

    }
    return head;
};
struct node*nizhi(struct node*head)
{
    struct node*p,*q;
    p=head->next;
    q=p->next;
    head->next=NULL;
    while(q)
    {
        p->next=head->next;
        head->next=p;
        p=q;
        q=q->next;
    }
    p->next=head->next;
    head->next=p;
    return head;
};
struct node*delete1(struct node*head)
{
    struct node*p,*q,*t;
    p=head->next;
    while(p->next!=NULL)
    {
        q=p->next;
        t=p;
        while(q)
        {
            if(p->data==q->data)
            {
                q=q->next;
                t->next=q;
                n--;
            }
            else
            {
                t=t->next;
                q=q->next;
            }
        }
        if(p->next==NULL)
        {
            break;
        }
        else
        {
            p=p->next;
        }
    }
};
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}*/
int main()
{
    struct node*head,*last;
    head=(struct node*)malloc(sizeof(struct node));
    last=(struct node*)malloc(sizeof(struct node));
    head->next=last;
    head->data1=0;
    head->data2=1;
    last->data1=1;
    last->data2=1;
    int n;
    scanf("%d",&n);
    int i=n;
    struct node*tail=head;
    n--;
    while(n--)
    {
        tail=head;
        while(tail->next)
        {
            if(tail->data2+tail->next->data2<=i)
            {
                struct node*p;
                p=(struct node*)malloc(sizeof(struct node));
                p->data1=tail->data1+tail->next->data1;
                p->data2=tail->data2+tail->next->data2;
                p->next=tail->next;
                tail->next=p;
            }
            tail=tail->next;
        }
    }
    tail=head;
    int top=1;
    int kk=0;
    while(tail)
    {
        if(kk%10==0&&kk)
        {
            printf("\n");
        }
        else if(top==1)
        {
            top=0;
        }
        else
        {
            printf("\t");
        }
        printf("%d/%d",tail->data1,tail->data2);
        kk++;
            tail=tail->next;
    }
    return 0;
}

I - 資料結構實驗之連結串列九：雙向連結串列

Description

學會了單向連結串列，我們又多了一種解決問題的能力，單連結串列利用一個指標就能在記憶體中找到下一個位置，這是一個不會輕易斷裂的鏈。但單連結串列有一個弱點——不能回指。比如在連結串列中有兩個節點A,B，他們的關係是B是A的後繼，A指向了B，便能輕易經A找到B,但從B卻不能找到A。一個簡單的想法便能輕易解決這個問題——建立雙向連結串列。在雙向連結串列中，A有一個指標指向了節點B，同時，B又有一個指向A的指標。這樣不僅能從連結串列頭節點的位置遍歷整個連結串列所有節點，也能從連結串列尾節點開始遍歷所有節點。對於給定的一列資料，按照給定的順序建立雙向連結串列，按照關鍵字找到相應節點，輸出此節點的前驅節點關鍵字及後繼節點關鍵字。

Input

第一行兩個正整數n（代表節點個數），m（代表要找的關鍵字的個數）。第二行是n個數（n個數沒有重複），利用這n個數建立雙向連結串列。接下來有m個關鍵字，每個佔一行。

Output

對給定的每個關鍵字，輸出此關鍵字前驅節點關鍵字和後繼節點關鍵字。如果給定的關鍵字沒有前驅或者後繼，則不輸出。
注意：每個給定關鍵字的輸出佔一行。一行輸出的資料之間有一個空格，行首、行末無空格。

 

Sample

Input 

10 3
1 2 3 4 5 6 7 8 9 0
3
5
0

Output 

2 4
4 6
9

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
struct node
{
    int data;
    struct node *next,*last;
};
/*
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1;i<=n;i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        if(p->data==-1)
        {
            break;
        }
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*creat1(struct node*head,int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p,*tail;
    tail=head;
    for(int i=0;i<n;i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;

    }
    return head;
};
struct node*nizhi(struct node*head)
{
    struct node*p,*q;
    p=head->next;
    q=p->next;
    head->next=NULL;
    while(q)
    {
        p->next=head->next;
        head->next=p;
        p=q;
        q=q->next;
    }
    p->next=head->next;
    head->next=p;
    return head;
};
struct node*delete1(struct node*head)
{
    struct node*p,*q,*t;
    p=head->next;
    while(p->next!=NULL)
    {
        q=p->next;
        t=p;
        while(q)
        {
            if(p->data==q->data)
            {
                q=q->next;
                t->next=q;
                n--;
            }
            else
            {
                t=t->next;
                q=q->next;
            }
        }
        if(p->next==NULL)
        {
            break;
        }
        else
        {
            p=p->next;
        }
    }
};
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}*/
int main()
{
    int n,m,i,j,x,t;
    struct node *head,*p,*p1,*tail,*p2;
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    scanf("%d %d",&n,&m);
    tail=head;
    t=n;
    while(t--)
    {
        p=(struct node*)malloc(sizeof(struct node));
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;
        p->last=tail;
        tail=p;
    }
    for(i=1;i<=m;i++)
    {
        j=0;
        scanf("%d",&x);
        p=head->next;
        while(p)
        {
            j++;
            if(j==1&&p->data==x)
            {
                printf("%d\n",p->next->data);
            }
            else if(j==n&&p->data==x)
            {
                printf("%d\n",p->last->data);
            }
            else if(p->data==x)
            {
                printf("%d %d\n",p->last->data,p->next->data);
            }
            p=p->next;
        }
    }
    return 0;
}

J - 陣列操作

Description

給你一個長度為 n 的陣列，並給出如下幾種操作：

  1. 在下標為 a 的位置插入一個整數 b，如果其後有元素，則全部後移。例如，陣列為 1, 2, 3，在下標為 1 的位置插入 4，則陣列變為：1, 4, 2, 3。
  2. 刪除下標為 a 的元素，如果其後有元素，則全部前移。例如，陣列為 1, 2, 3，刪除下標為 0 的元素，則陣列變為：2, 3。
  3. 修改下標為 a 的元素的值為 b。
  4. 輸出整個陣列。

Input

輸入資料有多組（資料組數不超過 10），到 EOF 結束。

對於每組資料：

  • 首先輸入一行 n, m (1 <= n <= 10^6, 1 <= m <= 10^4)，分別表示初始陣列的長度和操作次數。
  • 接下來一行輸入 n 個用空格隔開的整數 Ai (0 <= Ai <= 1000)，表示初始的陣列。
  • 最後有 m 行，每行對應一次操作，根據操作型別分為不同的輸入格式（具體含義參見描述部分，0 <= a, b <= 1000）：
    • 1 a b
    • 2 a
    • 3 a b
    • 4

Output

對於每組資料中的每次型別為 4 的操作，輸出一行，表示此時的陣列，每個整數之間用空格隔開。

Sample

Input 

3 6
1 2 3
1 1 4
4
2 2
4
3 2 8
4

Output 

1 4 2 3
1 4 3
1 4 8

Hint

建議使用連結串列完成。

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
struct node
{
    int data;
    struct node *next,*last;
};
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1; i<=n; i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*creat1(struct node*head,int n) //逆序
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p,*tail;
    tail=head;
    for(int i=0; i<n; i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;

    }
    return head;
};
struct node*nizhi(struct node*head)
{
    struct node*p,*q;
    p=head->next;
    q=p->next;
    head->next=NULL;
    while(q)
    {
        p->next=head->next;
        head->next=p;
        p=q;
        q=q->next;
    }
    p->next=head->next;
    head->next=p;
    return head;
};
struct node*op1(struct node*head,int a,int b)
{
    struct node*p,*q;
    p=head;
    q=(struct node*)malloc(sizeof(struct node));
    q->data=b;
    while(a--)
    {
        p=p->next;
    }
    q->next=p->next;
    p->next=q;
    return head;
};
struct node*op2(struct node*head,int a)
{
    struct node*p;
    p=head;
    while(a--)
    {
        p=p->next;
    }
    p->next=p->next->next;
    return head;
};
struct node*op3(struct node*head,int a,int b)
{
    struct node*p;
    p=head;
    while(a--)
    {
        p=p->next;
    }
    p->next->data=b;
    return head;
};
/*struct node*delete1(struct node*head)
{
    struct node*p,*q,*t;
    p=head->next;
    while(p->next!=NULL)
    {
        q=p->next;
        t=p;
        while(q)
        {
            if(p->data==q->data)
            {
                q=q->next;
                t->next=q;
                n--;
            }
            else
            {
                t=t->next;
                q=q->next;
            }
        }
        if(p->next==NULL)
        {
            break;
        }
        else
        {
            p=p->next;
        }
    }
};*/
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}
int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        struct node*head1;
        head1=(struct node*)malloc(sizeof(struct node));
        head1=creat(head1,n);
        int a,b,x;
        for(int i=0; i<m; i++)
        {
            scanf("%d",&x);
            if(x==1)
            {
                scanf("%d %d",&a,&b);
                head1=op1(head1,a,b);
            }
            else if(x==2)
            {
                scanf("%d",&a);
                head1=op2(head1,a);
            }
            else if(x==3)
            {
                scanf("%d %d",&a,&b);
                head1=op3(head1,a,b);
            }
            else if(x==4)
            {
                show(head1);
                printf("\n");
            }
        }
    }
    return 0;
}

K - 移動小球

Description

給你n個小球，從左到右編號依次為1,2,3,4,5,6.........n排成一行。現在有以下2種操作：A x y表示把編號為x小球移動到編號為y的小球的左邊(和y相鄰)。Q x為詢問編號為x的小球左邊的球號，如果x左邊沒有小球的話輸出"cyk666"。

Input

第一行輸入一個T，表示有T組測試資料。（1<=T<=100）

隨後每一組測試資料第一行是兩個整數N,M，其中N表示球的個數(1 隨後有M行詢問，第一個字元是操作型別s。

當s為'A'時，輸入x，y表示把編號為x小球移動到編號為y的小球的左邊。

當s為'Q'時，輸入x表示詢問小球x左邊的球號。保證（1<=x<=N,1<=y<=N,1<=N<=100000）

Output

輸出每次詢問的球號，如果這樣的小球不存在，輸出"cyk666"(不包括引號)。

Sample

Input 

1
6 5
A 1 2
A 1 4
A 3 5
Q 5
Q 2

Output 

3
cyk666
#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
int res;
struct node
{
    int data;
    struct node *next,*last;
};
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1; i<=n; i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        p->data=i;
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*creat1(struct node*head,int n) //逆序
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p,*tail;
    tail=head;
    for(int i=0; i<n; i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;

    }
    return head;
};
struct node*nizhi(struct node*head)
{
    struct node*p,*q;
    p=head->next;
    q=p->next;
    head->next=NULL;
    while(q)
    {
        p->next=head->next;
        head->next=p;
        p=q;
        q=q->next;
    }
    p->next=head->next;
    head->next=p;
    return head;
};
struct node*op1(struct node*head,int x,int y)
{
    struct node*p,*q;
    p=head;
    q=(struct node*)malloc(sizeof(struct node));
    while(p->next->data!=x)
    {
        p=p->next;
    }
    q->data=p->next->data;
    p->next=p->next->next;
    p=head;
    while(p->next->data!=y)
    {
        p=p->next;
    }
    q->next=p->next;
    p->next=q;
    return head;
};
struct node*op2(struct node*head,int x)
{
    struct node*p,*q;
    p=head;
    int k=0;
    while(p->next->data!=x)
    {
        k++;
        p=p->next;
    }
    if(k!=0)
    {
        printf("%d\n",p->data);
    }
    else
    {
        printf("cyk666\n");
    }
    return head;
};
/*struct node*delete1(struct node*head)
{
    struct node*p,*q,*t;
    p=head->next;
    while(p->next!=NULL)
    {
        q=p->next;
        t=p;
        while(q)
        {
            if(p->data==q->data)
            {
                q=q->next;
                t->next=q;
                n--;
            }
            else
            {
                t=t->next;
                q=q->next;
            }
        }
        if(p->next==NULL)
        {
            break;
        }
        else
        {
            p=p->next;
        }
    }
};*/
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}
int main()
{
    int n,m,t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&m);
        struct node*head1;
        head1=(struct node*)malloc(sizeof(struct node));
        head1=creat(head1,n);
        int a,b;
        char x;
        for(int i=0; i<m; i++)
        {
            getchar();
            scanf("%c",&x);
            if(x=='A')
            {
                scanf("%d %d",&a,&b);
                head1=op1(head1,a,b);
            }
            else if(x=='Q')
            {
                scanf("%d",&a);
                head1=op2(head1,a);
            }
        }
    }
    return 0;
}

L - 尋找關鍵點

Description

現定義關鍵點為一條鏈中處於中間位置的節點，例如 1 3 4中，3就是這個整數鏈中的關鍵點。

現在小玉得到了一個整數鏈，確保鏈中的各個數都互不相同且數列中數的個數為奇數。

可是，由於小玉的一些特殊要求，她可能會對這個鏈進行一些特別的操作。

  • 操作 1 ：給定兩個數a和b，每次刪除鏈中值為a和值為b兩個節點。
  • 操作 2 ：給定兩個數a和b，每次在鏈中值為1的節點後插入a，在鏈中值為2的節點後插入b。

由於小玉特殊的要求，她保證鏈中肯定會有值為1和2的節點，並且這兩個節點永遠不會被刪除。保證在插入操作之後鏈中始終不會有重複值的節點。

現在請你寫出一個程式，幫助小玉找出鏈中的關鍵點。

Input

只有一組資料

先輸入一個整數n（10<=n<=100000）,且保證n一定為奇數

接下來輸入n個互不相同的整數num（1<=num<=10000000)

接著下一行輸入一個整數m（1<=m<=4000)

代表接下來有m行

每行有3個數aa,bb,cc. 其中第一個數aa表示操作型別，aa為1代表刪除鏈中值為bb和cc的數，

aa為2代表在鏈中值為1的節點後增加值為bb的節點，在鏈中值為2的節點後增加值為cc的節點。

（保證刪除的節點在鏈中一定有，保證插入的節點與鏈中已有節點不會重複）

Output

對於每次操作，輸出一個值h，代表操作完成後鏈中的關鍵點。

Sample

Input 

5
1 3 4 5 2
2
1 3 4
2 3 4

Output 

5
5
#include<stdio.h>
#include<cstdlib>
#include<iostream>
#include<bits/stdc++.h>

using namespace std;
int res;
struct node
{
    int data;
    struct node *next,*last;
};
struct node*creat(struct node*head, int n)
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node*tail=head;
    for(int i=1; i<=n; i++)
    {
        struct node*p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        tail->next=p;
        tail=p;
    }
    return head;
};
struct node*creat1(struct node*head,int n) //逆序
{
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    struct node *p,*tail;
    tail=head;
    for(int i=0; i<n; i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        p->next=NULL;
        scanf("%d",&p->data);
        p->next=tail->next;
        tail->next=p;

    }
    return head;
};
struct node*nizhi(struct node*head)
{
    struct node*p,*q;
    p=head->next;
    q=p->next;
    head->next=NULL;
    while(q)
    {
        p->next=head->next;
        head->next=p;
        p=q;
        q=q->next;
    }
    p->next=head->next;
    head->next=p;
    return head;
};
struct node*op1(struct node*head,int a,int b)
{
    struct node*p,*q;
    p=head;
    q=(struct node*)malloc(sizeof(struct node));
    q=head->next;
    while(p->next!=NULL)
    {
        if(p->data==a)
        {
            q->next=p->next;
            free(p);
            p=q->next;
        }
        else if(p->data==b)
        {
            q->next=p->next;
            free(p);
            p=q->next;
        }
        else
        {
            q=p;
            p=p->next;
        }
    }
    if(p->next==NULL)
    {
        if(p->data==a)
        {
            q->next=NULL;
            free(p);
        }
        else if(p->data==b)
        {
            q->next=NULL;
            free(p);
        }
    }
    return head;
};
struct node*op2(struct node*head,int a,int b)
{
    struct node*p,*q;
    p=head->next;
    while(p!=NULL)
    {
        if(p->data==1)
        {
            q=(struct node*)malloc(sizeof(struct node));
            q->data=a;
            q->next=p->next;
            p->next=q;
        }
        if(p->data==2)
        {
            q=(struct node*)malloc(sizeof(struct node));
            q->data=b;
            q->next=p->next;
            p->next=q;
        }
        p=p->next;
    }
    return head;
};
/*struct node*delete1(struct node*head)
{
    struct node*p,*q,*t;
    p=head->next;
    while(p->next!=NULL)
    {
        q=p->next;
        t=p;
        while(q)
        {
            if(p->data==q->data)
            {
                q=q->next;
                t->next=q;
                n--;
            }
            else
            {
                t=t->next;
                q=q->next;
            }
        }
        if(p->next==NULL)
        {
            break;
        }
        else
        {
            p=p->next;
        }
    }
};*/
void show(struct node*head)
{
    struct node*tail;
    tail=head;
    int top=1;
    while(tail->next)
    {
        if(top)
            top=0;
        else
            printf(" ");
        printf("%d",tail->next->data);
        tail=tail->next;
    }
}
int main()
{
    int n,m;
    scanf("%d",&n);
    struct node*head1;
    head1=(struct node*)malloc(sizeof(struct node));
    head1=creat(head1,n);
    int a,b,x;
    scanf("%d",&m);
    for(int i=0; i<m; i++)
    {
        scanf("%d",&x);
        if(x==1)
        {
            scanf("%d %d",&a,&b);
            head1=op1(head1,a,b);
            n=n-2;
        }
        else if(x==2)
        {
            scanf("%d %d",&a,&b);
            head1=op2(head1,a,b);
            n=n+2;
        }
        struct node*p;
        p=(struct node*)malloc(sizeof(struct node));
        p=head1;
        int j=0;
        while(j<(n/2)+1)
        {
            j++;
            p=p->next;
        }
        res=p->data;
        printf("%d\n",res);
    }
    return 0;
}

M - 素數連結串列

Description

我們定義素數連結串列為元素全部是素數的連結串列。

給定一個初始含有 n 個元素的連結串列，並給出 q 次刪除操作，對於每次操作，你需要判斷連結串列中指定位置上的元素，如果元素存在且不是素數則刪除。

在所有操作完成後你還需要檢查一下最終連結串列是否是一個素數連結串列。

Input

輸入資料有多組。第 1 行輸入 1 個整數 T (1 <= T <= 25) 表示資料組數。

對於每組資料：

  • 第 1 行輸入 2 個整數 n (1 <= n <= 50000), q (1 <= q <= 1000) 表示連結串列初始元素數量和操作次數
  • 第 2 行輸入 n 個用空格隔開的整數（範圍 [0, 1000]）表示初始連結串列
  • 接下來 q 行，每行輸入 1 個整數 i (1 <= i <= 50000)，表示試圖刪除連結串列中第 i 個元素

Output

對於每組資料：

  • 先輸出 1 行 "#c"，其中 c 表示當前是第幾組資料
  • 對於每次刪除操作，根據情況輸出 1 行：
    • 如果要刪除的位置不存在元素（位置超出連結串列長度），則輸出 "Invalid Operation"
    • 如果要刪除的位置存在元素且此位置的元素是非素數，則刪除元素並輸出 "Deleted x"，其中 x 為成功刪除的數（必須為非素數才能刪除）
    • 如果要刪除的位置存在元素且此位置的元素是素數，則輸出 "Failed to delete x"，其中 x 為此位置上的數
  • 刪除操作全部進行完畢後，則還需判斷該連結串列現在是否為一個素數連結串列。如果連結串列非空且是素數連結串列，則輸出 "All Completed. It's a Prime Linked List"，否則輸出 "All Completed. It's not a Prime Linked List"

所有輸出均不包括引號。

Sample

Input 

2
1 2
0
5
1
6 3
1 2 3 3 4 5
1
1
4

Output 

#1
Invalid Operation
Deleted 0
All Completed. It's not a Prime Linked List
#2
Deleted 1
Failed to delete 2
Deleted 4
All Completed. It's a Prime Linked List

Hint

推薦直接複製貼上輸出語句字串到你的程式碼中，以防手打敲錯。

連結串列中第 1 個元素的位置為 1，第 2 個元素的位置為 2，以此類推。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int f(int n)
{
    int i, flag = 1;
    if(n == 0 || n == 1) return 0;
    for(i = 2; i <= sqrt(n); i++)
    {
        if(n % i == 0)
        {
            flag = 0;
            break;
        }
    }
    return flag;
}
struct node
{
    int data;
    struct node *next;
};
int count;
struct node *creat(int n);
struct node *del(struct node *head, int x);
void text(struct node *head);
int main()
{
    int t, i, n, q, k, x;
    while(~scanf("%d", &t))
    {
        for(k = 1; k <= t; k++)
        {
            struct node *head;
            head = (struct node *) malloc (sizeof(struct node));
            head->next = NULL;
            printf("#%d\n", k);
            count = 0;
            scanf("%d %d", &n, &q);
            head = creat(n);
            count = n;
            for(i = 1; i <= q; i++)
            {
                scanf("%d", &x);
                if(x > count)
                {
                    printf("Invalid Operation\n");
                    continue;
                }
                else head = del(head, x);
            }
            text(head);
        }
    }
    return 0;
}
struct node *creat(int n)
{
    int i;
    struct node *head, *tail;
    head = (struct node *) malloc (sizeof(struct node));
    head->next = NULL;
    tail = head;
    for(i = 0; i <= n - 1; i++)
    {
        struct node *p;
        p = (struct node *) malloc (sizeof(struct node));
        p->next = NULL;
        scanf("%d", &p->data);
        p->next = tail->next;
        tail->next = p;
        tail = p;
    }
    return head;
};
struct node *del(struct node *head, int x)
{
    int i;
    struct node *q, *p;
    q = head;
    p = head->next;
    for(i = 1; i < x; i++)
    {
        q = q->next;
        p = p->next;
    }
    if(f(p->data) == 1) printf("Failed to delete %d\n", p->data);
    else
    {
        printf("Deleted %d\n", p->data);
        count--;
        q->next = p->next;
    }
    return head;
};
void text(struct node *head)
{
    if(count == 0)
    {
        printf("All Completed. It's not a Prime Linked List\n");
        return;
    }
    int flag = 0;
    struct node *p;
    p = head->next;
    while(p != NULL)
    {
        if(f(p->data) == 0)
        {
            printf("All Completed. It's not a Prime Linked List\n");
            flag = 1;
            break;
        }
        p = p->next;
    }
    if(flag == 0) printf("All Completed. It's a Prime Linked List\n");
};

 

相關文章