牛马学习数据结构第七天

最新推荐文章于 2024-09-14 21:53:48 发布

Lu_time

最新推荐文章于 2024-09-14 21:53:48 发布

阅读量370

点赞数 3

文章标签：学习数据结构

本文链接：https://blog.csdn.net/Lu_time/article/details/137126777

版权

文章介绍了如何移除链表中重复的节点，保留首次出现的节点，以及两种方法实现链表反转，包括递归和迭代。还涉及到了图书整理场景下的链表操作和核心肌群训练编号的反转问题。

摘要由CSDN通过智能技术生成

1、移除重复节点

编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。

示例1:

 输入：[1, 2, 3, 3, 2, 1]
 输出：[1, 2, 3]

示例2:

 输入：[1, 1, 1, 1, 2]
 输出：[1, 2]

提示：

链表长度在[0, 20000]范围内。
链表元素在[0, 20000]范围内。

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


struct ListNode* removeDuplicateNodes(struct ListNode* head){
    if(!head){
        return NULL;
    }
    struct ListNode *temp;

    struct ListNode *slow=head;
    while(slow){  
        struct ListNode *fast=slow;
        while(fast->next){
            if(slow->val==fast->next->val){
                temp=fast->next;
                fast->next=fast->next->next;
                free(temp);
            }
            else{
                fast=fast->next;
            }
        }
        slow=slow->next;
    }
    return head;
}

2、图书整理I

书店店员有一张链表形式的书单，每个节点代表一本书，节点中的值表示书的编号。为更方便整理书架，店员需要将书单倒过来排列，就可以从最后一本书开始整理，逐一将书放回到书架上。请倒序返回这个书单链表。

示例 1：

输入：head = [3,6,4,1]

输出：[1,4,6,3]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* reverseBookList(struct ListNode* head, int* returnSize) {
    struct ListNode *temp=head;
    int cnt=0;
    while(temp){
        cnt++;
        temp=temp->next;
    }
    temp=head;
    int *updata=(int*)malloc(sizeof(int)*cnt);
    *returnSize=cnt;
    for(int i=cnt-1;i>=0;--i){
        updata[i]=temp->val;
        temp=temp->next;
    }
    return updata;
}

3、图书整理III（迭代和递归）

附教程LCR 024. 反转链表 - 力扣（LeetCode）

给定一个头节点为 head 的单链表用于记录一系列核心肌群训练编号，请将该系列训练编号倒序记录于链表并返回。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

方法如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
//方法一：迭代
struct ListNode* trainningPlan(struct ListNode* head) {
    if(!head || head->next==NULL){
        return head;
    }
    struct ListNode *curr=head;
    struct ListNode *prev=NULL;
    while(curr){
        struct ListNode *temp;
        temp=curr->next;
        curr->next=prev;
        prev=curr;
        curr=temp;
    }
    return prev;
}


//方法二：递归
struct ListNode* trainningPlan(struct ListNode* head) {
    if(!head || head->next==NULL){
        return head;
    }
    struct ListNode *NewNode=trainningPlan(head->next);//递归中的递过程
    //递归中的归过程
    head->next->next=head;
    head->next=NULL;
    return NewNode;
}

4、反转链表（中心思想递归和迭代）

附教程LCR 024. 反转链表 - 力扣（LeetCode）

给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

方法如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
/*迭代的方法*/

struct ListNode* reverseList(struct ListNode* head){
    if(!head){
        return head;
    }
    struct ListNode *prev=NULL;
    struct ListNode *curr=head;
    while(curr){
        struct ListNode *temp;
        temp=curr->next;
        curr->next=prev;
        prev=curr;
        curr=temp;
    }
    return prev;
}

/*递归的方法*/
struct ListNode* reverseList(struct ListNode* head){
    if(head==NULL || head->next==NULL){
        return head;
    }
    struct ListNode *NewNode=reverseList(head->next);//递过程
       //下面两行是归过程
        head->next->next=head;
        head->next=NULL;
    return NewNode;
}