yang20141109的专栏

题目：求链表的中间结点。如果链表中结点总数为奇数，返回中间结点；如果结点总数是偶数，返回中间两个结点的任意一个。 解析：我们可以定义两个指针，同时从链表的头结点出发，第一指针一次走一步，第二个指针一次走两步，当第二个指针走到链表的末尾时，第一指针正好在链表的中间。以下代码是：如果结点的总数为偶数，我们返回中间结点的后一个结点。//找到链表中间结点ListNode * findMidVa

给定k个链表，把这k个链表合并为一个有序的链表。 方法一：(1)每次都需要合并两个有序的链表。(2)把上一次合并后的链表与当前要合并的链表再次合并，直到剩下一个链表为止。此方法时间复杂度太高。//合并两个有序链表ListNode *mergeTwoLists(ListNode *l1,ListNode *l2){ ListNode *head = new ListNode(0);

给定一个单链表和一个k值，把链表向右旋转k步，比如说1->2->3->4->5->NULL和k = 2，则返回4->5->1->2->3->NULL。 解析：(1)把链表分割成两部分，前半部的长度为len-k，后半部分的长度为k，其中len为链表测长度。(2)把后一部分链表的尾指针指向前一部分链表的头指针。返回后一部分的首指针即可。ListNode* rotateRight(ListNode

给定一个有序的单链表，把链表中重复的元素删除。比如1->1->2->3->3，则返回1->2->3。 代码如下：ListNode* deleteDuplicates(ListNode* head) { if(head == NULL || head->next == NULL) return head; ListNode *pre = head; ListNode *cur =

给定一个有序单链表，删除链表中重复元素，比如：1->2->3->3->4->4->5，则返回1->2->5。 解析：设置三个指针，pre、cur和next，当cur->val和next->val不相等时，更新pre = cur、cur = next和next = next->next；当cur->val和next->val相等时，向前移动next指针，直到cur->val和next->v

给定单链表和一个k值，把小于k值节点排在大于等于k值节点之前。比如说1->4->3->2->5->2和 x = 3，则返回1->2->2->4->3->5。ListNode* partition(ListNode* head, int x) { if(head == NULL || head->next == NULL) return head; ListNode *pHeadA = n

给定一个单链表和两个位置m与n，把链表中从m到n位置的元素反转。比如说1->2->3->4->5->NULL，m = 2和n = 4，返回1->4->3->2->5->NULL。ListNode* reverseBetween(ListNode* head, int m, int n) { if (head == NULL || m == n) return head; ListNode

给定一个单链表：L0->L1->...->Ln-1->Ln，重新排序以后返回L0->Ln->L1->Ln-1->L2->Ln-2...。 解析：(1)把单链表分割为前后两部分。(2)把后一部分链表反转。(3)把两部分链表交叉插入即可。ListNode * reverseList(ListNode *head){ if (head == NULL || head->next == NU

给定一个单链表，对该链表进行插入排序。ListNode* insertionSortList(ListNode* head) { if (head == NULL || head->next == NULL) return head; ListNode *pHead = new ListNode(INT_MAX); pHead->next = head; ListNode *tail

给定两个链表，如果这两个链表相交，则返回第一个相交的顶点，如果不相交，则返回空。比如A:          a1 → a2                   ↘                     c1 → c2 → c3                   ↗            B:     b1 → b2 → b3则返回c1节点。 方法一：(1)求出

给定一个单链表和一个val，删除链表中所有值为val的节点，比如：1 --> 2 --> 6 --> 3 --> 4 --> 5 --> 6，val = 6，则返回1 --> 2 --> 3 --> 4 --> 5。ListNode* removeElements(ListNode* head, int val) { if(head == NULL) return head; ListN

递归反转单链表。ListNode *reverseList(ListNode *head,ListNode *pNewHead){ if(head == NULL) return pNewHead; ListNode *next = head->next; head->next = pNewHead; return reverseList(next,head);}ListNode

给定一个单链表，判断该链表是否为回文序列。要求时间复杂度为o(n)，空间复杂度为o(1)。 解析：(1)把链表分割成前后两部分。(2)反转前半部分链表。(3)判断前后两部分链表是否相等。bool isPalindrome(ListNode* head) { if (head == NULL || head->next == NULL) return true; ListNode

给定两个有序链表，把这两个链表合并为一个有序链表。比如链表1->3->5->NULL和链表2->4->6->NULL。合并以后为1->2->3->4->5->6->NULL。方法一：循环迭代方法ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode *head = new ListNode(0); ListNode *

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

题目：输入一个链表，输出该链表中倒数第k个结点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾结点是倒数第一个结点。例如一个链表有6个结点，从头结点开始他们的值依次是1、2、3、4、5、6。这个链表的倒数第3个结点是值为4的结点。 解析：为了实现只遍历链表一次就能找到倒数第k个结点，我们可以定义两个指针，第一个指针从链表的头指针开始遍历向前走k-1，第二个指针保持不动，从第k步开始

题目：给定单向链表的头指针和一个结点指针，定义一个函数在o(1)时间删除该结点。 解析：我们要删除结点i，先把i的下一个结点j的内容复制到i，然后把i的指针指向结点j的下一个结点。此时再删除结点j，效果刚好是把结点i给删除了。如果要删除的结点位于链表的尾部，那么他就没有下一个结点，我们仍然需要从链表的头结点开始，顺序遍历得到该结点的前序结点，并完成删除操作。如果删除的结点位于头结点，我们

链表是一种动态数据结构，是因为在创建链表时，无须知道链表的长度，当插入一个节点时，我们只需要为新节点分配内存，然后调整指针的指向来确保新节点被插入到链表中。内存分配不是在创建链表时一次性完成，而是每添加一个节点分配一次内存，由于没有闲置的内存，链表的空间效率比数组高，我们要向链表的末尾插入一个元素，函数原型为void appendNode(ListNode **pHead,int val)，我们要

在不改变链表结构的前提下，使用一个后进先出的数据结构（栈）存储正向遍历链表的结果，根据后进先出的特点：最后一个进入的数据最先被弹出，可以逆向打印出链表。我们也可以根据递归来逆向输出链表。#include#includeusing namespace std;//链表的节点类型struct Node{ int data; Node *next;};//在链表末尾插入一个元素v

给定一个单链表，只给出头结点指针pHead： (1)如何判断链表中是否存在环。 (2)如何知道环的长度。 (3)如何找出环的连接点。 (4)带环链表的长度。 问题一，我们设置两个指针slow和fast，slow指针每次只走一步，fast指针每次走两步，如果fast指针可以追赶上slow指针，也就是说fast指针和slow指针相等。那么我们就说链表中

题目：定义一个函数，输入一个链表的头结点，反转该链表。 方法一：如果链表只有一个结点或者链表为空，我们直接返回，如果链表的长度大于等于2，我们从第二个结点开始采用头插法插入到链表中。void reverseList(ListNode *&pHead){ if(pHead == NULL)//判断链表是否为空 return; ListNode *p = pHead->next;

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。 解析：在链表头部加入一个新的头结点。设置三个指针：pPre初始化为新的头结点的指针。pCur指向原来链表的头结点。pNext指向pCur的下一个结点。每次比较当前节点和下一个结点的值。如果相等则删除pNext指向的

//除去链表中重复元素比如：1,2,3,3,4,4,5。删除以后为1,2,3,4,5。void deleteNode(ListNode *pHead){ if (pHead == NULL && pHead->next == NULL) return; ListNode *pre = pHead; ListNode *pNext = pHead->next; while (pNex

给出两个单向链表的头指针，比如pHead1和pHead2，判断这两个链表是否相交，如果相交求出第一个相交的结点。 方法一：由于两个链表没有环，我们可以把第二个链表的尾指针指向第一个链表的头结点，此时我们从链表二出发，判断这个新的链表是否存在环，如果存在环则说明这两个链表相交，否则，这两个链表不相交。环的连接点即两个链表的第一个交点。在上一篇博客中我们已经说过如何判断一个链表是否存在环，而

给定一个单链表，使得链表中奇数位于偶数之前。 解析：快排的思想，设置两个指针，p1指向最后一个奇数位置，p2指向当前位置，每当p2移动一位时，判断p2指向的元素是否为奇数，如果是奇数，则p2位置的元素和p1下一位置的元素交换，p1更新为p1->next。如果是偶数，则p2直接下移一位。时间复杂度为o(n)。ListNode* oddEvenList01(ListNode* head)

给定一个单链表，使得奇数位置的元素位于偶数位置元素之前。比如说：1->2->4->5->6->NULL，调整以后1->4->6->2->5->NULL。 解析：这道题和上面一道题的区别是：不是把链表中奇数元素位于偶数元素之前，而是奇数位置的元素位于偶数位置元素之前。设置三个指针，指针odd指向奇数位置的元素，指针even指向偶数位置的元素，指针evenHead指向第一个偶数位置的元素，按

对单链表进行归并排序：首先设置两个指针slow和fast，slow指针每次走一步，fast指针每次走两步，当fast指向末尾元素或者指向空时，slow指针刚好走到链表的中间位置，此时slow指针恰好把链表分为左右两部分，slow->next指针指向第二部分的首部，然后我们递归的对两部分进行划分操作，最后划分到两部分都只有一个元素时，我们对其进行合并操作，然后依次递归的向上进行归并操作。时间复杂度为

单链表进行快速排序：选择尾元素作为枢轴，根据枢轴值把链表划分为两部分，前半部分值小于枢轴值，后半部分值大于枢轴值，划分函数的返回值为指向排好序链表枢轴前一个元素的指针。这个指针有可能是空指针，我们需要做特殊判断。在快排函数中，我们需要对空指针做特殊处理。以下是完整版代码：//对单向链表进行快速排序#include#includeusing namespace std;//链表数据结构s