L2-002 链表去重 (25 分)

错误代码,写了一个多小时还是错的,而且只有两分,悲伤逆流成河

#include <iostream>
#include <map>
#include <stdio.h>
#include <math.h>
#include <algorithm>
using namespace std;
map<int,int>mp;
typedef struct List
{
    int ard,data,nard;
    struct List *next;
}List;
List* CreatList(int n)
{
    List *head,*q,*p;
    head=(List*)malloc(sizeof(List));
    head->next=NULL;
    q=head;
    for(int i=0;i<n;i++)
    {
        p=(List*)malloc(sizeof(List));
        scanf("%d %d %d",&p->ard,&p->data,&p->nard);
        p->next=NULL;
        q->next=p;
        q=p;
    }
    return head;
}
List* Delete(List *head,List *head1)
{
    List *q,*p,*k,*t,*s;
    head->data=99999;
    q=head;
    p=head;
    head1->next=NULL;
    t=head1;
    while(q->next!=NULL)
    {
        int a=fabs(q->next->data);
        mp[a]++;
        if(q->next->data==p->data)
        {
            k=q->next;
            p->next=q->next->next;
            mp[a]--;
            s=(List*)malloc(sizeof(List));
            s->ard=k->ard;
                s->data=k->data;
                s->nard=k->nard;
                s->next=NULL;
            t->next=s;
            t=s;
            free(k);
        }
        else
        {
            if(mp[a]>1)
            {
                k=q->next;
                p->next=q->next->next;
                mp[a]--;
                s=(List*)malloc(sizeof(List));
                s->ard=k->ard;
                s->data=k->data;
                s->nard=k->nard;
                s->next=NULL;
                t->next=s;
                t=s;
                free(k);
            }
            else
            {
                q=q->next;
                p=p->next;
            }

        }
    }
    return head;
}
List* Sort(int start,int n,List *head)
{
    List *q,*head1,*p,*t,*k;
    head1=(List*)malloc(sizeof(List));
    head1->next=NULL;
    q=head1;
    t=head;
    for(int i=0;i<n;i++)
    {
        t=head;
        while(t->next!=NULL)
        {
            if(t->next->ard==start)
            {
                p=t->next;
                k=(List*)malloc(sizeof(List));
                start=p->nard;
                k->ard=p->ard;
                k->data=p->data;
                k->nard=start;
                k->next=NULL;
                q->next=k;
                q=k;
                t->next=p->next;
                free(p);
                break;
            }
            t=t->next;
        }
    }
    return head1;

}
void Print(List *head)
{
    head=head->next;
    while(head!=NULL)
    {
        if(head->nard>=0)
        printf("%05d %d %05d\n",head->ard,head->data,head->nard);
        else
        printf("%05d %d -1\n",head->ard,head->data);
        head=head->next;
    }
}
int main()
{
   int start,n;
   cin>>start>>n;
   List *p=CreatList(n);
   List *q=Sort(start,n,p);
   List *t=Delete(q,p);
   Print(t);
   Print(p);
}

原文地址:https://www.cnblogs.com/xyfs99/p/10357679.html

时间: 2024-10-12 04:12:10

L2-002 链表去重 (25 分)的相关文章

L2-2 重排链表 (25 分)

给定一个单链表 L?1??→L?2??→?→L?n−1??→L?n??,请编写程序将链表重新排列为 L?n??→L?1??→L?n−1??→L?2??→?.例如:给定L为1→2→3→4→5→6,则输出应该为6→1→5→2→4→3. 输入格式: 每个输入包含1个测试用例.每个测试用例第1行给出第1个结点的地址和结点总个数,即正整数N (≤).结点的地址是5位非负整数,NULL地址用−表示. 接下来有N行,每行格式为: Address Data Next 其中Address是结点地址:Data是该结

1025 反转链表 (25 分

给定一个常数 K 以及一个单链表 L,请编写程序将 L 中每 K 个结点反转.例如:给定 L 为 1→2→3→4→5→6,K 为 3,则输出应该为 3→2→1→6→5→4:如果 K 为 4,则输出应该为 4→3→2→1→5→6,即最后不到 K 个元素不反转. 输入格式: 每个输入包含 1 个测试用例.每个测试用例第 1 行给出第 1 个结点的地址.结点总个数正整数 N (≤).以及正整数 K (≤),即要求反转的子链结点的个数.结点的地址是 5 位非负整数,NULL 地址用 ? 表示. 接下来有

L2-2 重排链表 (25 分)

给定一个单链表 L?1??→L?2??→?→L?n−1??→L?n??,请编写程序将链表重新排列为 L?n??→L?1??→L?n−1??→L?2??→?.例如:给定L为1→2→3→4→5→6,则输出应该为6→1→5→2→4→3. 输入格式: 每个输入包含1个测试用例.每个测试用例第1行给出第1个结点的地址和结点总个数,即正整数N (≤).结点的地址是5位非负整数,NULL地址用−表示. 接下来有N行,每行格式为: Address Data Next 其中Address是结点地址:Data是该结

天梯 L2 链表去重

L2-002 链表去重 (25 分) 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉.即对每个键值 K,只有第一个绝对值等于 K 的结点被保留.同时,所有被删除的结点须被保存在另一个链表上.例如给定 L 为 21→-15→-15→-7→15,你需要输出去重后的链表 21→-15→-7,还有被删除的链表 -15→15. 输入格式: 输入在第一行给出 L 的第一个结点的地址和一个正整数 N(≤10?5??,为结点总数).一个结点的地址是非负的 5 位整数,空地址 NULL 用 −

PAT 甲级 1052 Linked List Sorting (25 分)(数组模拟链表,没注意到不一定所有节点都在链表里)

1052 Linked List Sorting (25 分) A linked list consists of a series of structures, which are not necessarily adjacent in memory. We assume that each structure contains an integer key and a Next pointer to the next structure. Now given a linked list, y

6-1 单链表逆转 (20分)

题目链接:6-1 单链表逆转 (20分) 方式一:递归逆置单链表 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <math.h> 4 #include <string.h> 5 #include <ctype.h> 6 7 #define maxn 5000 8 #define newline printf("\n") 9 10 11 typedef int Ele

LeetCode OJ:Remove Duplicates from Sorted List II(链表去重II)

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5, return 1->2->5.Given 1->1->1->2->3, return 2->3.

C# 链表去重 List 一维 二维 分别使用 Distinct() GroupBy() 方法

分别使用过List中Distinct(),GroupBy()实现链表的去重. 1.先上效果: 一维链表中分别有元素"aa","bb",'aa','aa',"cc",使用Distinct()方法后输出 aa,bb,cc 二维链表中类型为ClassA类型,其中对象的属性A分别为1,1,2,3,1,使用GroupBy()方法实则是分类,输出Key值分别为1,2,3. 2.上代码,类ClassA 1 class ClassA 2 { 3 private

1133 Splitting A Linked List (25 分)

1133 Splitting A Linked List (25 分) Given a singly linked list, you are supposed to rearrange its elements so that all the negative values appear before all of the non-negatives, and all the values in [0, K] appear before all those greater than K. Th

1021 Deepest Root (25 分)(经典搜索)

1021 Deepest Root (25 分) A graph which is connected and acyclic can be considered a tree. The height of the tree depends on the selected root. Now you are supposed to find the root that results in a highest tree. Such a root is called the deepest roo