单链表的反转

typedef struct LinkNode {  
  int data;  
  struct LinkNode* next;  
}LinkNode, *LinkList;  

LinkList ReverseList(LinkList head) {  
  if (head == NULL || head->next == NULL) {
    return head;  
  }

  LinkList prev = NULL;  
  LinkList curr = head;  
  LinkList next = NULL;  
  while (curr != NULL) {
    next = curr->next;
    curr->next = prev;
    prev = curr;
    curr = next;
  }  
  return prev;  
} 

 

方法二：

struct ListNode{      int       m_nKey;      ListNode* m_pNext;};

  递归实现：

pNode reverseList(pNode head) 
{ 
	if(head == NULL || head->m_pNext == NULL)  
		return head; 
	pNode newHead = reverseList(head->m_pNext); 
	head->m_pNext->m_pNext = head; 
	head->m_pNext=NULL; 
	return newHead;
}

 

#include <stdio.h>
#include <malloc.h>


struct node 
{
	int data;
	struct node *m_pNext;
};

typedef struct node * PNode;

PNode reverseList(PNode head)   
{   
    if(head == NULL || head->m_pNext == NULL)    
        return head;   
    PNode newHead = reverseList(head->m_pNext);   
    head->m_pNext->m_pNext = head;   
    head->m_pNext=NULL;   
    return newHead;  
}  
PNode CreateList(const int num)
{
	PNode head = NULL,p = NULL,q = NULL;

	for(int i = 1;i <= num; i ++)
	{
		p = (PNode)malloc(sizeof(struct node));
		p->data = i;

		if(NULL == head)
		{
			head = p;
		}
		else
		{
			q->m_pNext = p;
		}
		q = p;
	}

	p->m_pNext = NULL;

	return head;
}
int main()
{
	PNode head = CreateList(5);
	PNode newHead = reverseList(head);

	PNode p = newHead;
	while(NULL != p)
	{
		printf("%3d",p->data);
		p = p->m_pNext;
	}


	return 0;
}

//解释： 

rHead = rev( head->next );//递归处理节点（head->next）开始的子链表；
head->next->next = head;//将当前输入节点（head）和其直接后节点（head->next）进行逆向关联，即节点（head->next）指向节点（head）；
head->next = NULL; //将原来正向指针取消 

 相邻元素互换：

#include <stdio.h>
#include <malloc.h>
 
typedef struct LinkNode {  
  int data;  
  struct LinkNode* next;  
}LinkNode, *LinkList;  

LinkList ReverseList(LinkList head) {  
  if (head == NULL || head->next == NULL) {
    return head;  
  }

  LinkList prev = NULL;  
  LinkList curr = head;  
  LinkList next = NULL;  
  while (curr != NULL) {
    next = curr->next;
    curr->next = prev;
    prev = curr;
    curr = next;
  }  
  return prev;  
} 

LinkList InverseList(LinkList head) {  
  if (head == NULL || head->next == NULL) {
    return head;  
  }

  LinkList prev = NULL;  
  LinkList curr = head;  
  LinkList next = NULL;  
  while (curr != NULL && curr->next != NULL) {  
    if (prev != NULL) { 
      prev->next = curr->next; 
    } else {
      head = curr->next;  
    }
    prev = curr;  
    next = curr->next->next;  
    curr->next->next = curr;  
    curr->next = next;  
    curr = next;   
  }  
  return head;  
}  
 
LinkList CreateList(const int n) {
  LinkList head = NULL, p = NULL, q = NULL;  
  for (int i  = 0; i < n; ++ i) {  
    p = (LinkList)malloc(sizeof(LinkNode));
    p->data = i;    
    if (NULL == head) {
      head = p;
    } else {
      q->next = p;
    }    
    q = p;
  }  
  q->next = NULL;  
  return head;  
}
 
void Print(LinkList head) {
  LinkList p = head;
  while (p != NULL) {
    printf("%d ", p->data);
    p = p->next;
  }
  printf("\n\n");
}
 
int main() {
  LinkList head = CreateList(11);  
  Print(head);  
  head = ReverseList(head);  
  Print(head);  
  head = InverseList(head);  
  Print(head);   
  return 0;
}

/* vim: set expandtab ts=4 sw=4 sts=4 tw=100: */

K个元素倒置的算法

#include <stdio.h>
#include <malloc.h>
struct node
{
    int item;
    struct node * next;
};
typedef struct node * LNode;
LNode CreateList(const int num)
{
    int i;
    LNode head = NULL,p = NULL,q = NULL;
    for(i = 1; i <= num; ++ i)
    {
        p = (LNode)malloc(sizeof(struct node));
        p->item = i;
        if(NULL == head)
        {
            head = p;
        }
        else
        {
            q->next = p;
        }
        q = p;
    }
    q->next = NULL;
    return head;
}
LNode reverseList(LNode head)
{
    if(head == NULL || head->next == NULL)
        return head;
    LNode newHead = reverseList(head->next);
    head->next->next = head;
    head->next=NULL;
    return newHead;
}


/*
LNode reverseList(LNode head)
{
    if (head == NULL || head->next == NULL)
    {
        return head;
    }
    LNode pPrev = NULL;
    LNode pCurr = head;
    LNode pNext = NULL;
    while (pCurr != NULL)
    {
        pNext = pCurr->next;
        pCurr->next = pPrev;
        pPrev = pCurr;
        pCurr = pNext;
    }
    return pPrev;
}
*/
LNode SwapPairs(LNode head)
{
    if (head == NULL || head->next == NULL)
    {
        return head;
    }
    LNode p = head;
    while (p != NULL && p->next != NULL)
    {
        int temp = p->item;
        p->item = p->next->item;
        p->next->item = temp;
        p = p->next->next;
    }
    return head;
}

LNode ReverseNode(LNode head, const int k)
{
    if (head == NULL || head->next == NULL)
    {
        return head;
    }
    LNode p = head;
    LNode s = NULL, q = NULL, r = NULL, t = NULL;
    while (p != NULL)
    {
        q = p;
        for (int i = 0; i < k - 1 && p->next != NULL; ++i)
        {
            p = p->next;
        }
        r = p->next;
        p->next = NULL;
        s = reverseList(q);
        if (q == head)
        {
            head = s;
        }
        else
        {
            t->next = s;
        }
        while (s->next != NULL)
        {
            s = s->next;
        }
        t = s;
        p = r;
    }
    return head;
}

void print(LNode head)
{
    LNode p = head;
    while (p != NULL)
    {
        printf("item:%d\n", p->item);
        p = p->next;
    }
}
int main()
{
    LNode head = CreateList(11);
    print(head);
    //LNode q = reverseList(head);
    head = ReverseNode(head, 3);
    print(head);
    return 0;
}