链表

最新推荐文章于 2022-11-04 18:13:01 发布

脑阔大大

最新推荐文章于 2022-11-04 18:13:01 发布

阅读量365

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构

本文链接：https://blog.youkuaiyun.com/The_Dream_of_Rookie/article/details/50448493

数据结构专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了链表的概念，包括单向链表、双向链表和循环链表的区别，并通过具体代码演示了链表的基本操作如建立、插入、删除、打印和查找。同时，还展示了如何使用链表解决实际问题，例如实现循环链表和双向循环链表的基本操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

链表定义：

一种物理储存单元上非连续，非顺序的储存结构，其处理的方式都是通过指针来实现的；（所以说指针是一个很重要的部分）

链表的分类：单向链表（单向直链表，单向循环链表）；

双向链表(同上)；

链表的基本操作就是：链表的建立，插入，删除，打印，查找；

链表与数组的关系：两者都为线性表，数组的优点是随机访问，缺点就是需要事先知道数组长度；

链表的优点就是能够并不需要事先知道所需内存大小，可以充分利用零碎的空间，缺点就是操作复杂；

再此说明一下，因为笔者非常的懒惰所以代码全都是复制粘贴其他大神的（对于有瑕疵的地方还请包涵）；

在链表的基本操作之前需要设计链表结构：

typedef struct _LINK_NODE
{
    int data;
	struct _LINK_NODE* next;
}LINK_NODE;

下面就是单向链表的基本操作的演示：

建立：

LINK_NODE* alloca_node(int value)
{
    LINK_NODE* pLinkNode = NULL;
	pLinkNode = (LINK_NODE*)malloc(sizeof(LINK_NODE));
	
	pLinkNode->data = value;
	pLinkNode->next = NULL;
	return pLinkNode;
}

(对于数据的输入可以在建立链表的时候输入也可以以插入的方式输入)

插入：

STATUS _add_data(LINK_NODE** pNode, LINK_NODE* pDataNode)
{
    if(NULL == *pNode){
	    *pNode = pDataNode;
		return TRUE;
	}
	
	return _add_data(&(*pNode)->next, pDataNode);
}

打印：

void print_node(const LINK_NODE* pLinkNode)
{
    if(pLinkNode){
	    printf("%d\n", pLinkNode->data);
		print_node(pLinkNode->next);
	}
}

查找：

LINK_NODE* find_data(const LINK_NODE* pLinkNode, int value)
{
    if(NULL == pLinkNode)
	    return NULL;
	
	if(value == pLinkNode->data)
	    return (LINK_NODE*)pLinkNode;
	
	return find_data(pLinkNode->next, value);
}

删除：

STATUS _delete_data(LINK_NODE** pNode, int value)
{
    LINK_NODE* pLinkNode;
    if(NULL == (*pNode)->next)
	    return FALSE;
	
	pLinkNode = (*pNode)->next;
	if(value == pLinkNode->data){
	    (*pNode)->next = pLinkNode->next;
		free(pLinkNode);
		return TRUE;
	}else{
	    return _delete_data(&(*pNode)->next, value);
	}
}

循环链表：

以例题的形式：

#include <iostream>
 
//链表节点
struct Node
{
    int data;
    Node *next;
};
 
//在循环链表头部插入新的节点
void push(Node **head, int data)
{
    Node *newNode = new Node;
    Node *temp = *head;
    newNode->data = data;
    newNode->next = *head;
 
    //如果链表不为空，则将最后一个节点的后向指针设置为新节点
    //即新节点变成了新的头节点。
    if (*head != NULL)
    {
        while (temp->next != *head)
            temp = temp->next;
        temp->next = newNode;
    }
    else
        newNode->next = newNode; //新节点做为链表第一个节点
 
    *head = newNode;  //调整头节点
}
 
//打印循环链表
void printList(Node *head)
{
    Node *temp = head;
    if (head != NULL)
    {
        do
        {
            std::cout << " " << temp->data << " ";
            temp = temp->next;
        } while (temp != head);
    }
}
 
int main()
{
    //初始化链表为：[11]->2->56->12->[11],其中[11]表示同一个节点
    Node *head = NULL;
    push(&head, 12);
    push(&head, 56);
    push(&head, 2);
    push(&head, 11);
 
    std::cout<<"Circular Linked List: \n ";
    printList(head);
 
    return 0;
}

双向链表：

线性表的双向链表存储结构 

typedef struct DuLNode

{

   ElemType data;

   struct DuLNode *prior,*next;

}DuLNode,*DuLinkList;

带头结点的双向循环链表的基本操作

void InitList(DuLinkList L)

{ /* 产生空的双向循环链表L */

     L=(DuLinkList)malloc(sizeof(DuLNode));

     if(L)

         L->next=L->prior=L;

     else

         exit(OVERFLOW);

}

   

销毁双向循环链表L 

void DestroyList(DuLinkList L)

{

    DuLinkList q,p=(*L)->next; /* p指向第一个结点 */

    while(p!=*L) /* p没到表头 */

    {

        q=p->next;

        free(p);

        p=q;

   }

   free(*L);

   *L=NULL;

}

   

重置链表为空表 

void ClearList(DuLinkList L) /* 不改变L */

{ 　DuLinkList q,p=L->next; /* p指向第一个结点 */

    while(p!=L) /* p没到表头 */

   {

      q=p->next;

      free(p);

      p=q;

   }

   L->next=L->prior=L; /*头结点的两个指针域均指向自身 */

}

   

验证是否为空表 

Status ListEmpty(DuLinkList L)

{ /* 初始条件：线性表L已存在

     if(L->next==L&&L->prior==L)

         return TRUE;

     else

        return FALSE;

}

   


元素的操作

编辑

   

计算表内元素个数 

int ListLength(DuLinkList L)

{ /* 初始条件：L已存在。操作结果： */

     int i=0;

     DuLinkList p=L->next; /* p指向第一个结点 */

     while(p!=L) /* p没到表头 */

    {

       i++;

       p=p->next;

    }

    return i;

}

   

赋值 

Status GetElem(DuLinkList L,int i,ElemType *e)

{ /* 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */

     int j=1; /* j为计数器 */

     DuLinkList p=L->next; /* p指向第一个结点 */

     while(p!=L&&j<i)

     {

        p=p->next;

        j++;

     }

     if(p==L||j>i) /* 第i个元素不存在 */

         return ERROR;

     *e=p->data; /* 取第i个元素 */

     return OK;

}

   

查找元素 

int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))

{ /* 初始条件：L已存在，compare()是数据元素判定函数 */

/* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */

/* 若这样的数据元素不存在，则返回值为0 */

     int i=0;

     DuLinkList p=L->next; /* p指向第1个元素 */

     while(p!=L)

    {

       i++;

       if(compare(p->data,e)) /* 找到这样的数据元素*/

             return i;

       p=p->next;

    }

    return 0;

}

   

查找元素前驱 

Status PriorElem(DuLinkList L,ElemType cur_e,ElemType *pre_e)

{ /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */

/* 否则操作失败，pre_e无定义 */

    DuLinkList p=L->next->next; /* p指向第2个元素 */

    while(p!=L) /* p没到表头 */

    {

       if(p->data==cur_e)

       {

         *pre_e=p->prior->data;

         return TRUE;

       }

       p=p->next;

    }

    return FALSE;

}

   

查找元素后继 

Status NextElem(DuLinkList L,ElemType cur_e,ElemType *next_e)

{ /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */

/* 否则操作失败，next_e无定义 */

   DuLinkList p=L->next->next; /* p指向第2个元素 */

   while(p!=L) /* p没到表头 */

   {

       if(p->prior->data==cur_e)

       {

         *next_e=p->data;

         return TRUE;

       }

       p=p->next;

   }

   return FALSE;

}

   

查找元素地址 

DuLinkList GetElemP(DuLinkList L,int i) /* 另加 */

{ /* 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，*/

/* 返回NULL */

      int j;

      DuLinkList p=L; /* p指向头结点 */

      if(i<0||i>ListLength(L)) /* i值不合法 */

          return NULL;

      for(j=1;j<=i;j++)

          p=p->next;

      return p;

}

   

元素的插入 

Status ListInsert(DuLinkList L,int i,ElemType e)

{ /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */

/* 改进算法2.18，否则无法在第表长+1个结点之前插入元素 */

     DuLinkList p,s;

     if(i<1||i>ListLength(L)+1) /* i值不合法 */

         return ERROR;

     p=GetElemP(L,i-1); /* 在L中确定第i个元素前驱的位置指针p */

     if(!p) /* p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱) */

         return ERROR;

     s=(DuLinkList)malloc(sizeof(DuLNode));

     if(!s)

         return OVERFLOW;

     s->data=e;

     s->prior=p; /* 在第i-1个元素之后插入 */

     s->next=p->next;

     p->next->prior=s;

     p->next=s;

     return OK;

}

   

元素的删除 

Status ListDelete(DuLinkList L,int i,ElemType *e)

{ /* 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长 */

    DuLinkList p;

    if(i<1) /* i值不合法 */

        return ERROR;

    p=GetElemP(L,i); /* 在L中确定第i个元素的位置指针p */

    if(!p) /* p=NULL,即第i个元素不存在 */

        return ERROR;

    *e=p->data;

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

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

    free(p);

    return OK;

}

   

正序查找 

void ListTraverse(DuLinkList L,void(*visit)(ElemType))

{ /* 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit() */

    DuLinkList p=L->next; /* p指向头结点 */

    while(p!=L)

    {

      visit(p->data);

      p=p->next;

    }

    printf("\n");

}

void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))

   

逆序查找 

{ /* 由双链循环线性表L的头结点出发，逆序对每个数据元素调用函数visit()。另加 */

    DuLinkList p=L->prior; /* p指向尾结点 */

    while(p!=L)

    {

     visit(p->data);

     p=p->prior;

    }

   printf("\n");

}