数据结构--1. 链表

---

一、单链表

链表是通过一组任意的存储单元来存储线性表中的数据元素，链表中的每个节点都至少包括两个域（数据域和指针域）。

结点的定义：

typedef struct node
{
	DataType data;//数据域
    struct node *next;//指针域
}LNode,*LinkList;

1. 基本运算

1.1 单链表的建立

1.1.1 头插法

• 创建头节点；

• newNode表示待插入节点，维护newnode指向新节点；

• 分情况：

  • 当链表为空时，即首次插入新节点，将head.next指向新插入节点；

  • 如果不是首次插入新节点，将新节点插入到head和head.next指向节点之间，即

    newnode.next = head.next;
    head.next = newNode;
    

代码实现：

LinkList Creat_LinkList1()
{
    LinkList head = (Linklist)malloc(sizeof(LNode));//生成头结点
    head->next = NULL;//空表
    LNode *newnode;
    int x;
    scanf("%d",&x);
    while(x!=-1)
    {
        newnode = (LinkList)malloc(sizeof(LNode));
        newnode->data = x;
        newnode->next = head->next;
        head->next = newnode;
        scanf("%d",&x);
    }
    return head;
}

1.1.2 尾插法

• 创建头节点；

• newNode表示待插入节点，维护tail指针，指示链表尾节点，当tail.next == null时，表示tail指向尾节点；

  • 当链表为空时，即首次插入新节点，将head.next指向新插入节点，即

    head.next = newNode;
    

  • 如果不是首次插入新节点，需要遍历整个链表定位到尾节点，并将新节点插入到尾节点之后，

    tail.next = newNode;
    

代码实现：

LinkList Creat_LinkList2()
{
    LinkList head = (Linklist)malloc(sizeof(LNode));//生成头结点
    head->next = NULL;
    LNode *newnode,*tail = head;
    int x;
    scanf("%d",&x);
    while(x!=-1)
    {
        newnode = (LinkList)malloc(sizeof(LNode));
        newnode->data = x;
        tail->next = newnode;
        tail = newnode;
        scanf("%d",&x);
    }
    tail->next = NULL;
    return head;
}

1.2 求表长

int Length_LinkList(Linklist head)
{
    LNode *newnode = head;
    int j = 0;
    while(newnode->next != NULL)
    {
        newnode = newnode->next;
        j++;
    }
    return j;
}

1.3 查找

1.3.1 按照序号查找

从链表的第一个元素结点起判断当前结点是否为第k个，若是，则返回该结点的指针，否则继续查找下一个，直到表结束；没有第k个结点返回NULL

LinkList Get_LinkList(LinkList head,int k)
{
   LNode *newnode = head;
   int j = 0;
   while(newnode->next != NULL && j<k)
   {
       newnode = newnode->next;
       j++;
   }
   if(j==k)
       return newnode;
    else
       return NULL;
}

1.3.2 按值x查找

从链表的第一个元素结点起判断当前结点的值是否等于x，若是，则返回该结点的指针，否则继续查找下一个，直到表结束；查找不到返回NULL

LNode *Locate(LinkList head,DataType x)
{
    LNode *newnode = head->next;
    while(newnode != NULL && newnode->data != x)
        newnode = newnode->next;
    return newnode;
}

1.4 插入

1.4.1 头插法和尾插法（链表的建立）

1.4.2 任意位置插入

• 找到插入位置的上一个结点

• 创建新结点

• 新结点的next域指向插入位置的下一个结点，即

  newnode->next = p->next
  

• 插入位置的上一个节点的next域指向新节点，即

  p->next = newnode
  

代码实现：

int Insert_LinkList(LinkList head,int i,DataType x)
{
    LNode *p,*newnode;
    p = Get_LinkList(head,i-1);
    if(p == NULL)
    {
        printf("插入位置i错")；
        return ERROR;
    }
    else
    {
        newnode = (LinkList)malloc(sizeof(LNode));
        newnode->data = x;
        newnode->next = p->next;
        p->next = newnode;
        return TRUE;
    }
}

1.5 删除

• 查找删除结点的前一个结点和后一个节点

• 前一个结点的next域指向后一个结点

  p->next = q->next;
  

• 释放删除节点的空间

  free(q);
  

代码实现：

int Del_LinkList(LinkList head,int i)
{
    LinkList p,q;
    p = Get_LinkList(head,i-1);
    if(p == NULL)
    {
    	printf("第i-1个结点不存在");
        return ERROR;
    }
    else
    {
        if(p->next == NULL)
        {
            printf("第i个结点不存在")；
            return ERROR;
        }
        else
        {
            q = p->next;
            p->next=q->next;//从链表中删除
            free(q);
            return TRUE;
        }
    }
}

二、单循环链表

单循环链表结点的定义：

typedef struct CircularLinkNode{
	 ElemType data;
	 CircularLinkNode *next;
}CircularLinkNode,*CircularLinkList;

各种操作与链表类似；

三、 双向链表

• 双向链表的结点构成：
  

1. 指针域：用于指向当前结点的直接前驱结点；
2. 数据域：用于存储数据元素;
3. 指针域：用于指向当前节点的直接后继结点。

• 双向链表的结点结构实现：

  typedef struct line{
      struct line * prior; //指向直接前趋
      int data;
      struct line * next; //指向直接后继
  }line;
  

• 创建一个双向链表

  line* initLine(line * head){
      head=(line*)malloc(sizeof(line));//创建链表第一个结点（首元结点）
      head->prior=NULL;
      head->next=NULL;
      head->data=1;
      line * list=head;
      for (int i=2; i<=3; i++) {
          //创建并初始化一个新结点
          line * body=(line*)malloc(sizeof(line));
          body->prior=NULL;
          body->next=NULL;
          body->data=i;
        
          list->next=body;//直接前趋结点的next指针指向新结点
          body->prior=list;//新结点指向直接前趋结点
          list=list->next;
      }
      return head;
  }
  

1. 插入

p为链表中某结点，s为待插入结点，将*s插在 *p的前面

s->prior = p->prior;
p->prior->next = s;
s->next = p;
p->prior = s;

2. 删除

p为待删除结点

p->prior->next = p->next;
p->next->prior = p->prior;
free(p);

双向链表的各种操作图解

---

续：双向循环链表

实现：约瑟夫环