C数据结构_链表练习题

1.删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

//力扣
/*
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* deleteDuplicates(struct ListNode* head) 
{
    struct ListNode*cur=head;
    while(cur!=NULL&&cur->next!=NULL)
    {
        if(cur->next->val==cur->val)
        {
            cur->next=cur->next->next;
        }
        else
        {
            cur=cur->next;
        }        
    }
    return head;
}

 

 

2.链表的中间结点

给定一个带有头结点 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

 

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

 

提示：

给定链表的结点数介于 1 和 100 之间。

//力扣
/*
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

int Getlen(struct ListNode* head)
{
    int len=0;
    struct ListNode*cur=head;
    while(cur!=NULL)
    {
        cur=cur->next;
        len++;
    }
    return len;
}

struct ListNode* middleNode(struct ListNode* head)
{
    int len=Getlen(head)/2;
    struct ListNode*middle=head;
    while(len!=0)
    {
        middle=middle->next;
        len--;
    }
    return middle;
}

3.反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

//力扣
/*
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode*newhead=NULL;
    struct ListNode*node=NULL;
    while(head!=NULL)
    {
        node=head;
        head=head->next;
        node->next=newhead;
        newhead=node;
    }
    return newhead;
}

4.合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

//力扣
/*
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2)
{
    if(l1==NULL)
    {
        return l2;
    }
    if(l2==NULL)
    {
        return l1;
    }
    struct ListNode*p1=l1;
    struct ListNode*p2=l2;
    struct ListNode*r1=NULL;
    struct ListNode*r2=NULL;
    while(p1!=NULL&&p2!=NULL)
    {
        if(p1->val<=p2->val)
        {
            if(r2==NULL)
            {
                r1=r2=p1;
            }
            else
            {
                r2->next=p1;
                r2=p1;
            }
            p1=p1->next;
        }
        else
        {
            if(r2==NULL)
            {
                r1=r2=p2;
            }
            else
            {
                r2->next=p2;
                r2=p2;
            }
            p2=p2->next;
        }
    }
    if(p1==NULL)
    {
        r2->next=p2;
    }
    else
    {
        r2->next=p1;
    }
    return r1;    
}

5.移除链表元素

删除链表中等于给定值 val 的所有节点。

示例:

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

//力扣
/*
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* removeElements(struct ListNode* head, int val) 
{
    if(head==NULL)
    {
        return NULL;
    }
    struct ListNode*prev=head;
    struct ListNode*cur=head->next;
    while(cur!=NULL)
    {
        if(cur->val!=val)
        {
            prev=cur;
        }
        else
        {
            prev->next=cur->next;
            free(cur);
        }
        cur=prev->next;
    }
    struct ListNode *newHead = head;
	if (head->val == val) {
		newHead = head->next;
		free(head);
	}
	return newHead;
}