1.从尾到头打印链表
先遍历链表，遍历的同时将链表的值头插进一个新的链表，在打印新的链表即可。

void SLitsPrintTailToHead(SListNode* pHead)
{SListNode* _new, *ptr;_new = NULL;ptr = pHead;while (ptr){SListPushFront(&_new, ptr->data);ptr = ptr->next;}while (_new){printf("%d ", _new->data);_new = _new->next;}
}

2.删除一个无头单链表的非尾节点（不能遍历链表）
假设删除的是pos节点，我们可以将pos的下一个节点的数据存入pos节点，在删除pos节点的下一个节点即可。

void SListDelNonTailNode(SListNode* pos)
{SListNode* Ppos;Ppos = NULL;Ppos = pos->next;pos->data = Ppos->data;pos->next = Ppos->next;free(Ppos);
}

3. 在无头单链表的一个节点前插入一个节点（不能遍历链表）
   假设我们需要在pos前插入一个节点，我们可以先在pos后插入一个与pos数据一样的节点，在将pos的数据改为给的值。

void SListInsertFrontNode(SListNode* pos, DataType x)
{SListNode* _new;_new = NULL;_new = BuySListNode(pos->data);_new->next = pos->next;pos->next = _new;pos->data = x;
}

4. 单链表实现约瑟夫环(JosephCircle)
   约瑟夫环 是一个数学的应用问题：已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依 此 规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后 结果+1即为原问题的解。
   先不断迭代找到尾节点，让尾节点的next指针指向头节点，这样形成了一个环，接着进入循环，循环的结束条件为只剩一个节点。不断地迭代k次然后删除当前节点。

SListNode* SListJosephCircle(SListNode* pHead, int k)
{SListNode* str, *tail;int i = 0;str = pHead;tail = pHead;while (tail->next){tail = tail->next;}tail->next = pHead;while (str->next!=str){for (;i < k;++i){str = str->next;}str->data = str->next->data;str->next = str->next->next;free(str->next);}return str;
}

5. 逆置/反转单链表
   遍历链表，同时将数据头插入链表，新的链表为反转链表。

SListNode* SListReverse(SListNode* list)
{SListNode* _new, *str;_new = NULL;str = list;while (str){SListPushFront(&_new, str->data);str = str->next;}return _new;
}

6.单链表冒泡排序

void SListBubbleSort(SListNode* list)
{int i, j,count;count = 0;int mid;SListNode* str,*ptri,*ptrj;str = list;while (str){str = str->next;count++;}for (i = 0;i < count-1;i++){ptri = list;ptri = ptri->next;for (j = 0;j < i-1;j++){ptrj = list;ptrj = ptrj->next;if (ptri->data > ptrj->data){mid = ptri->data;ptri->data = ptrj->data;ptrj->data = mid;}}}
}

7. 合并两个有序链表,合并后依然有序
   给两个指针分别指向两个有序链表，两个链表所指向的数据进行比大小，小的插入新链表并且指针向后走，进行下一次比较，当两个指针都走完时结束。

SListNode* SListMerge(SListNode* list1, SListNode* list2)
{SListNode* str1, *str2,*_new;str1 = list1;str2 = list2;_new = NULL;while (str1&&str2){if (str1->data > str2->data){SListPushBack(&_new,str2->data);str2 = str2->next;}if (str1->data < str2->data){SListPushBack(&_new, str1->data);str1 = str1->next;}else{SListPushBack(&_new, str2->data);}}return _new;
}

8. 查找单链表的中间节点，要求只能遍历一次链表
   给两个指针，第一个指针走一步时第二个指针走两步，当快指针走完时慢指针走到中间节点。

SListNode* SListFindMidNode(SListNode* list)
{SListNode* fast, *slow;fast = list;slow = list;while (fast->next){fast = fast->next;if (fast->next == NULL){break;}fast = fast->next;slow = slow->next;}return slow;
}

9. 查找单链表的倒数第k个节点，要求只能遍历一次链表
   同样定义两个指针，快指针先走k步慢指针开始走，当快指针走完时慢指针走到倒数第K个节点。

SListNode* SListFindTailKNode(SListNode* list, size_t k)
{SListNode* fast, *slow;fast = list;slow = list;int i;for (i = 0;i < k;i++){fast = fast->next;}while (fast){fast = fast->next;slow = slow->next;}return slow;
}

10.构造一个带环链表
找到环入口的节点，让尾节点指向入口节点。

SListNode* SListIsCycle(SListNode* list)
{SListNode* str,*ptr;str = list;ptr = SListFind(list, 0);while (str){str = str->next;}str->next = ptr;return ptr;
}

11.求环的长度
定义两个快慢指针，快指针走两步慢指针走一步，当他们在环里相遇时结束。再让他们继续走，第二次相遇时快指针一定比慢指针快了环的长度步。

int SListCycleLen(SListNode* meetNode)
{int len,count1,count2;SListNode*fast, *slow;fast = meetNode->next;slow = meetNode;int count=1;while (fast!=slow){fast = fast->next->next;slow = slow->next;}slow - slow->next;while (slow != fast){slow = slow->next;count++;}return count;
}