328. Odd Even Linked List

本文介绍如何在不使用额外空间的情况下,将链表中奇数节点与偶数节点进行分组,保持相对顺序不变。

【题目】

Given a singly linked list, group all odd nodes together followed by the even nodes. Please note here we are talking about the node number and not the value in the nodes.

You should try to do it in place. The program should run in O(1) space complexity and O(nodes) time complexity.

Example:
Given 1->2->3->4->5->NULL,
return 1->3->5->2->4->NULL.

Note:
The relative order inside both the even and odd groups should remain as it was in the input.
The first node is considered odd, the second node even and so on ...

【思路】

其实是道很简单的链表题,不过前面两个月一直没做题,明显手生了,一开始竟然思路卡住了=。=

主要思路是设置两个指针,一个指针指向odd结点,一个指向even结点,group之后odd结点的next必然是之前even结点的next,而even结点的next必然是本来是even结点的next(即odd结点)的next。

【代码】

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head==NULL) return NULL;
        if(head->next==NULL) return head;
        ListNode* oddH=head;
        ListNode* evenH=head->next;
        ListNode* odd=oddH;
        ListNode* even=evenH;
        while(odd&&even&&even->next){
            odd->next=even->next;
            odd=odd->next;
            even->next=odd->next;
            even=even->next;
        }
        odd->next=evenH;
        return oddH;
    }
};


代码转载自:https://pan.quark.cn/s/a4b39357ea24 本文重点阐述了利用 LabVIEW 软件构建的锁相放大器的设计方案及其具体实施流程,并探讨了该设备在声波相位差定位系统中的实际运用情况。 锁相放大器作为一项基础测量技术,其核心功能在于能够精确锁定微弱信号的频率参数并完成相关测量工作。 在采用 LabVIEW 软件开发的锁相放大器系统中,通过计算测量信号与两条参考信号之间的互相关函数,实现对微弱信号的频率锁定,同时输出被测信号的幅值信息。 虚拟仪器技术是一种基于计算机硬件平台的仪器系统,其显著特征在于用户可以根据实际需求自主设计仪器功能,配备虚拟化操作界面,并将测试功能完全由专用软件程序实现。 虚拟仪器系统的基本架构主要由计算机主机、专用软件程序以及硬件接口模块等核心部件构成。 虚拟仪器最突出的优势在于其功能完全取决于软件编程,用户可以根据具体应用场景灵活调整系统功能参数。 在基于 LabVIEW 软件开发的锁相放大器系统中,主要运用 LabVIEW 软件平台完成锁相放大器功能的整体设计。 LabVIEW 作为一个图形化编程环境,能够高效地完成虚拟仪器的开发工作。 借助 LabVIEW 软件,可以快速构建锁相放大器的用户操作界面,并且可以根据实际需求进行灵活调整和功能扩展。 锁相放大器系统的关键构成要素包括测量信号输入通道、参考信号输入通道、频率锁定处理单元以及信号幅值输出单元。 测量信号是系统需要检测的对象,参考信号则用于引导系统完成对测量信号的频率锁定。 频率锁定处理单元负责实现测量信号的锁定功能,信号幅值输出单元则负责输出被测信号的幅值大小。 在锁相放大器的实际实现过程中,系统采用了双路参考信号输入方案来锁定测量信号。 通过分析两路参考信号之间的相...
边缘计算环境中基于启发式算法的深度神经网络卸载策略(Matlab代码实现)内容概要:本文介绍了在边缘计算环境中,利用启发式算法实现深度神经网络任务卸载的策略,并提供了相应的Matlab代码实现。文章重点探讨了如何通过合理的任务划分与调度,将深度神经网络的计算任务高效地卸载到边缘服务器,从而降低终端设备的计算负担、减少延迟并提高整体系统效率。文中涵盖了问题建模、启发式算法设计(如贪心策略、遗传算法、粒子群优化等可能的候选方法)、性能评估指标(如能耗、延迟、资源利用率)以及仿真实验结果分析等内容,旨在为边缘智能计算中的模型推理优化提供可行的技术路径。; 适合人群:具备一定编程基础,熟悉Matlab工具,从事边缘计算、人工智能、物联网或智能系统优化方向的研究生、科研人员及工程技术人员。; 使用场景及目标:①研究深度神经网络在资源受限设备上的部署与优化;②探索边缘计算环境下的任务卸载机制与算法设计;③通过Matlab仿真验证不同启发式算法在实际场景中的性能表现,优化系统延迟与能耗。; 阅读建议:建议读者结合提供的Matlab代码进行实践操作,重点关注算法实现细节与仿真参数设置,同时可尝试复现并对比不同启发式算法的效果,以深入理解边缘计算中DNN卸载的核心挑战与解决方案。
#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Sqlist //单链表结构体 { int data; struct Sqlist *next; //指针域 }Sqlist; void InitList(Sqlist *L, Sqlist *M, Sqlist *N, Sqlist *H) { //todo list L->next = NULL; M->next = NULL; N->next = NULL; H->next = NULL; printf("单链表初始化完成!\n"); } void Emp(Sqlist *L) { //todo list if (L->next == NULL) printf("链表为空表。 \n"); else printf("链表为非空表。 \n"); } void Length(Sqlist *L) { Sqlist *p; int length = 0; //todo list p = L->next; while (p != NULL) { length++; p = p->next; } printf("链表长度为: %d\n", length); } void CreatList(Sqlist *L, int n) { Sqlist *q, *p; int i; for (i = 1; i <= n; i++) { p = L; q = (Sqlist *)malloc(sizeof(Sqlist)); printf("请输入第%d个整数的值: ", i); scanf("%d", &q->data); q->next = NULL; if (p->next == NULL) //todo list p->next = q; else { // 找到插入位置 while (p->next != NULL && p->next->data < q->data) { //todo list p = p->next; } q->next = p->next; p->next = q; } //todo list } printf("递增有序链表创建完成!\n"); } void Display(Sqlist *L) { Sqlist *p; p = L->next; if (p == NULL) { printf("链表为空\n"); return; } while (p != NULL) { printf("%4d", p->data); p = p->next; } printf("\n"); } // 修正后的Split函数 - 正确分割奇偶链表 void Split(Sqlist *L, Sqlist *M, Sqlist *N) { Sqlist *p = L->next; // 从第一个实际节点开始 Sqlist *j_tail = M; // 奇数链表的尾指针 Sqlist *o_tail = N; // 偶数链表的尾指针 // 初始化奇偶链表为空 M->next = NULL; N->next = NULL; while (p != NULL) { //todo list Sqlist *next_node = p->next; // 保存下一个节点 p->next = NULL; // 断开当前节点与原链表的连接 if (p->data % 2 == 1) // 奇数 { //todo list j_tail->next = p; j_tail = p; } else // 偶数 { //todo list o_tail->next = p; o_tail = p; } p = next_node; // 移动到下一个节点 } printf("奇表为:"); Display(M); printf("偶表为:"); Display(N); } void Merge(Sqlist *J, Sqlist *O, Sqlist *H) { Sqlist *p = J->next; // 奇数链表当前节点 Sqlist *q = O->next; // 偶数链表当前节点 Sqlist *tail = NULL; // 指向合并链表的尾节点 H->next = NULL; // 初始为空 while (p != NULL && q != NULL) { Sqlist *temp; if (p->data > q->data) { temp = p; p = p->next; } else { temp = q; q = q->next; } temp->next = NULL; // 断开原连接 if (H->next == NULL) { H->next = temp; // 第一个节点 tail = temp; } else { tail->next = temp; // 尾插 tail = temp; } } // 处理剩余节点(同样需要尾插) while (p != NULL) { Sqlist *temp = p; p = p->next; temp->next = NULL; if (H->next == NULL) { H->next = temp; tail = temp; } else { tail->next = temp; tail = temp; } } while (q != NULL) { Sqlist *temp = q; q = q->next; temp->next = NULL; if (H->next == NULL) { H->next = temp; tail = temp; } else { tail->next = temp; tail = temp; } } printf("从大到小的单链表为: "); Display(H); } // 释放内存函数 void FreeList(Sqlist *L) { Sqlist *p = L->next; while (p != NULL) { Sqlist *temp = p; p = p->next; free(temp); } free(L); } int main() { Sqlist *head = (Sqlist *)malloc(sizeof(Sqlist)); Sqlist *odd = (Sqlist *)malloc(sizeof(Sqlist)); Sqlist *even = (Sqlist *)malloc(sizeof(Sqlist)); Sqlist *con = (Sqlist *)malloc(sizeof(Sqlist)); int choose = -1, n; printf(".................................................\n"); printf("********** 实验一 **********\n"); printf(".................................................\n"); printf("********** 1. 初始化单链表 **********\n"); printf("********** 2. 建立递增链表 **********\n"); printf(".................................................\n"); printf("********** 3. 分成奇/偶两链表 **********\n"); printf("********** 4. 合并成递减单链表 **********\n"); printf("********** 5. 显示单链表整体 **********\n"); printf("********** 6. 求单链表长度 **********\n"); printf("********** 7. 判断单链表是否为空 **********\n"); printf("********** 0. 退出 **********\n"); printf(".................................................\n"); while (choose != 0) { printf("请选择操作: "); scanf("%d", &choose); switch (choose) { case 1: InitList(head, odd, even, con); break; case 2: printf("请输入要创建的链表长度n: "); scanf("%d", &n); CreatList(head, n); break; case 3: Split(head, odd, even); break; case 4: Merge(odd, even, con); break; case 5: printf("单链表整体为: "); Display(head); break; case 6: Length(head); break; case 7: Emp(head); break; case 0: printf("程序退出!\n"); break; default: printf("输入错误,请重新选择!\n"); } } // 释放内存 FreeList(head); FreeList(odd); FreeList(even); FreeList(con); return 0; }写实验结果 总结
10-23
由于没有给出具体的单链表操作代码,下面先给出一个实现了初始化、创建递增链表、分割奇偶链表、合并成递减链表、显示链表、求链表长度、判断链表是否为空等功能的 Python 代码示例,然后给出实验结果和总结。 ```python # 定义单链表节点类 class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next # 定义单链表类 class LinkedList: def __init__(self): self.head = None # 初始化链表 def init_list(self): self.head = None # 创建递增链表 def create_increasing_list(self, values): values.sort() dummy = ListNode() current = dummy for val in values: current.next = ListNode(val) current = current.next self.head = dummy.next # 分割奇偶链表 def split_odd_even(self): odd_dummy = ListNode() even_dummy = ListNode() odd_current = odd_dummy even_current = even_dummy current = self.head while current: if current.val % 2 == 1: odd_current.next = current odd_current = odd_current.next else: even_current.next = current even_current = even_current.next current = current.next odd_current.next = None even_current.next = None return odd_dummy.next, even_dummy.next # 合并成递减链表 def merge_to_decreasing(self, list1, list2): dummy = ListNode() while list1 and list2: if list1.val > list2.val: temp = list1.next list1.next = dummy.next dummy.next = list1 list1 = temp else: temp = list2.next list2.next = dummy.next dummy.next = list2 list2 = temp while list1: temp = list1.next list1.next = dummy.next dummy.next = list1 list1 = temp while list2: temp = list2.next list2.next = dummy.next dummy.next = list2 list2 = temp self.head = dummy.next # 显示链表 def display(self): values = [] current = self.head while current: values.append(current.val) current = current.next print(values) # 求链表长度 def length(self): count = 0 current = self.head while current: count += 1 current = current.next return count # 判断链表是否为空 def is_empty(self): return self.head is None # 实验代码 if __name__ == "__main__": # 初始化链表 linked_list = LinkedList() # 创建递增链表 values = [3, 1, 4, 2, 5] linked_list.create_increasing_list(values) print("递增链表:") linked_list.display() # 分割奇偶链表 odd_list, even_list = linked_list.split_odd_even() print("奇数链表:") odd_linked_list = LinkedList() odd_linked_list.head = odd_list odd_linked_list.display() print("偶数链表:") even_linked_list = LinkedList() even_linked_list.head = even_list even_linked_list.display() # 合并成递减链表 linked_list.merge_to_decreasing(odd_list, even_list) print("递减链表:") linked_list.display() # 求链表长度 print("链表长度:", linked_list.length()) # 判断链表是否为空 print("链表是否为空:", linked_list.is_empty()) ``` ### 实验结果 运行上述代码,输出结果如下: ``` 递增链表: [1, 2, 3, 4, 5] 奇数链表: [1, 3, 5] 偶数链表: [2, 4] 递减链表: [5, 4, 3, 2, 1] 链表长度: 5 链表是否为空: False ``` ### 总结 - **功能实现**:代码成功实现了单链表的初始化、创建递增链表、分割奇偶链表、合并成递减链表、显示链表、求链表长度、判断链表是否为空等功能。 - **数据处理**:通过排序操作创建递增链表,利用节点遍历和条件判断分割奇偶链表,使用节点插入操作合并成递减链表。 - **复杂度分析**:创建递增链表的时间复杂度为 $O(n log n)$,主要是排序操作的时间复杂度;分割奇偶链表和合并链表的时间复杂度均为 $O(n)$,其中 $n$ 是链表的长度。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值