数据结构学习笔记（三）线性表（3）

数据结构学习笔记（三）线性表（3）

循环链表

循环链表的概念

  循环链表的首结点和尾结点被连接在一起。循环链表的第一个结点之前就是最后一个结点，反之亦然。

循环链表C语言实现

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

typedef struct LNode
{
    
    
    int data;
    struct LNode *next;
}LinkList, LNode;
LinkList *creat()
{
    
    
    LinkList *head, *p1, *p2;
    int i;
    if ((head = (LinkList *)malloc(sizeof(LNode))) == NULL)
    {
    
    
        printf("Error");
        exit(0);
    }
    p1 = p2 = head;
    printf("输入创建链表的长度:");
    scanf("%d, &head->data");//创建链表，带头结点，头结点数据域表示输入的个数
    if(head->data==0)
    {
    
    
        head->next = NULL;
        printf("已创带头结点的空链表");
    }
    else
    {
    
    
        printf("输入数据:\n");
        for (i = 0; i < head->data;i++)
        {
    
    
            if((p1=(LinkList*)malloc(sizeof(LNode)))==NULL)
            {
    
    
                printf("Error");
                exit(0);
            }
            scanf("%d", &p1->data);
            p2->next = p1;
            p2 = p1;
        }
        p1->next = head;
    }
    return (head);
}

void print(LinkList *head)
{
    
    
    LinkList *p;
    p = head->next;
    while(p!=head)
    {
    
    
        printf("%d", p->data);
        p = p->next;
    }
    printf("\n");
}
void main()
{
    
    
    LinkList *head;
    head = creat();
    print(head);
}

双向链表

双向链表概念

  双向链表中不仅有指向后于一个结点的指针，还有一个指向前一个结点的指针。这样可以从任何一个结点访问前一个结点，或者访问后一个结点，以至整个链表。

  双向链表的每个节点都有两个指针域、一个数据域。

双向链表的C语言实现

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

typedef struct DuLNode
{
    
    
    int i;
    struct DuLNode *next, *prior;
} DuLNode, *DuLinkList;

DuLNode *create_list()
{
    
    
    int a[] = {
    
    1, 2, 3, 4, 5};
    int j;
    DuLNode *head, *p1, *p2;
    p2 = head = (DuLinkList)malloc(sizeof(DuLNode));
    head->next = head->prior = NULL;
    for (j = 4; j >= 0;j--)
    {
    
    
        p1 = (DuLinkList)malloc(sizeof(DuLNode));
        p1->prior = head;
        p1->next = head->next;
        head->next = p1;
    }
    return head;
}

DuLNode *insert_list(DuLNode *head, int i, int num)
{
    
    
    DuLNode *p, *q;
    int j;
    for (j = 1, p = head->next; j < i && p->next;j++)
    {
    
    
        q = p->next;
        q->prior = p;
        p = q;
    }
    q = (DuLinkList)malloc(sizeof(DuLNode));
    q->i = num;
    q->prior = p->prior;
    q->next = p;
    p->prior->next = q;
    p->prior = q;
    return head;
}