华为机试复习--链表

目录

• NC78 反转链表
• NC33 合并有序链表
• NC40 两个链表生成相加链表
• NC66 两个链表的第一个公共节点
• NC96 判断一个链表是否为回文结构
• NC链表的奇偶重排

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}
返回值
{1,2}

/**
 * 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;
    }
};