双向循环神经网络缺点 双向快速循环治愈过程

目录

7-1 单链表的创建及遍历

7-2 两个有序链表序列的合并

 7-3 两个有序链表序列的交集

7-4 约瑟夫环

 7-5 链表去重

7-6 带头节点的双向循环链表操作

 7-7 单链表就地逆置

 7-8 重排链表

 7-9 头插法创建单链表、遍历链表、删除链表

---

 

7-1 单链表的创建及遍历

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

输入格式:

读入n及n个整数。

输出格式:

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

输入样例:

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

2
10 5

输出样例:

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

10 5

#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
    struct Node *next;
    int data;
}node;
node *creat(int n)
{
    node *head,*p,*tail;
    head=(node*)malloc(sizeof(node));
    head->next=NULL;
    tail=head;
    for(int i=0;i<n;i++)
    {
        p=(node*)malloc(sizeof(node));
        p->next=NULL;
        scanf("%d",&p->data);
        tail->next=p;
        tail=p;
    }
    return head;
}
int main()
{
    int n;
    node *head,*p;
    scanf("%d",&n);
    head=creat(n);
    p=head->next;
    while(p)
    {
        if(p->next==NULL)
            printf("%d",p->data);
        else printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

7-2 两个有序链表序列的合并

已知两个非降序链表序列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>
int count=0;
typedef struct Node
{
    struct Node *next;
    int data;
}node;
node *creat()
{
    int x;
    node *head,*p,*tail;
    head=(node*)malloc(sizeof(node));
    head->next=NULL;
    tail=head;
    while(~scanf("%d",&x)&&x!=-1)
    {
    p=(node*)malloc(sizeof(node));
    p->next=NULL;
    p->data=x;
    tail->next=p;
    tail=p;
    count++;
    }
    return head;
}
void pri(node *p)
{
    while(p)
    {
        if(p->next==NULL)
            printf("%d\n",p->data);
        else printf("%d ",p->data);
        p=p->next;
    }
}
node *merge(node *head1,node *head2)
{
    node *p1,*p2,*tail,*head3;
    p1=head1->next;
    p2=head2->next;
    head3=(node*)malloc(sizeof(node));
    head3->next=NULL;
    tail=head3;
    while(p1&&p2)
    {
        if(p1->data<=p2->data)
        {
            tail->next=p1;
            tail=p1;
            p1=p1->next;
        }
        else
        {
            tail->next=p2;
            tail=p2;
            p2=p2->next;
        }
    }
    if(p1) tail->next=p1;
    else tail->next=p2;
    return head3;
}
int main()
{
    int x,k;
    node *head1,*head2,*head3;
    head1=creat();
    head2=creat();
    if(count!=0)
    {
    head3=merge(head1,head2);
    pri(head3->next);
    }
    else printf("NULL");
    return 0;
}

 7-3 两个有序链表序列的交集

已知两个非降序链表序列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 count=0;
typedef struct Node
{
    struct Node *next;
    int data;
}node;
node *creat()
{
    int x;
    node *head,*p,*tail;
    head=(node*)malloc(sizeof(node));
    head->next=NULL;
    tail=head;
    while(~scanf("%d",&x)&&x!=-1)
    {
    p=(node*)malloc(sizeof(node));
    p->next=NULL;
    p->data=x;
    tail->next=p;
    tail=p;
    }
    return head;
}
void pri(node *p)
{
    while(p)
    {
        if(p->next==NULL)
            printf("%d\n",p->data);
        else printf("%d ",p->data);
        p=p->next;
    }
}
node *merge(node *head1,node *head2)
{
    node *p1,*p2,*tail,*head3;
    p1=head1->next;
    p2=head2->next;
    head3=(node*)malloc(sizeof(node));
    head3->next=NULL;
    tail=head3;
    while(p1&&p2)
    {
        if(p1->data<p2->data)
        {
            p1=p1->next;
        }
        else if(p1->data>p2->data)
        {
            p2=p2->next;
        }
        else if(p1->data==p2->data)
        {
            count=1;
            tail->next=p1;
            tail=p1;
            p1=p1->next;
            p2=p2->next;
        }
    }
    return head3;
}
int main()
{
    node *head1,*head2,*head3;
    head1=creat();
    head2=creat();
    head3=merge(head1,head2);
    if(count==0)
    {
       printf("NULL");
    }
    else pri(head3->next);
    return 0;
}

7-4 约瑟夫环

N个人围成一圈顺序编号，从1号开始按1、2、3......顺序报数，报p者退出圈外，其余的人再从1、2、3开始报数，报p的人再退出圈外，以此类推。
请按退出顺序输出每个退出人的原序号。

输入格式:

输入只有一行，包括一个整数N(1<=N<=3000)及一个整数p(1<=p<=5000)。

输出格式:

按退出顺序输出每个退出人的原序号，数据间以一个空格分隔，但行尾无空格。

输入样例:

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

7 3

输出样例:

3 6 2 7 5 1 4

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct Node
{
    int data;
    struct Node *next;
} node;
node *creat(int n)
{
    node *head,*p,*tail;
    p=(node*)malloc(sizeof(node));
    p->data=1;
    p->next=NULL;
    head=tail=p;
    for(int i=2; i<=n; i++)
    {
        p=(node*)malloc(sizeof(node));
        p->data=i;
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    tail->next=head;
    return head;
}
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    node *head, *p,*q;
    head=creat(n);
    q=head;
    while(q->next!=head)
        q=q->next;
    int a=0;
    while(q->next!=q)
    {
        p=q->next;
        a++;
        if(a==m)
        {
            printf("%d ",p->data);
            q->next=p->next;
            free(p);
            a=0;
        }
        else
            q=p;
    }
    printf("%d",q->data);//输出剩下的最后一个q
    return 0;
}

 7-5 链表去重

给定一个带整数键值的链表 L，你需要把其中绝对值重复的键值结点删掉。即对每个键值 K，只有第一个绝对值等于 K 的结点被保留。同时，所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。

输入格式：

输入在第一行给出 L 的第一个结点的地址和一个正整数 N（≤105，为结点总数）。一个结点的地址是非负的 5 位整数，空地址 NULL 用 -1 来表示。

随后 N 行，每行按以下格式描述一个结点：

地址 键值 下一个结点

其中地址是该结点的地址，键值是绝对值不超过104的整数，下一个结点是下个结点的地址。

输出格式：

首先输出去重后的链表，然后输出被删除的链表。每个结点占一行，按输入的格式输出。

输入样例：

00100 5
99999 -7 87654
23854 -15 00000
87654 15 -1
00000 -15 99999
00100 21 23854

输出样例：

00100 21 23854
23854 -15 99999
99999 -7 -1
00000 -15 87654
87654 15 -1

#include<stdio.h>
#include<stdio.h>
#include<math.h>
#define N 100001
int visit[N] = {0};//判断该值是否已存在；
typedef struct LNode
{
    int data;
    int next;
}LNode,*List;//存放键值与下一个地址；
typedef struct L
{
    int address,data;
}L;//存放地址与键值；
LNode node[N];//存放初始值；
L a[N];int k1 = 0;//存放去重后的值；
L b[N];int k2 = 0;//存放被删除的值；
int main()
{
    int first_address,t;
    scanf("%d %d",&first_address,&t);    
    while(t--)    
    {    
        int m;    //地址;
    	scanf("%d",&m);
        scanf("%d %d",&node[m].data,&node[m].next);//输入键值与下一个地址；
    }    
    //以下为去重操作；
    int n = first_address;    
    while(n != -1)//当n不是空地址
    {        
    	if(visit[abs(node[n].data)] == 0)//如果n键值未出现过的话，visit应为0；
    	{            
    		a[k1].address = n;
    		a[k1].data = node[n].data;
    		k1++;                //相当于实现建链表操作；
    		visit[abs(node[n].data)] = 1;        
    	}        
    	else        //如果已出现过的话，就建立另外一个链表
    	{            
    		b[k2].address = n;            
    		b[k2].data = node[n].data;            
    		k2++;        
    	}        
    	n = node[n].next;//n的地址变为下一个地址
    }
    //处理数据，最后地址为空地址，赋值为-1；
    if(k1>=1)    
    {        
    	a[k1].address = -1;
    }    
    if(k2>=1)    
    {        
    	b[k2].address = -1;    
    }    
    //输出数据    
    int i = 0;    
    while(k1!=0)    
    {        
    	if(a[i+1].address == -1)   //如果下一个地址为空的话；
    	{            
    		printf("%05d %d %d\n",a[i].address,a[i].data,a[i+1].address);//换行输出；
    		break;         
    	}        
    	else
 	       printf("%05d %d %05d\n",a[i].address,a[i].data,a[i+1].address);//不换行输出；  
        i++;    
     }         
     int j = 0;    
    while(k2!=0)    
     {        
     if(b[j+1].address == -1)        
     {            
     	printf("%05d %d %d\n",b[j].address,b[j].data,b[j+1].address);            
     	break;         
     }        
     else         
     	printf("%05d %d %05d\n",b[j].address,b[j].data,b[j+1].address);        
     j++;    
    }         
    return 0;     
}

7-6 带头节点的双向循环链表操作

本题目要求读入一系列整数，依次插入到双向循环链表的头部和尾部，然后顺序和逆序输出链表。

链表节点类型可以定义为

typedef int DataType;
typedef struct LinkedNode{
    DataType data;
    struct LinkedNode *prev;
    struct LinkedNode *next;
}LinkedNode;

链表类型可以定义为

typedef struct LinkedList{
  int length; /* 链表的长度 */
  LinkedNode head; /* 双向循环链表的头节点 */
}LinkedList;

初始化链表的函数可声明为

void init_list(LinkedList *list);

分配节点的函数可声明为

LinkedNode *alloc_node(DataType data);

头部插入的函数可声明为

void push_front(LinkedList *list, DataType data);

尾部插入的函数可声明为

void push_back(LinkedList *list, DataType data);

顺序遍历的函数可声明为

void traverse(LinkedList *list);

逆序遍历的函数可声明为

void traverse_back(LinkedList *list);

输入格式:

输入一行整数（空格分隔），以-1结束。

输出格式:

第一行输出链表顺序遍历的结果，第二行输出逆序遍历的结果。

输入样例:

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

1 2 3 4 5 6 -1

输出样例:

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

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct Node
{
    int data;
    struct Node *next;
    struct Node *front;
}node;
int main()
{
    node *head,*q,*p,*h;
    head=(node*)malloc(sizeof(node));
    head->next=NULL;
    head->front=NULL;
    head->data=-1;
    q=head;//用于记录head节点
    h=head;//用于记录head节点
    int x;
    int count=1;
    while(~scanf("%d",&x))
   {
       count++;
       if(x==-1)
       {
           break;
       }
        else
        {
            p=(node*)malloc(sizeof(node));
            p->data=x;
            p->front=NULL;
            p->next=NULL;
            if(count%2!=0)
            {
                q->front=p;
                p->next=q;
                q=p;
            }
            else
            {
                h->next=p;
                p->front=h;
                h=h->next;
            }
        }
    }//上述操作可形成q在头，h在尾的指针
    while(h)
    {
        if(h!=head)
        {
            if(h->front)
            {
                printf("%d ",h->data);
            }
            else
            {
                printf("%d\n",h->data);
            }
            h=h->front;
        }
        else h=h->front;//这个必须写，不然就会输出空;
    }
    while(q)
    {
        if(q!=head)
        {
            if(q->next)
            {
                printf("%d ",q->data);
            }
            else
            {
                printf("%d\n",q->data);
            }
            q=q->next;
        }
        else
        {
            q=q->next;
        }
    }
}

 7-7 单链表就地逆置

输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表进行就地逆置（不增加新结点），并输出逆置后的单链表数据。

输入格式:

首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入多个整数，以-1作为该组测试的结束（-1不处理）。

输出格式:

对于每组测试，输出逆置后的单链表数据（数据之间留一个空格）。

输入样例:

1
1 2 3 4 5 -1

输出样例:

5 4 3 2 1

#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
    int data;
    struct Node *next;
}node;
node *creat()
{
    node *head,*p;
    int x;
    head=(node*)malloc(sizeof(node));
    head->next = NULL;
    while(~scanf("%d",&x)&&x!=-1)
    {
        p=(node*)malloc(sizeof(node));
        p->data=x;
        p->next=head->next;
        head->next=p;
    }
    return head;
}
int main()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
      node *head,*p;
      head=creat();
      p=head->next;
      while(p)
      {
          if(p->next==NULL)
          printf("%d\n",p->data);
          else printf("%d ",p->data);
          p=p->next;
      }
    }
    return 0;
}

 7-8 重排链表

给定一个单链表 L1→L2→⋯→Ln−1→Ln，请编写程序将链表重新排列为 Ln→L1→Ln−1→L2→⋯。例如：给定L为1→2→3→4→5→6，则输出应该为6→1→5→2→4→3。

输入格式：

每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址和结点总个数，即正整数N (≤105)。结点的地址是5位非负整数，NULL地址用−1表示。

接下来有N行，每行格式为：

Address Data Next

其中Address是结点地址；Data是该结点保存的数据，为不超过105的正整数；Next是下一结点的地址。题目保证给出的链表上至少有两个结点。

输出格式：

对每个测试用例，顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。

输入样例：

00100 6
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

输出样例：

68237 6 00100
00100 1 99999
99999 5 12309
12309 2 00000
00000 4 33218
33218 3 -1

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
typedef struct Node{
    int data;//存储数据
    int pre;//存储前一个节点的地址
    int next;//存储下一个节点的地址
}node;
int main()
{
    node str[100005];
    int i,n,Address,temp;
    scanf("%d %d",&Address,&n);
    for(i=0;i<n;i++)
    {
        int Address1,data,next;
        scanf("%d %d %d",&Address1,&data,&next);
        str[Address1].data=data;
        str[Address1].next=next;//保存下一个节点的地址
        if(next!=-1)
            str[next].pre=Address1;//储存前一个节点的地址
        if(next==-1)
        {
            temp=Address1;//记录最后一个节点的地址
        }
    }
    for(;;)//无限循环判断，直到temp==Address或Adress==temp结束循环；
    {
        printf("%05d %d ",temp,str[temp].data);//第一次输出n的地址和数据，后续变化输出响应地址和数据；
        if(temp==Address)//如果最后一个节点的地址与起始地址一样，说明没有后续输入了；
        {
            printf("-1\n");
            break;
        }
        else
            printf("%05d\n",Address);//如果不一样，就输出相应地址；
        temp = str[temp].pre;//str[temp].pre记录的是上一个的地址，赋值给temp方便输出；
        printf("%05d %d ",Address, str[Address].data);//第一次输出首地址的地址和相应数据，后续变化看下面
        if(Address == temp)
        {
            printf("-1\n");
            break;
        }
        else
            printf("%05d\n",temp);
        Address = str[Address].next;
    }
    return 0;
}

 7-9 头插法创建单链表、遍历链表、删除链表

输入一系列自然数（0和正整数），输入-1时表示输入结束。按照输入的顺序，用头插法建立单链表，并遍历所建立的单链表，输出这些数据。注意 -1 不加入链表。

输入格式:

第一行是一个正整数k，表示以下会有k组测试数据。

每组测试数据是一系列以空格隔开的自然数（0和正整数）。数列末尾的 -1 表示本组测试数据结束。按照输入的顺序，用头插法建立单链表，并遍历所建立的单链表，输出这些数据。注意 -1 不加入链表。

输出格式:

对于每组测试数据，输出链表中各节点的数据域。每个数据后有一个空格。每组测试数据的输出占1行。

输入样例:

3
1 2 3 4 5 -1 
30 20 10 -1 
4 2 2 1 1 2 0 2 -1

输出样例:

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

5 4 3 2 1 
10 20 30 
2 0 2 1 1 2 2 4

注意：对每组测试数据，创建链表，遍历链表输出之后，一定要删除链表，否则会出现“内存超限”。

#include<stdio.h>
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int a[1001000];
        int i=0;
        int x;
        while(~scanf("%d",&x))
        {
            if(x==-1)
            {
                break;
            }
            else
            {
                a[i]=x;
                i++;
            }
        }
        int j;
    for(j=i-1;j>=0;j--)
    {
          if(j==0) printf("%d \n",a[j]);
          else printf("%d ",a[j]);
     }
    }
    return 0;
}

 管你的内存超限，数组直接治愈