华为机试复习--链表
NC78 反转链表
题目
输入一个链表，反转链表后，输出新链表的表头。
示例1
输入{1,2,3}
返回值{3,2,1}
class Solution {
public:
ListNode* ReverseList(ListNode* pHead) {
ListNode* cur=pHead;
ListNode* pre=NULL;
ListNode* nex=NULL;
while(cur!=NULL)
{
nex=cur->next;
cur->next=pre;
pre=cur;
cur=nex;
}
return pre;
}
};
NC33 合并有序链表
题目描述
将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的，且合并后新链表依然有序。
示例1
输入
{1},{2}
返回值
{1,2}
示例2
输入
{2},{1}
返回值
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param l1 ListNode类
* @param l2 ListNode类
* @return ListNode类
*/
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
// write code here
ListNode* head=NULL;
if(l1==NULL)
return l2;
if(l2==NULL)
return l1;
if(l1->val<=l2->val){
head=l1;
head->next=mergeTwoLists(l1->next, l2);
}
else{
head=l2;
head->next=mergeTwoLists(l1, l2->next);
}
return head;
}
};
NC40 两个链表生成相加链表
题目描述
假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。
给定两个这种链表，请生成代表两个整数相加值的结果链表。
例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。
示例1
输入
[9,3,7],[6,3]
返回值
{1,0,0,0}
备注:
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param head1 ListNode类
* @param head2 ListNode类
* @return ListNode类
*/
//反转链表并计算长度
ListNode* ReverseList(ListNode* pHead,int &length) {
ListNode* cur=pHead;
ListNode* pre=NULL;
ListNode* nex=NULL;
while(cur!=NULL)
{
nex=cur->next;
cur->next=pre;
pre=cur;
cur=nex;
length++;
}
return pre;
}
ListNode* addInList(ListNode* head1, ListNode* head2) {
// write code here
int len1=0;
int len2=0;
ListNode* re1=ReverseList(head1,len1);
ListNode* re2=ReverseList(head2,len2);
if(len1<len2){
ListNode* tmp=re1;
re1=re2;
re2=tmp;
}
ListNode* a=re1;
while(re1!=NULL){
if(re2==NULL)
break;
int tmp=re1->val+re2->val;
if(tmp<10)//不存在进位
re1->val=tmp;
else{//存在进位
if(re1->next==NULL){//进位位原本不存在
re1->next=new ListNode(1);
re1->next->next=NULL;
}
else{//进位位存在
if(re1->next->val<9){//进位位小于9则只需要进位1次
re1->next->val+=1;
}
else{//进位位为9则需要连续进位
re1->next->val=0;
if(re1->next->next==NULL)
re1->next->next=new ListNode(1);
else
re1->next->next->val+=1;
}
}
re1->val=(tmp-10);
}
re1=re1->next;
re2=re2->next;
}
return ReverseList(a,len1);
}
};
NC66 两个链表的第一个公共节点
题目描述
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
ListNode* p1=pHead1;
ListNode* p2=pHead2;
while(p1!=p2){
p1=(p1==NULL?pHead2:p1->next);
p2=(p2==NULL?pHead1:p2->next);
}
return p1;
}
};
NC96 判断一个链表是否为回文结构
题目描述
给定一个链表，请判断该链表是否为回文结构。
示例1
输入
[1,2,2,1]
返回值
true
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param head ListNode类 the head
* @return bool布尔型
*/
ListNode* ReverseList(ListNode* pHead) {
ListNode* cur=pHead;
ListNode* pre=NULL;
ListNode* nex=NULL;
while(cur!=NULL)
{
nex=cur->next;
cur->next=pre;
pre=cur;
cur=nex;
}
return pre;
}
bool isPail(ListNode* head) {
ListNode* fast = head, *slow = head;
//通过快慢指针找到中点
while (fast != NULL && fast->next != NULL) {
fast = fast->next->next;
slow = slow->next;
}
//如果fast不为空，说明链表的长度是奇数个
if (fast != NULL) {
slow = slow->next;
}
//反转后半部分链表
slow = ReverseList(slow);
fast = head;
while (slow != NULL) {
//然后比较，判断节点值是否相等
if (fast->val != slow->val)
return false;
fast = fast->next;
slow = slow->next;
}
return true;
}
};
NC链表的奇偶重排
题目描述
给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。
注意是节点的编号而非节点的数值。
示例1
输入
复制
{1,2,3,4,5,6}
返回值
复制
{1,3,5,2,4,6}
说明
1->2->3->4->5->6->NULL
重排后为
1->3->5->2->4->6->NULL
示例2
输入
复制
{1,4,6,3,7}
返回值
复制
{1,6,7,4,3}
说明
1->4->6->3->7->NULL
重排后为
1->6->7->4->3->NULL
奇数节点有1,6,7，偶数节点有4,3。重排后为1,6,7,4,3
备注:
链表长度不大于200000。每个数范围均在int内。
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) : val(x), next(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param head ListNode类
* @return ListNode类
*/
ListNode* oddEvenList(ListNode* head) {
// write code here
if(head == NULL || head->next == NULL)
return head;
ListNode* evenHead = head->next;
ListNode* odd = head,*even = head->next;
while(even != NULL && even->next != NULL){
odd->next = even->next;
odd = odd->next;
even->next = odd->next;
even = even->next;
}
odd->next = evenHead;
return head;
}
};
