单链表查找最大值、两个递增的链表合并并且去重

单链表查找最大值

代码:

 1 #include<iostream>
 2 #include<bits/stdc++.h>
 3 using namespace std;
 4 struct Node{
 5     int value;
 6     Node * next;
 7 };
 8 Node *a=new Node; //创建头指针
 9 void build_link(Node * a,int n){ //建表
10     Node *p;
11     p=a;
12     for(int i=0;i<n;i++){
13         Node *q=(Node *)malloc(sizeof(Node)); //给下一节点开辟空间
14         cin>>q->value; //按顺序输入每个节点的值value
15         q->next=NULL;
16         p->next=q;
17         p=q;
18     }
19 }
20 Node * Find(Node *a){ //查找最大值的节点
21     Node *pmax;
22     pmax=a->next;
23     while(a->next!=NULL){
24         if(pmax->value<(a->next->value)){
25             pmax=a->next; //pmax指向最大值节点
26         }
27         a=a->next;
28     }
29     return pmax; //返回最大值节点的地址
30 }
31 int main(){
32     int n;
33     cin>>n; //输入链表的长度n
34     a->next=NULL;
35     build_link(a,n);
36     Node *pmax=Find(a);
37     cout<<pmax->value<<endl; //输出最大值
38     return 0;
39 }

两个递增链表的合并,并且去重

实现代码:

 1 #include<iostream>
 2 #include<bits/stdc++.h>
 3 using namespace std;
 4 struct Node{
 5     int value;
 6     Node *next;
 7 };
 8 void build_link(Node * a,int n){
 9     Node *p=a;
10     for(int i=0;i<n;i++){
11         Node *q=new Node;
12         cin>>q->value;
13         q->next=NULL;
14         p->next=q;
15         p=q;
16     }
17 }
18 void combine(Node *a,Node *b){
19     Node *p;
20     p=a; //p所指向的节点必须是比较的两个节点之前的节点!因为这个地方我找了好久的bug,如果不是这样会造成部分样例死循环!
21     a=a->next;
22     b=b->next;
23     while(a!=NULL&&b!=NULL){
24         if(a->value == b->value){
25             //cout<<‘b‘<<a->value<<‘ ‘<<b->value<<endl;
26             p->next=a;
27             p=a;
28             b=b->next;
29             a=a->next;
30         }else if(a->value < b->value){
31             //cout<<‘a‘<<a->value<<‘ ‘<<b->value<<endl;
32             p->next=a;
33             p=a;
34             a=a->next;
35         }else{
36             //cout<<‘c‘<<a->value<<‘ ‘<<b->value<<endl;
37             p->next=b;
38             p=b;
39             b=b->next;
40         }
41    }
42     if(a==NULL){
43         p->next=b;
44     }else{
45         p->next=a;
46     }
47 }
48 int main(){
49     Node *a=(Node*)malloc(sizeof(Node));
50     Node *b=(Node*)malloc(sizeof(Node));
51     a->next=NULL;
52     b->next=NULL;
53     int n1,n2;
54     cin>>n1;
55     build_link(a,n1);
56     cin>>n2;
57     build_link(b,n2);
58     combine(a,b);
59     while(a->next!=NULL){
60         cout<<a->next->value<<‘ ‘;
61         a=a->next;
62     }
63     return 0;
64 }

如有错误,麻烦指出。Thanks?(?ω?)?

原文地址:https://www.cnblogs.com/ISGuXing/p/8778408.html

时间: 2024-10-03 07:02:43

单链表查找最大值、两个递增的链表合并并且去重的相关文章

面试题 17:合并两个排序的链表

题目:输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按 照递增排序的. 两个指针指向两个链表的头结点,取其中值小的作为新链表的头结点,和之前的结点串联,如此递归. 注意用例: 两个链表都为null: 其中一个链表为null: 两个链表有多个结点,有相同的值,不同的值. package offer; /*面试题 17:合并两个排序的链表 题目:输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按 照递增排序的.*/ public class Problem17 { st

剑指Offer面试题17(Java版):合并两个排序的链表

题目:输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的.例如输入图中的链表1和链表2,则合并之后的升序链表3所示. 这是一个经常被各公司采用的面试题.在面试过程中,我们发现应聘者最容易犯两个错误:一是在写代码之前没有对合并的过程想清楚,最终合并出来的链表要么中间断开要么并没有递增排序:二是代码的鲁棒性方面存在问题,程序一旦有特殊的输入(如空链表)就会崩溃.接下来分析如何解决这个问题. 首先分析合并两个链表的过程.我们的分析从合并两个链表的头结点开始.链表1的头结点的值

剑指offer之面试题17合并两个排序的链表

问题描述: 输入两个递增的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的. 实现代码如下: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> struct List{ int date; struct List *next; }; struct List* doMergeList(struct List *P1head,struct List *P2head){ if(P1head==NU

链表习题(7)-将两个递增单链表合并成一个递减单链表

1 /*将两个递增单链表合并成一个递减单链表*/ 2 /* 3 算法思想:两个链表已经按元素值递增次序排序,将其合并时,均从第一个结点起进行比较,将较小的 4 结点链入链表中,同时后移工作指针.由于结果链表是递减的,故使用头插法建立新链表.比较结束后, 5 可能会有一个链表非空,此时用头插法将剩下的结点依次插入新链表中即可. 6 */ 7 void Union_List(LinkList& La,LinkList& Lb) 8 { 9 LNode *r, *pa = La->next

将单链表排序的两种方法

对单链表排序,通常有两种方法.(PS:考察一个程序员的C语言编程功底,通常看他是否能娴熟的操作链表就知道了.) 方法1:将每一个结点保存到额外的数组中,对数组进行排序,然后根据有序的数组重新构建链表. 方法2:直接对链表进行插入排序,但是实现起来比较复杂一些. 显然,方法1最为简单,因为将链式存储L先转化为顺序存储a[],对顺序存储a[]排序,就避免了较为复杂的链接指针操作.一旦对顺序存储a[]排好序后,根据a[]重新构建一个链表是易如反掌的事情. 1. 单链表的定义如下 typedef str

27、输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. 思路:同归并算法 本题: 1 public class Solution { 2 public ListNode Merge(ListNode list1, ListNode list2) { 3 ListNode head; 4 if (list1 == null) { 5 return list2; 6 } 7 if (list2 == null) { 8 return list1; 9 } 10

剑指offer面试题17——合并两个排序的链表

题目1519:合并两个排序的链表 题目描述: 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则.(hint: 请务必使用链表.) 输入: 输入可能包含多个测试样例,输入以EOF结束.对于每个测试案例,输入的第一行为两个整数n和m(0<=n<=1000, 0<=m<=1000):n代表将要输入的第一个链表的元素的个数,m代表将要输入的第二个链表的元素的个数.下面一行包括n个数t(1<=t<=1000000):代表链表一中的元素.接

【剑指Offer】【链表】合并两个排序的链表

题目:输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. A:若链表1为空,则合并后的链表头结点为pHead2:若链表2为空,则合并后的链表头结点为pHead1   创建ret_Head作为合并链表的新头结点,比较pHead1和pHead2,ret_Head指向小的数,ret_Head->next指向两个链表中下一个最小的数 ====> 递归 A:同样的,递归也是一种栈结构,所以也可以用栈来解决这个问题 /* struct ListNode { int

【面试题17】合并两个排序的链表

[题目描述] 输入两个递增排序的链表,合并这两个链表并使新链表中的结点是按照递增排序的. [解决方案] 用递归解决,非常简单. 我的代码实现,仅供参考: 1 public static ListNode Merge(ListNode listA, ListNode listB) 2 { 3 if (listA == null) 4 { 5 return listB; 6 } 7 else if(listB == null) 8 { 9 return listA; 10 } 11 12 ListN