精华内容
下载资源
问答
  • 主要介绍了C语言数据结构实现链表去重的实例的相关资料,这里提供了题目及实例代码,需要的朋友可以参考下
  • 两个有序链表去重合并,
  • 7-4 链表去重 (25 分)

    2021-07-28 23:03:30
    7-4 链表去重题目详情一、存储方式:二、去重:1.准备工作2.特判3.输出完整代码 题目详情 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,只有第一个绝对值等于 K 的结点被...


    题目详情

    给定一个带整数键值的链表 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


    一、存储方式:

    题目说了节点地址是五位整数,所以利用结构体数组存储,类似哈希表。

    typedef struct node{
        int val;	//节点的值
        int next;	//下一节点的地址
    }listNode;
    listNode record[100100];	//结构体数组
    

    二、去重:

    1.准备工作

    	vector<int> address;	//存放去重之后元素的地址(索引)
    	vector<int> _address;	//存放重复元素的地址(索引)
    	set<int> se;			//利用set去重
    	int start, n;			//start为链表开始的地址, n为节点个数
        cin >> start >> n;
        for(int i = 0; i < n; ++i) {	//读入数据并存放到reord数组里
            int ad;
            cin >> ad;
            cin >> record[ad].val >> record[ad].next;
        }
        for(int i = start; i != -1;) {	//把地址(索引)按照题目给的链表的顺序记录下来
            address.push_back(i);
            i = record[i].next;
        }
    

    这样address数组中存放的就是题目中链表顺序对应的结构体数组的地址(索引),去重的时候遍历address数组对应结构体数组中的元素就好了。

    2.特判

    这道题是有特殊情况的,既输入的链表只有一个节点,那就直接特殊处理一下。

    	if(n == 1) {
            printf("%05d %d -1\n", address[0], record[address[0]].val);
            return 0;
        }
    

    3.输出

    大致思路:
    1、先把第一项给输出,然后遍历链表,同时用set进行去重
    2、如果有重复就不输出且把重复元素的地址放到_address数组中
    3、不是重复的就直接输出,同时更新set
    4、输出_address

    	printf("%05d %d ", address[0], record[address[0]].val);	//先输出第一项
        se.insert(abs(record[address[0]].val));					//加入set去重
        for(int i = 1; i < address.size(); ++i) {				//遍历链表
            if(se.find(abs(record[address[i]].val)) != se.end()) {	//存在重复的情况
                _address.push_back(address[i]);					//把下标存到_address中
            } else {
                se.insert(abs(record[address[i]].val));		//不重复就加入set,且输出
                printf("%05d\n%05d %d ", address[i], address[i], record[address[i]].val);
            }
        }
        cout << -1 << endl;
    
    	//输出链表中重复的元素,和上面一样的套路
        printf("%05d %d ", _address[0], record[_address[0]].val);	
        for(int i = 1; i < _address.size(); ++i) {
                printf("%05d\n%05d %d ", _address[i], _address[i], record[_address[i]].val);
        }
        cout << -1 << endl;
    

    完整代码

    #include<bits/stdc++.h>
    using namespace std;
    typedef struct node{
        int val;	//节点的值
        int next;	//下一节点的地址
    }listNode;
    listNode record[100100];	//结构体数组
    vector<int> address;	//存放去重之后元素的地址(索引)
    vector<int> _address;	//存放重复元素的地址(索引)
    set<int> se;			//利用set去重
    int main()
    {
    	vector<int> address;	//存放去重之后元素的地址(索引)
    	vector<int> _address;	//存放重复元素的地址(索引)
    	set<int> se;			//利用set去重
    	int start, n;			//start为链表开始的地址, n为节点个数
        cin >> start >> n;
        for(int i = 0; i < n; ++i) {	//读入数据并存放到reord数组里
            int ad;
            cin >> ad;
            cin >> record[ad].val >> record[ad].next;
        }
        for(int i = start; i != -1;) {	//把地址(索引)按照题目给的链表的顺序记录下来
            address.push_back(i);
            i = record[i].next;
        }
        if(n == 1) {
            printf("%05d %d -1\n", address[0], record[address[0]].val);
            return 0;
        }
        printf("%05d %d ", address[0], record[address[0]].val);	//先输出第一项
        se.insert(abs(record[address[0]].val));					//加入set去重
        for(int i = 1; i < address.size(); ++i) {				//遍历链表
            if(se.find(abs(record[address[i]].val)) != se.end()) {	//存在重复的情况
                _address.push_back(address[i]);					//把下标存到_address中
            } else {
                se.insert(abs(record[address[i]].val));		//不重复就加入set,且输出
                printf("%05d\n%05d %d ", address[i], address[i], record[address[i]].val);
            }
        }
        cout << -1 << endl;
    
    	//输出链表中重复的元素,和上面一样的套路
        printf("%05d %d ", _address[0], record[_address[0]].val);	
        for(int i = 1; i < _address.size(); ++i) {
                printf("%05d\n%05d %d ", _address[i], _address[i], record[_address[i]].val);
        }
        cout << -1 << endl;
        return 0;
    }
    
    展开全文
  • (数据结构C语言)链表去重

    千次阅读 2020-12-19 23:56:10
    链表去重前言一、题目要求二、思路三、代码四、反思总结 前言 大二菜鸡面临越来越近的期末考试,瑟瑟发抖。为了应付一下可怕未知的数据结构机试,本人想练习一下编程,于是打开学校OJ,从头开始练习,拿这道链表...

    前言

    大二菜鸡面临越来越近的期末考试,瑟瑟发抖。为了应付一下可怕未知的数据结构机试,本人想练习一下编程,于是打开学校OJ,从头开始练习,拿这道链表去重练手,但也做了好长时间(泪)。虽然困难重重,但最后还是独立将题目实现,有一丢成就感,于是也想写一篇博客来加深体会。这也算我的第一篇博客,毕竟来CSDN白嫖一年了(笑)。


    一、题目要求

    给定一个键值为整数的单链表 L,将键值的绝对值有重复的结点删除:即对任意键值 K,只有键值或其绝对值等于 K 的第一个结点被保留在 L 中。例如,下面单链表 L 包含键值 21、-15、15、7、-15,如下图(a)所示;去重后的链表 L 包含键值 21、-15、7,如下图(b)所示。
    在这里插入图片描述
    输入说明:
    输入的第一行包含两个整数,分别表示链表第一个结点的地址和结点个数 n(1≤n≤100)。结点地址是一个非负的 5 位整数,NULL 指针用-1 表示。
    随后 n 行,每行含 3 个整数,按下列格式给出一个结点的信息:
    Address Key Next
    其中 Address 是结点的地址,Key 是绝对值不超过 10000 的整数,Next 是下一个结点的地址。
    输出说明:
    输出的第一行为去重后链表 L 的长度,换行;接下来按顺序输出 L 的所有结点,每个结点占一行,按照 Address Key Next 的格式输出,间隔 1 个空格。

    测试样例:

    输入样例 1
    00100 5
    99999 7 87654
    23854 -15 00000
    87654 -15 -1
    00000 15 99999
    00100 21 23854
    输出样例 1
    3
    00100 21 23854
    23854 -15 99999
    99999 7 -1

    二、思路

    先用一个数组将输入结点存储,此时结点乱序,在数组中对结点排完序之后,再用链表将输入结点存储,之后比较、删除结点,最后打印结点内容。

    三、代码

    代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    #define MAX 100
    //定义结点结构体
    typedef struct node
    {
        int self_adr;
        int next_adr;
        int key;
        struct node *next = NULL;
    }node;
    //初始化
    node *Init(){
        node *head = (node *)malloc(sizeof(node));
        head->next = NULL;
        return head;
    }
    //寻找当前结点q的直接前驱
    node *Search(node *head, node *q){
        node *p = head->next;
        while(p->next!=q){
            p = p->next;
        }
        return p;
    }
    //求当前链表长度
    int sum_length(node *head){
        node *p = head->next;
        int length, count = 0;
        while(p){
            count++;
            p = p->next;
        }
        length = count;
        return length;
    }
    
    int main(){
        int n, first_adr;
        int i,j,length;
        node NodeList[MAX];
        node temp;
        node *head, *p, *q;
    
        head = Init();
        q = head;
    
        scanf("%d%d",&first_adr,&n);
        
        for (i = 0; i < n;i++){
            scanf("%d%d%d",&NodeList[i].self_adr,&NodeList[i].key,&NodeList[i].next_adr);
        }
        //按照输入前后地址对结点排序
        for (i = 0; i < n;i++){
            for (j = i; j < n;j++){
                if(NodeList[j].self_adr == first_adr){
                    temp = NodeList[i];
                    NodeList[i] = NodeList[j];
                    NodeList[j] = temp;
                    first_adr = NodeList[i].next_adr;
                    break;
                }  
            }
        }
        //用链表将这些结点连接
        for (i = 0; i < n;i++){
            p = (node *)malloc(sizeof(node));
            p = &NodeList[i];
            p->next = NULL;
            q->next = p;
            q = q->next;
        }
    
        q = head;
        p = q->next;
    
        while(p){
            q = p->next;
            
            while (q){
                if (q->key == p->key || q->key == -(p->key)){
                    if(q->next == NULL){//此时为链表最后一个结点
                    node *s = Search(head, q);
                    s->next_adr = -1;
                    s->next = NULL;
                    }
                else{
                    node *s = Search(head, q);
                    s->next_adr = q->next->self_adr;
                    s->next = q->next;
                    }
                }
                q = q->next;
            }
            p = p->next;
        }
        
        q = head;
        length = sum_length(q);
        printf("%d\n",length);//打印结点个数
        //打印结点
        while(q->next){
            p = q->next;
            if(p->next_adr==-1)
                printf("%05d %d %d\n",p->self_adr,p->key,p->next_adr);
            else
                printf("%05d %d %05d\n",p->self_adr,p->key,p->next_adr);
            q = q->next;
        }
    
        return 0;
    }
    

    四、反思

    中间对链表操作的地方在循环那里卡了好久,由于未对判定条件深思熟虑,在操作最后一个结点时导致循环无法跳出,此为代码片段:

    			if(q->next == NULL){//此时为链表最后一个结点
                    node *s = Search(head, q);
                    s->next_adr = -1;
                    s->next = NULL;
                    }
    

    总结

    虽然是个简简单单的编程题,但本人还是费了好大力气,但还是有收获的。另外,这个解法肯定不是最优的写法,但我想用通俗易懂的方式写出来。如果有大佬看到这篇文章,若有时间,请对程序进行指正。
    谢谢浏览!

    展开全文
  • L2-002 链表去重题目描述:C语言解法:1. 数组解法 时间:2021年4月15日 题目来源:团体程序设计天梯赛-练习集 题目描述: 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,...

    时间:2021年4月15日
    题目来源:团体程序设计天梯赛-练习集

    题目描述:

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

    输入格式:

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

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

    地址 键值 下一个结点
    

    其中地址是该结点的地址,键值是绝对值不超过 10​4 的整数,下一个结点是下个结点的地址。

    输出格式:

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

    输入样例:

    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
    

    C语言解法:

    1. 数组解法

    解决问题最好的方法就是不把问题当作问题,所以解决链表最好的方法就是不把链表当作成链表,除非你会用链表。

    定义一个 Abs[] 数组,若绝对值 15 存在,则 Abs[15] = 1,否则为 0;

    节点 00100 的数字保存到 Number[00100] 中,节点 00100 的下一个节点保存到 Next[00100] 中。

    一个一个检查节点,若节点数字对应的 Abs[next] = 1,则将这个节点放入副链表,并将它从主链表中删除;若 Abs[next] = 0,则将之改为 1,并将该节点与上一个节点连接。

    最后将两个链表封上,输出。
    注意,若没有被删除的节点,那么不输出副链表(第三个测试点)。
    注意输出的地址格式。

    #include<stdio.h>
    #include<math.h>
    int main(){
    
    	int Number[100000] = {}, Next[100000] = {}, Abs[100000] = {};
    	int index, n, i, head, node = -1, next, fhead = -1, fnode;
    	
    	scanf("%d%d", &head, &n);
    	for(i=0; i<n; i++){
    		scanf("%d", &index);
    		scanf("%d", &Number[index]);
    		scanf("%d", &Next[index]);
    	}
    	
    	next = head;
    	while(next != -1){
    		if(Abs[abs(Number[next])] == 1){
    			// next 需删除,转移到副链表 
    			if(fhead == -1){
    				fhead = next;
    				fnode = next;
    				next = Next[next];
    				continue;
    			}
    			Next[fnode] = next;
    			fnode = next;
    			// 从主链表中删除 next 节点 
    			Next[node] = Next[next];
    		}else{
    			// 节点保留,记录到 Abs[] 
    			if(node == -1){
    				Abs[abs(Number[next])] = 1;
    				node = next;
    				next = Next[next];
    				continue;
    			}
    			Next[node] = next;
    			Abs[abs(Number[next])] = 1;
    			node = next;
    		}
    		next = Next[next];
    		
    	}
    	Next[fnode] = -1;
    	Next[node] = -1;
    	
    	// 输出主链表 
    	node = head;
    	while(Next[node] != -1){
    		printf("%05d %d %05d\n", node, Number[node], Next[node]);
    		node = Next[node];
    	}
    	printf("%05d %d %d\n", node, Number[node], Next[node]);
    	
    	// 输出副链表 
    	if(fhead == -1){	// 第三个测试点
    		return  0; 
    	}
    	fnode = fhead;
    	while(Next[fnode] != -1){
    		printf("%05d %d %05d\n", fnode, Number[fnode], Next[fnode]);
    		fnode = Next[fnode];
    	}
    	printf("%05d %d %d\n", fnode, Number[fnode], Next[fnode]);
    	
    	return 0;
    } 
    
    展开全文
  • 7-8 链表去重 (25分)

    2021-01-21 21:13:34
    7-8 链表去重 (25分) ** 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,只有第一个绝对值等于 K 的结点被保留。同时,所有被删除的结点须被保存在另一个链表上。例如给定 L ...

    **

    7-8 链表去重 (25分)

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

    输入格式:
    输入在第一行给出 L 的第一个结点的地址和一个正整数 N(≤10
    ​5,为结点总数)。一个结点的地址是非负的 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<iostream>
    #include<stdio.h>
    using namespace std;
    int from[100000], to[100000], flag[100000], defto[100000], deff[100000];
    int main() {
        int a, b, n, i, f, f1, value, def1;
        int def = -1;
        cin >> f >> n;
        for (i = 0; i < n; i++) {
            cin >> a >> value >> b;
            from[a] = value;
            to[a] = b;
        }
        flag[abs(from[f])] = 1;
        f1 = f;
        while (to[f1] != -1) {//访问f下一个节点
            if (!flag[abs(from[to[f1]])]) {
                //下一个绝对值不重复
                flag[abs(from[to[f1]])]=1;
                    f1 = to[f1];//遍历下一个节点
            }
            else {//下一个点重复
                if (def == -1) {
                    def = to[f1];//保存头节点
                    def1 = def;
                    deff[def1] = from[def1];
                    defto[def1] = -1;
                }
                else {
                    defto[def1] = to[f1];
                    def1 = to[f1];
                    deff[def1] = from[def1];
                    defto[def1] = -1;
                }
                if (to[to[f1]] != -1) to[f1]=to[to[f1]];//原链表指向下一个
                else to[f1] = -1;
            }
        }
        while (to[f] != -1) {
            printf("%05d %d %05d\n", f, from[f], to[f]);
            f = to[f];
        }
        printf("%05d %d %d\n", f, from[f], -1);
        if (def != -1) {
            while (defto[def] != -1) {
                printf("%05d %d %05d\n", def, deff[def], defto[def]);
                def = defto[def];
            }
            printf("%05d %d %d\n", def, deff[def], defto[def]);
        }
        
    }
    

    更新代码②

    #include<iostream>
    using namespace std;
    int value[100001], next1[100001], flag[100001];
    int main() {
        int start, n;
        cin >> start >> n;
        while (n--) {
            int a, b, c;
            cin >> a >> b >> c;
            value[a] = b;
            next1[a] = c;
        }
        flag[abs(value[start])] = 1;
        int now = start,dels=-1,dell=-1;
        while (next1[now] != -1) {
            if (!flag[abs(value[next1[now]])]) {
                flag[abs(value[next1[now]])]=1;
                now=next1[now];
            }
            else {
                int now1 = next1[now];
                if (next1[now1] != -1) {
                    next1[now] = next1[now1];
                }
                else {
                    next1[now] = -1;
                }
                    if (dels == -1) {
                    dels = now1;
                    dell = now1;
                    next1[now1] = -1;
                }
                else {
                    next1[dell] = now1;
                    dell = now1;
                    next1[now1] = -1;
                }
            }
        }
        int i=start;
        for ( i = start; next1[i] != -1; i = next1[i]) printf("%05d %d %05d\n", i, value[i], next1[i]);
        printf("%05d %d -1\n", i, value[i]);
        if(dels!=-1){
        for ( i = dels; next1[i] != -1; i = next1[i]) printf("%05d %d %05d\n", i, value[i], next1[i]);
        printf("%05d %d -1\n", i, value[i]);//佛了,忘了判断是否为空,输出条件不太合适
        }
    }
    

    更新代码③
    给我整吐了,调代码一小时,居然是因为没有初始化del_head,输出四个测试点都超时了。

    #include<iostream>
    #include<cstring>
    #include<algorithm>
    
    using namespace std;
    
    const int N = 1000010;
    
    int in_head,del_head = -1;
    int _now[N],now_next[N];
    int del_next[N];
    int st[N];
    
    int main(){
        int n;
        cin>>in_head>>n;
        while(n--){
            int a,b,c;
            cin>>a>>b>>c;
            _now[a] = b;
            now_next[a] = c;
        }
        
        if(in_head == -1){
            return 0;
        }
        
        int temp = in_head, now_temp = -1;
        int deltemp = -1 ;
        do{
            int val = abs(_now[temp]);
            if(!st[val]){
                if(in_head == -1){
                    in_head = now_temp =temp;
                }
                else{
                    now_next[now_temp] = temp; // 如果当前的节点的值没有使用过,那么就让插入到不被删除的链表
                    now_temp = temp;
                }
                //当前的绝对值没有被使用过;
                st[val] = 1;
            }
            else {
                //这个节点是被使用过的
                if(del_head == -1){
                    del_head = deltemp = temp;
                }
                else{
                    del_next[deltemp] = temp;
                    deltemp = temp;
                }
            }
            temp = now_next[temp];
        } while(temp != -1);// ne[temp] 表示temp的下一个元素的地址;
        
            
        now_next[now_temp] = -1;
        del_next[deltemp] = -1;
        
        for(int i = in_head; ~i; i=now_next[i]) 
        {
            if(~now_next[i]) printf("%05d %d %05d\n", i, _now[i], now_next[i]);
            else printf("%05d %d %d\n", i, _now[i], now_next[i]);
        }
    
        if(del_head != -1){
            for(int i = del_head; ~i; i=del_next[i]) {
               if(~del_next[i]) printf("%05d %d %05d\n", i, _now[i], del_next[i]);
               else printf("%05d %d %d\n", i, _now[i], del_next[i]);
            }
        }
        return 0;
    }
    
    展开全文
  • 数据结构>链表去重

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

    2020-03-31 20:11:11
    在一个链表中,存在重复的节点,请删除该链表中重复的节点,重复节点只保留一个,返回链表头指针 例; 链表:1->2->3->3->3->4->4->5 处理后:1->2->3->4->5 """ # 节点类...
  • XDOJ 258 链表去重

    2020-12-14 22:45:08
    例如,下面单链表 L 包含键值 21、 -15、15、7、-15,去重后的链表 L 包含键值 21、-15、7。 输入说明 输入的第一行包含两个整数,分别表示链表第一个结点的地址和结点个n(1≤n≤100)。结 点地址是一个非负的 5 位...
  • L2-002 链表去重 (25 分) 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,只有第一个绝对值等于 K 的结点被保留。同时,所有被删除的结点须被保存在另一个链表上。例如给定 L ...
  • 链表去重(java)

    千次阅读 2020-05-19 18:59:54
    问题描述: 现有一个无序单链表,其中存在重复元素,实现一个算法来删除重复出现的元素,最终使得单链表中所有元素仅出现一次。 思路分析: 我们有两种思路: ... //链表删除重复元素 private static c
  • 7-4 链表去重 (10 分) 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,只有第一个绝对值等于 K 的结点被保留。同时,所有被删除的结点须被保存在另一个链表上。例如给定 L 为 ...
  • 链表去重

    2021-03-07 14:58:10
    36. 链表去重 L2-002 链表去重 (25 分) 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,只有第一个绝对值等于 K 的结点被保留。同时,所有被删除的结点须被保存在另一个链表上...
  • 链表去重(删除重复元素)

    千次阅读 2020-11-03 18:26:23
    未排序链表去重 O(n^2) 思路: 第一重循环从链表的头节点开始,枚举一个保留的节点,这是因为我们保留的是「最开始出现的节点」。 第二重循环是枚举「最开始出现的节点」的下一个结点,到链表的末尾结束,将所有...
  • 例如:另L为21→-15→-15→-7→15,则你必须输出去重后的链表21→-15→-7、以及被删除的链表-15→15。 输入格式: 输入第一行包含链表第一个结点的地址、以及结点个数N(<= 105的正整数)。结点地址是一个非负...
  • 链表去重(PTA)

    2020-12-15 10:57:16
    例如给定 L 为 21→-15→-15→-7→15,你需要输出去重后的链表 21→-15→-7,还有被删除的链表 -15→15。 输入格式: 输入在第一行给出 L 的第一个结点的地址和一个正整数 N(≤10 ​5 ​​ ,为结点总数)。一个...
  • 例如给定 L 为 21→-15→-15→-7→15,你需要输出去重后的链表 21→-15→-7,还有被删除的链表 -15→15。 输入格式: 输入在第一行给出 L 的第一个结点的地址和一个正整数 N(≤10^5​​ ,为结点总数)。一个结点的...
  • 怎么快速的对列表进行去重呢,去重之后原来的顺序会不会改变呢?1.以下的几种情况结果是一样的,去重之后顺序会改变:ids = [1,2,3,3,4,2,3,4,5,6,1]news_ids = []for id in ids:if id not in news_ids:news_ids....
  • 递增有序链表去重

    2021-03-17 17:12:01
    对于这类去重,我们肯定需要进行遍历,而这道题给我们的是递增有序的序列,我们便可以进行一一比较,后一个元素与当前元素相同 时便删除当前元素。 代码如下: struct Link { int data; struct Link *next; }...
  • 给定一个**带整数键值**的链表 L,你需要把其中**绝对值重复**的键值结点删掉。即对每个键值 K,只有第一个...例如给定 L 为 21→-15→-15→-7→15,你需要输出去重后的链表 21→-15→-7,还有被删除的链表 -15→15。
  • 7-3 链表去重 (25分) 给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,只有第一个绝对值等于 K 的结点被保留。同时,所有被删除的结点须被保存在另一个链表上。例如给定 L 为 ...
  • PTA链表去重

    千次阅读 2019-03-29 22:37:10
    例如给定 L 为 21→-15→-15→-7→15,你需要输出去重后的链表 21→-15→-7,还有被删除的链表 -15→15。 输入格式: 输入在第一行给出 L 的第一个结点的地址和一个正整数 N(≤10​5​​,为结点总...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,276
精华内容 6,510
关键字:

链表去重