void change(LNode *head){

  LNode *tmp = head;

  while(tmp->next != null){

     tmp = tmp->next;

   }

   tmp->next = head;

}

void linklist_c(Lnode *head){

     Lnode *p; p=head;

     if(!p) return ERROR;

     while(p->next!=NULL)

          p=p->next;

     p->next=head;

 }

O(n)

时间复杂度o(n)

void Change(LinkNode * head)

{LinkNode* p=head;

while(p!=NULL) p=p->next;

p->next-head;

return;

}

node* ChangeToCycleLink(node* head)

{

node* h;

h=head;

while(h->next!=NULL)

{

h=h->next;

}

h->next=head;

return head;

}

void fun(LinkList *head)

{

 LinkList *p = head;

 while(p->next != NULL) p = p->next; //找到最后一个结点

 p->next = head; //改为循环链表

 return;

}

/*

对于表长为n的链表，其时间复杂度为O(n)，基本操作是找最后一个结点的p = p->next;指针移动语句

*/

void LinkList(Lnode *head){

      Lnode *p;

      p=head;

      if(!p) return error;

      while(p->next!=null){

      p=p->next;

       }

       p->next=head;

}

o(n)

void Change(LinkList &head)

{

    LinkNode *p = head;

    while(p->next!=NULL)

    {

        p=p->next;

    }

    p->next = head;

}

评论区中的有些答案和参考答案有一点差别，差别在于传参部分，有同学使用了&head，而参考答案使用的是*head，考虑到题目要求并不需要修改head指针，我认为更好的方式应该是参考答案中的*head。

void linklist_c(Lnode *head) {Lnode *p; p=head; if(!p) return ERROR; while(p->next!=NULL) p=p->next; p->next=head; } 设单链表的长度（数据结点数）为N，则该算法的时间主要花费在查找链表最后一个结点上（算法中的while循环），所以该算法的时间复杂度为O（N）。

思路

遍历单链表直到尾结点，将尾结点指针指向头指针head指向结点

时间主要开销在遍历部分

时间n+1，O(n)

不知

int CulList(List &head)

{

List p=head;

if(!p) return error;

whlie(p->next)

{

p=p->next;
}

p->next=head;

return trun;

}

void linklist_c(Lnode *head){

    Lnode *p; p=head;

    if(!p) return ERROR;

    while(p->next!=NULL)

        p=p->next;

    p->next=head;

}

O(N)

void circulate(LinkList L, *head){
  LNode *p;

  p=head->next;

  if(p==NULL) return;

  while(p){

    p=p->next;

  }

  p->next=head;

}

时间复杂度为O（n）

if(head==NULL){

return ERROR

}

LNode *tail=head->next

while(tail!=NULL){

tail=tail->next;

}

tail->next=head

return True

void exchange(linklist &head)

{

linklist p=head;

while(p->next)      p = p->next;

p->next = head;

}

实际按复杂度为 O(n)

#include<stdio.h>
#include<stdlib.h>
#define M (List)malloc(sizeof(Node))
typedef struct Node{
    int data;
    Node* next;
}Node,*List;

List create(int n){
    List head=NULL,tail=NULL;
    for(int i=0;i<n+10;i++){
        List p=M;
        p->data=i;
        if(head==NULL) head=tail=p;
        else{
            tail->next=p;
            tail=p;
        }
    }
    tail->next=NULL;
    return head;
} 
void print(List head){
    while(head){
        printf("%d ",head->data);
        head=head->next;
    }
    printf("\n");
}
//转变为循环链表  时间复杂度为O(n) 
void transform(List head){
    List p=head;
    while(p->next) p=p->next;
    p->next=head;
}
int main(){
    List head=create(0);
    transform(head);
    print(head);
    return 0;
}

bool CircleLinkList(LinkList L){

LNode *p = (LNode *)malloc(sizeof(LNode));

if (L->next == NULL || p == NULL)       // 若L为空表或内存不足分配失败则返回false

return false;

p == L->next;

while(p->next!=NULL){         // 找尾结点

p=p->next;

}

p->next = L->next;                 // 令尾结点的next指向第一个结点

return true;

}

该算法的主体在于寻找单链表的尾结点，算法的时间复杂度T(n)=O(n)，n为单链表的长度

bool CircleLinkList(LinkList L){

LNode *p = (LNode *)malloc(sizeof(LNode));

if (L->next == NULL || p == NULL)       // 若L为空表或内存不足分配失败则返回false

return false;

p == L->next;

while(p->next!=NULL){         // 找尾结点

p=p->next;

}

p->next = L->next;                 // 令尾结点的next指向第一个结点

return true;

}

该算法的主体在于寻找单链表的尾结点，算法的时间复杂度T(n)=O(n)，n为单链表的长度

void CreateCircle(ListNode* head)

{

        ListNode *p=head;

        if(!p) return;

        while(p->next!=NULL)

            p=p->next;

        p->next=head;

}