数据结构与算法第二讲-[单向循环链表]

单向循环链表

单向循环链表：
单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。

//定义节点
typedef struct Node{
    ElemType data ;
    struct Node *next;
}Node;
typedef Node *LinkList;

• 初始化
循环链表的创建分为两种情况：
1.链表第一次创建: 创建一个新的结点 新结点的next指向自身（*L）->next = (*L);
2.链表已经创建,直接插入数据: 找到链表的尾结点，将尾结点的next指向新结点 ，新结点的next指向（*L）

Status creatCycleList(LinkList *L){
    int item;
    LinkList temp = NULL ;
    LinkList target = NULL ;
    printf("输入节点的值，输入0结束\n");
    while (1) {
        scanf("%d",&item);
        if(item==0) break;

        //如果输入的链表是空。则创建一个新的节点，使其next指针指向自己  (*head)->next=*head;
        if (*L == NULL) {
            *L = (LinkList)malloc(sizeof(Node));
            if (!*L) exit(0);
            (*L)->data = item;//赋值
            (*L)->next = *L;//指向自身
        }else{
            for (target = *L; target->next != *L;target = target->next);//找到尾结点

            temp = (LinkList)malloc(sizeof(Node));
            if(!temp) return ERROR;
            
            temp->data=item;
            temp->next=*L;  //新节点指向头节点
            
            target->next=temp;//尾节点指向新节点
        }
    }
    return OK;;
}

• 循环遍历
遍历循环链表，循环链表的遍历最好用do while语句，因为头节点就有值

void showList (LinkList L){
//    判断链表是否为空
    if (L == NULL) {
        return;;
    }else{
        LinkList temp ;
        temp = L;
        do {
            printf("%5d",temp->data);
            temp = temp->next;
        } while (temp != L);
    }
}

• 插入
1.如果插入的位置为1,则属于插入首元结点,所以需要特殊处理
  1.1 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
 1.2 找到链表最后的结点_尾结点,
  1.3. 让新结点的next 执行头结点.
  1.4. 尾结点的next 指向新的头结点;
  1.5. 让头指针指向temp(临时的新结点)
2.插入的位置在其他位置
  2.1 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
  2.2 先找到插入的位置,如果超过链表长度,则自动插入队尾;
  2.3 通过target找到要插入位置的前一个结点, 让target->next = temp;
  2.4 插入结点的前驱指向新结点,新结点的next 指向target原来的next位置 ;

//4.3 循环链表插入数据
Status ListInsert(LinkList *L, int place, int num){
    
    LinkList temp ,target;
    int i;
    if (place < 1) {
        return ERROR;
    }
    if (place == 1) {
        
        //如果插入的位置为1,则属于插入首元结点,所以需要特殊处理
        //1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
        //2. 找到链表最后的结点_尾结点,
        //3. 让新结点的next 执行头结点.
        //4. 尾结点的next 指向新的头结点;
        //5. 让头指针指向temp(临时的新结点)
        
        temp = (LinkList)malloc(sizeof(Node));
        if (temp == NULL) {
            return ERROR;
        }
        temp->data = num;
        
        for (target = *L; target->next != *L; target = target->next);
        
        temp->next = *L;
        target->next = temp;
        *L = temp;
        
    }else
    {
        
        //如果插入的位置在其他位置;
        //1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
        //2. 先找到插入的位置,如果超过链表长度,则自动插入队尾;
        //3. 通过target找到要插入位置的前一个结点, 让target->next = temp;
        //4. 插入结点的前驱指向新结点,新结点的next 指向target原来的next位置 ;
        
        temp = (LinkList)malloc(sizeof(Node));
        if (temp == NULL) {
            return ERROR;
        }
        temp->data = num;
        
        
        if (place > linklistLength2(L)) {
            for (target = *L; target->next != *L ; target = target->next) ;
            
            temp->next = target->next;
            target->next = temp;

        } else {
        for ( i = 1,target = *L; target->next != *L && i != place - 1; target = target->next,i++) ;
        
        temp->next = target->next;
        target->next = temp;
            
        }
        

    }
    
    return OK;
}

• 删除

1. 如果要删除的位置是1
   如果删除到只剩下首元结点了,则直接将*L置空;
     1.1 删除首结点
     1.2 找到尾结点, 使得尾结点next 指向头结点的下一个结点 target->next = (*L)->next;
     1.3 新结点做为头结点,则释放原来的头结点
2. 要删除的是其他的位置
     2.1 找到删除结点前一个结点target
     2.2 新结点做为头结点,则释放原来的头结点
     2.3 释放需要删除的结点temp

Status linkListDelete(LinkList *L ,int place){
    LinkList temp,target;
    int i ;
    temp = *L;
      if(temp == NULL) return ERROR;
    if(place > linklistLength2(L)) return ERROR;

    if (place == 1) {
        //①.如果删除到只剩下首元结点了,则直接将*L置空;
           if((*L)->next == (*L)){
               (*L) = NULL;
               return OK;
           }
        //②.链表还有很多数据,但是删除的是首结点;
       //1. 找到尾结点, 使得尾结点next 指向头结点的下一个结点 target->next = (*L)->next;
       //2. 新结点做为头结点,则释放原来的头结点
        for (target = *L; target->next != *L; target = target->next) ;
        
        temp = *L;
        (*L) = (*L)->next;
        target->next = *L;
        free(temp);

    }else{
//      int length =  linklistLength2(*L);
//        if (place>length || place < 1) return  ERROR;;
        
            //如果删除其他结点--其他结点
            //1. 找到删除结点前一个结点target
            //2. 使得target->next 指向下一个结点
            //3. 释放需要删除的结点temp
            for(i=1,target = *L;target->next != *L && i != place -1;target = target->next,i++) ;
                temp = target->next;
                target->next = temp->next;
                free(temp);
    }
    
    return OK;
}

• 查询

int findValue(LinkList L,int value){
    
    int i = 1;
    LinkList p;
    p = L;
    
    //寻找链表中的结点 data == value
    while (p->data != value && p->next != L) {
        i++;
        p = p->next;
    }
    
    //当尾结点指向头结点就会直接跳出循环,所以要额外增加一次判断尾结点的data == value;
    if (p->next == L && p->data != value) {
        return  -1;
    }
    
    return i;
    
}

• 获取链表的长度

Status linklistLength(LinkList L){
    int length = 0 ;
    LinkList p = L->next;
         if (p) {
         length = 1;
     }
    while (p !=L) {
        length ++;
        p = p->next;
    }
    printf("链表的长度%d\n",length);
    return length;;
}
int linklistLength2(LinkList *L){
    int length = 0 ;
    LinkList p ;
    p = *L;
     if (p) {
         length = 1;
     }
    do {
        length ++;
        p = p->next;
    } while (p->next !=*L);

    printf("链表的长度%d\n",length);
    return length;;
}

线性表—链表结构与顺序存储结构优缺点对⽐比

• 分配方式
  顺序存储 O(1)
  单链表O(n)
• 时间性能
  存储结构需要平均移动⼀一个表⻓长⼀一半的元素,时间O(n)
  单链表查找某位置后的指针后,插⼊入和删除为 O(1)
• 空间性能
  顺序存储结构需要预先分配存储空间,分太⼤大,浪费空间;分⼩小了了,发⽣生上溢出
  单链表不不需要分配存储空间,只要有就可以分配, 元素个数也不不受限制

demo