单链表算法

首先对链表而言,需要考虑两个问题:
1) 头指针,在对链表进行操作时,是否有可能改变头节点?如果可能,那么函数的参数就不应该是类似:insert( node *head) , 而应是 inset(node **phead)这样的.
2) 经常需要进行遍历操作中,是否已经到了链表结尾是始终要注意的问题

1 单链表的普通操作
插入一个节点:
int insert(node **phead, node *pos, int data)
{
   node *cur = *phead;
    node *new = (node *)malloc(sizeof(node));
    if( !new) return 1;
   new->data = data;
if(!pos) {
     new->next = *phead;
     *phead = new;
   return 0;
   }
   while(cur)
{

   if(cur == pos){
    new->next = pos -> next;
pos -> next = new;
return 0;
}

cur = cur->next;
}

     return 1;
}

删除一个节点:要考虑头指针
int deletenode(node **phead, int data){
{
   node *cur = *phead;
   if( (*phead)->data == data)
     { *phead = *phead ->next;
         free(*phead);
        return 0;
   }
   while(cur->next->data != data) cur= cur->next;
   if(!cur) return 1;
}  

2 单链表的逆转
直接的方法:

递归方法
List* rev( List * head )
{
List *rHead;
if( !head )
{
return head;
}
else if( !head->next ) //只有一个结点
{
return head;
}
else
{
rHead = rev( head->next );
head->next->next = head;
head->next = NULL;
return rHead;
}
}  

普通的方法

int Contray_CirL(CirLinkList &L) // 将单链表逆置，并返回 OK
{CirLinkList t,p; //从第二个节点开始，将其向前插入为第一个节点
t=L;
t=t->next;
p=t->next;
while (p!= NULL )
{ t->next=p->next;// 连接后面的节点，p为操作节点
p->next=L->next;//p插入到第一节点前
L->next=p; //连接头指针
p=t->next; //操作下个节点
} // while 结束
return OK;
} // Contray_CirL

3 单链表中是否有回路.
通常会有标志法, 追赶法等.这里只写追赶法.
int is_cycle(Node *head)
{
   Node *p1, *p2;
   p1 = head->next;
   p2 = head;
   if (!head || ! (p->next)) return 0;
while((p1->next->next) && P2)
{
   if(p1 == p2) return 1;
   p1 = p1 -> next->next;
   p2 = p2->next;
}
return 0;

}