精华内容
下载资源
问答
  • 循环列表与单链表的区别
    2021-03-30 21:36:44

    循环链表的实现指导说明

    循环链表与单链表操作实现的差异:
    1.在初始化函数中把语句(*head)->next = NULL 改为 (*head)->next =head
    2.在其他函数中把循环条件p->next!=NULL 和 p->next->next !=NULL 中的 NULL 该为头指针 head 即可

    更多相关内容
  • 单链表结点的删除 3循环链表的实现 3.1.插入 3.2.特点——没有明显的尾端 4双向链表 1.单链表 1.1单链表存储特点: 逻辑次序和物理次序不一定相同 元素之间的逻辑关系用指针表示 举例:(a1,a2,a3,a4)的存储示意图 ...

    目录

    1.单链表

    1.1单链表存储特点:

    1.2 单链表的结点结构

    1.定义单链表

    2.在单链表中申请一个结点 

    3.引用数据元素和指针域

    1.3 存储结构

    2.单链表的实现

    2.1 遍历操作

    2.2 求单链表的元素个数

    2.3 查找操作

    2.4 插入操作

    2.5 创建单链表

    1.头插法

    2.尾插法

    2.6.单链表结点的删除

    3循环链表的实现

    3.1.插入

    3.2.特点——没有明显的尾端

    4双向链表


    1.单链表

    1.1单链表存储特点:

    1. 逻辑次序和物理次序不一定相同

    2. 元素之间的逻辑关系用指针表示

    • 举例:(a1,a2,a3,a4)的存储示意图

    • 存储信息的这个单元我们称之为结点,一个结点包括数据域(存储当前信息)和指针域(存储下一结点的地址)。

    • 单链表是由若干结点构成的,单链表的结点只有一个指针域:

    单链表的结点结构: 

    1.2 单链表的结点结构

    1.定义单链表

     typedef struct node{
         Datatype data;      //数据域
         struct node *next;  //指针域
     }Node,*Link;  //*Link:指向结构体的指针

    使用typedef定义,Node,和*Link就相当于声明了一个类型

    • Node st : 等价于 struct node st;

      Link p : 等价于 struct node *p;

      p = (Link) malloc(sizeof(Node));

      等价于:

      p = (struct node *) malloc(sizeof(Node))

    2.在单链表中申请一个结点 

    //申请一个结点
     Link p;
     p = (Link)malloc(sizeof(Node));

    3.引用数据元素和指针域

     //引用数据元素
         (*p).data
         p -> data
     //引用指针域
         (*p).next
         p -> next

    1.3 存储结构

    • 重点在数据元素之间的逻辑关系表示,将实际存储地址抽象 

    • 将空表与非空表进行统一处理:头结点

    2.单链表的实现

    2.1 遍历操作

    • 操作接口:void displayNode(Link head);

     void displayNode(Link head){
         p = head -> next;
         while(p!=NULL){
             printf("%d",p->data);
             p = p->next;
         }
     }

    2.2 求单链表的元素个数

    • 操作接口:int length(Link head); 

     int length(Link head){
         p = head->next;
         count = 0;
         while(p != NULL){
             p=p->next;
             count++;
         }
         return count;
     }

    2.3 查找操作

    • 操作接口: int queryNode(Link head,DataType x); 

    int queryNode(Link head,DataType x){
         p = head->next;
         while(p!=NULL){
             if(p->data==x){
                 print(data);
                 return ture;
             }
             p=p->next;
         }
         return false;  //没有找到
     }

    2.4 插入操作

    • 操作接口:void inserNode(Link head,int i,dataType x);

    • 结点ai-1、x和ai之间的逻辑关系 

    • 边界情况:表头、表尾 

    • 算法描述

    bool insertNode(Link head,int i,DataType x){
         p = head;   //工作指针指向头结点
         count = 0;
         while(p!=NULL & count <i-1){
             p = p->next;
             count++;
         }
         if(p == NULL){
             return false;  //没有找到第i个节点
         }else{
             node = (Link)malloc(sizeof(Node)); //申请一个结点
             node->data = x;
             node->next = p->next;
             p->next = node;
             return true;
         }
     }

    2.5 创建单链表

    1.头插法

    • 操作接口: Link newList(Datatype a[],int n);

    • 头插法:将插入的结点插在头结点的后面

    插入第一个结点:

    •  再依次插入每一个结点
    • 特点:头插法的顺序与数组顺序相反

    template <calss DataType>
     Link newList(DataType a[],int n){
         //创建头结点
         head = (Link)malloc(sizeof(Node));
         head->next = NULL;
         //创建后续结点
         for(int i = 0;i<n;i++){
             node = (Link)malloc(sizeof(Node));
             node->data = a[i];
             node->next = head->next;
             head-next = node;
         }
         return head;
     }

    2.尾插法

    • 操作接口:Link newList(Datatype a[],int n);

    • 尾插法:将待插入的结点插在终端结点的后面 

     Link newList(DataType a[],int n){
         head = (Link)malloc(sizeof(Node));  //生成头结点
         head->next = NULL; 
         rear = head;  //初始化尾结点
         for(int i = 0;i<n;i++){
             node = (Link)malloc(sizeof(Node));
             node->data = a[i];
             rear->next = node;  
             /*node->next = NULL;*/
             rear = node;
         }
         rear->next = NULL;
         return head;
     }

    2.6.单链表结点的删除

    • 操作接口:bool deleteNode(Link head,DataType x);

    • 正在上传…重新上传取消

    • 算法描述:

       q-next = p->next;
       free(p);
    • 空表情况,判断

       if(head = NULL ||head->next = NULL){ //空表
           return false;
       }

    • 正在上传…重新上传取消

     bool deleteNode(Link head,DataType x){
         if(head->next=NULL || head=NULL){  //空表,或者链表中没有数据
             return false;
         }
         p=head->next;  //初始化p,q
         q=p->head;
         while(p!=NULL){ 
             if(p->data == x){
                 q->next = p->next;
                 free(p);
                 return true;
             }else{
                 q=p;
                 p=p->next;
             }
         }
         return flase;
     }

    3循环链表的实现

    • 可以找到p的前驱结点 

    3.1.插入

    3.2.特点——没有明显的尾端

    4双向链表

    • 快速找出前驱

    展开全文
  • 目录1 单链表节点实现单链表操作单链表实现测试链表顺序表对比2 单向循环链表操作实现测试3 双向链表操作实现测试 1 单链表 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域...

    1 单链表

    单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值。
    ![在这里插入GLKg==,size_20,color_FFFFFF,t_70,g_se,x_16)

    表元素域elem用来存放具体的数据。
    链接域next用来存放下一个节点的位置(python中的标识)
    变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点。

    节点实现

    class SingleNode(object):
        """单链表的结点"""
        def __init__(self,item):
            # _item存放数据元素
            self.item = item
            # _next是下一个节点的标识
            self.next = None

    单链表操作

    is_empty() 链表是否为空
    length() 链表长度
    travel() 遍历整个链表
    add(item) 链表头部添加元素
    append(item) 链表尾部添加元素
    insert(pos, item) 指定位置添加元素
    remove(item) 删除节点
    search(item) 查找节点是否存在

    单链表实现

    class SingleLinkList(object):
        #单链表
        def __init__(self,node=None):
            #初始时候头指向为空,也就是先生成一个空的链表
            self.__head=node
    
        def is_empty(self):
            #判断是否为空
            return self.__head==None
    
        def length(self):
            #输出链表的长度
            #定义一个指针进行遍历
            cur=self.__head
            count=0
            while cur!=None:
                count+=1
                cur=cur.next
            return count
    
        def travel(self):
            #遍历整个链表
            cur=self.__head
            while cur != None:
                print(cur.elem,end=" ")
                cur=cur.next
            print('')
    
        def add(self,item):
            #头部插入
            node=SingleNode(item)
            #方法一:头后插入
            if self.is_empty():
                self.__head=node
            else:
                p=self.__head
                self.__head=node
                node.next=p
    
            # #方法二:重置头
            # node.next=self.__head
            # self.__head=node
    
        def insert(self,pos,item):
            #指定位置插入   pos从零开始索引
            node = SingleNode(item)
            if pos<=0:
                self.add(item)
            elif pos > self.length():
                self.append(item)
            else:
                pre = self.__head
                count = 0
                while count<(pos-1):#当循环退出后,指向pos-1位置
                    count += 1
                    pre = pre.next
                node.next=pre.next
                pre.next = node
    
        def append(self,item):
            #尾端加入
            node=SingleNode(item)
            if self.is_empty():
                self.__head=node
            else:
                cur=self.__head
                while cur.next != None:
                    cur=cur.next
                cur.next=node
    
        def remove(self,item):
            cur = self.__head
            pre=None
            while cur != None:
                if cur.elem == item:
                    #先判断是否事头节点
                    if cur == self.__head:
                        self.__head=cur.next
                    else:
                        pre.next=cur.next
                    break
                else:
                    pre = cur
                    cur = cur.next
    
        def search(self,item):
            #查找
            cur=self.__head
            while cur!=None:
                if cur.elem==item:
                    return True
                else:
                    cur=cur.next
            return False

    测试

    在这里插入图片描述

    链表与顺序表对比

    链表失去了顺序表随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大,但对存储空间的使用要相对灵活。链表与顺序表的各种操作复杂度如下所示:
    在这里插入图片描述
    注意虽然表面看起来复杂度都是 O(n),但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找,删除和插入操作本身的复杂度是O(1)。顺序表查找很快,主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况,顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作,只能通过拷贝和覆盖的方法进行。

    2 单向循环链表

    单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点。
    在这里插入图片描述

    操作

    is_empty() 判断链表是否为空
    length() 返回链表的长度
    travel() 遍历
    add(item) 在头部添加一个节点
    append(item) 在尾部添加一个节点
    insert(pos, item) 在指定位置pos添加节点
    remove(item) 删除一个节点
    search(item) 查找节点是否存在

    实现

    class Node(object):
        #节点
        def __init__(self,elem):
            self.elem=elem
            self.next=None
    
    class SingleCycleLinkList(object):
        #单项循环列表
        def __init__(self,node=None):
            #初始时候头指向为空,也就是先生成一个空的链表
            self.__head=node
            if node:
                node.next=node
    
        def is_empty(self):
            #判断是否为空
            return self.__head==None
    
        def length(self):
            #输出链表的长度
            if self.is_empty():
                return 0
            #定义一个指针进行遍历
            cur=self.__head
            count=1
            while cur.next!=self.__head:
                count+=1
                cur=cur.next
            return count
    
        def travel(self):
            #遍历整个链表
            if self.is_empty():
                return
            cur=self.__head
            while cur.next!=self.__head:
                print(cur.elem,end=" ")
                cur=cur.next
            #退出循环,cur指向尾节点,但尾节点的元素未打印
            print(cur.elem)
    
        def add(self,item):
            #头部插入
            node=Node(item)
            if self.is_empty():
                self.__head=node
                node.next=node
            else:
                cur = self.__head
                while cur.next != self.__head:
                    cur = cur.next
                # 退出循环,cur指向尾节点,
                node.next=self.__head
                cur.next=node
                self.__head=node
    
        def insert(self,pos,item):
            #指定位置插入   pos从零开始索引
            node = Node(item)
            if pos<=0:
                self.add(item)
            elif pos > self.length():
                self.append(item)
            else:
                pre = self.__head
                count = 0
                while count<(pos-1):#当循环退出后,指向pos-1位置
                    count += 1
                    pre = pre.next
                node.next=pre.next
                pre.next = node
    
        def append(self,item):
            #尾端加入
            node=Node(item)
            if self.is_empty():
                self.__head=node
                node.next=node
            else:
                cur=self.__head
                while cur.next !=self.__head:
                    cur=cur.next
                cur.next=node
                node.next=self.__head
    
        def remove(self,item):
            #删除节点
            if self.is_empty():
                return
            cur = self.__head
            pre=None
            while cur.next != self.__head:
                if cur.elem == item:
                    #先判断是否事头节点
                    if cur == self.__head:
                        #头节点的情况
                        #先找的尾节点
                        rear=self.__head
                        while rear.next!=self.__head:
                            rear=rear.next
                        self.__head=cur.next
                        rear.next=self.__head
                    else:
                        #中间节点
                        pre.next=cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
            # 退出循环,cur指向尾节点
            if cur.elem==item:
                if cur==self.__head:
                    #链表只有一个节点
                    self.__head=None
                pre.next = cur.next
    
        def search(self,item):
            #查找
            if self.is_empty():
                return False
            cur=self.__head
            while cur.next!=self.__head:
                if cur.elem==item:
                    return True
                else:
                    cur=cur.next
            if cur.elem == item:
                return True
            return False

    测试

    在这里插入图片描述

    3 双向链表

    每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。
    在这里插入图片描述

    操作

    is_empty() 链表是否为空
    length() 链表长度
    travel() 遍历链表
    add(item) 链表头部添加
    append(item) 链表尾部添加
    insert(pos, item) 指定位置添加
    remove(item) 删除节点
    search(item) 查找节点是否存在

    实现

    class Node(object):
        #节点
        def __init__(self,item):
            self.elem=item
            self.next=None
            self.prev=None
    
    class DoubleLinkList(object):
        #双链表
        def __init__(self,node=None):
            #初始时候头指向为空,也就是先生成一个空的链表
            self.__head=node
    
        def is_empty(self):
            #判断是否为空
            return self.__head is None
    
        def length(self):
            #输出链表的长度
            #定义一个指针进行遍历
            cur=self.__head
            count=0
            while cur!=None:
                count+=1
                cur=cur.next
            return count
    
        def travel(self):
            #遍历整个链表
            cur=self.__head
            while cur != None:
                print(cur.elem,end=" ")
                cur=cur.next
            print('')
    
        def add(self,item):
            #头部插入
            node=Node(item)
            node.next=self.__head
            self.__head=node
            node.next.prev=node
    
            # node.next=self.__head
            # self.__head.prev=node
            # self.__head=node
    
    
        def insert(self,pos,item):
            #指定位置插入   pos从零开始索引
            node = Node(item)
            if pos<=0:
                self.add(item)
            elif pos > self.length():
                self.append(item)
            else:
                cur=self.__head
                count = 0
                while count<pos:
                    count += 1
                    cur = cur.next
                #当循环退出后,cur就是指向pos这个位置
                node.next=cur
                node.prev=cur.prev
                cur.prev.next=node
                cur.prev=node
    
    
        def append(self,item):
            #尾端加入
            node=Node(item)
            if self.is_empty():
                self.__head=node
            else:
                cur=self.__head
                while cur.next != None:
                    cur=cur.next
                cur.next=node
                node.prev=cur
    
        def remove(self,item):
            cur = self.__head
            while cur != None:
                if cur.elem == item:
                    #先判断是否事头节点
                    if cur == self.__head:
                        self.__head=cur.next
                        #判断链表是否只有一个节点
                        if cur.next:
                            cur.next.prev=None
                    else:
                        cur.prev.next=cur.next
                        if cur.next:
                            cur.next.prev=cur.prev
                    break
                else:
                    cur = cur.next
    
        def search(self,item):
            #查找
            cur=self.__head
            while cur!=None:
                if cur.elem==item:
                    return True
                else:
                    cur=cur.next
            return False
    

    测试

    在这里插入图片描述

    展开全文
  • 单链表 文章目录***单链表***前言一、单链表二、使用步骤1.单链表存储结构2. 前言 提示:这里可以添加本文要记录的大概内容: 顺序表------随机存取 链表---------顺序存取 下面是链表的一些内容。 一、单链表 n个...

    链表

    文章目录

    链表

    一、单链表
    1.单链表存储结构
    2.1、单链表初始化
    2.2、判断链表是否为空*
    2.3、销毁单链表L
    3 单链表L的表长
    4、取值——取单链表中第i 个元素的内容
    5、按值查找
    6、插入

    7、删除*
    8、创建单链表*
    二、循环链表
    三、双向链表
    1.双向链表的插入
    2.双向链表的删除

    前言

    提示:这里可以添加本文要记录的大概内容:
    顺序表------随机存取
    链表---------顺序存取

    下面是链表的一些内容。

    一、单链表

    n个链表有指针链组成一个链表。
    单链表 --每个结点只有一个指针域。

    1.单链表存储结构

    代码如下(示例):

    typedef struct lnode {
    	ElemType  date;
    	struct lnode* next;
    }lnode,*linklist;
    

    eg 存储学生学号、姓名、成绩的单列表结点类型定义:

    typedef struct {
    	char num[8];
    	char  num[8];
    	int score;
    }Elemtype;
    typedef struct Lnode {
    	Elemtype  data;
    	struct Lnode* next;
    }lnode,*Linklist;
    

    2.1、单链表初始化

    代码如下(示例):

    status initlist_l(linklist &L){
    l=new Lnode;
    l->next=NULLreturn ok;
    

    2.2、判断链表是否为空

    int listEmpty(linklist L){
    if(l->next)
    return 0;
    else
    return 1;
    }
    

    2.3、销毁单链表L

    status Destroylist_l(linklist &L){
    Lnode *p;//linklist p;
    while(L)
    {
    p=L;
    L=L->next;
    delete p;
    }
    return ok;
    

    清空链表L

    status ClearList(linklist &L){
    Lnode *p,*q;//或linklist p,q;
    p=L->next;
    while(p){
    q=p->next;
    delete p;
    p=q;
    }
    L->next=NULL;
    return ok;
    }
    

    *3 单链表L的表长

    int ListLength_l(linklist L){//返回L中数据元素个数
    linklist p;
    p=L->next;
    i=0;
    while(p){
    i++;
    p=p->next;
    }
    

    4、取值——取单链表中第i 个元素的内容

    status GetElem-L(linklist L,int i,ElemType &e){
    p=l->next;j=1;
    while (p && j < i) {
    		p = p->next;
    		++j;
    	}
    	if (!p || j > i)
    		return 0;
    	e = p->data;
    	return 1;
    

    5、按值查找

    Lnode *LocateElem_L(linklist L,Elemtype e){
    p = p->next;j=1;
    	while (p && p->data != e)
    		{p = p->next;j++;}
    if(p)return j;
     else return 0;    
    

    6、插入

    status listlnsert_l(linklist& L, int i, Elemtype e)
    {
    	p = L; j = 0;
    	while (p && j < i - 1)
    	{
    		p = p->next; ++j;//寻找第i-1个结点,p指向i-1结点
    	}
    		if (!p || j > i - 1) return 0;
    		s = new Lnode; s->data = e;//生成新结点s,将结点s的数据域为e;
    		s->next = p->next;
    		p->next = s;
    		return ok;
    	
    }
    

    7、删除

    status Listdelete - L(linklist & L, int i, Elemtype & e)
    {
    	p = L; j = 0;
    	while (p->next && j < i - 1)
    	{
    		p = p->next; j++;
    	}//寻找第i个结点,并令p指向其前驱
    	if (!(p->next) || j > i - 1)return 0;
    	q = p->next;//临时保存被删除的结点以被释放
    	p->next = q->next;//改变删除结点前驱结点指针域
    	e = q->data;//保存删除结点的数据域
    	delete q;//释放空间c++
    	return ok;
    }
    

    8、创建单链表
    –8.11 头插法

    void Creatlist - H(linklist & L, int n) {
    	L = new Lnode;
    	L->next = NULL;//建立一个带头结点的单链表
    	for (int n; i > 0; i--)
    	{
    		p = new Lnode;//生成一个新节点c++
    		//p = (Lnode*)malloc(sizeof(Lnode));生成一个新节点c
    		cin >> p->data;
    		p->next = L->next;//插入到表头
    		L->next = p;
    	}
    }
    

    8.22 尾插法

    void Creatlist - H(linklist & L, int n) {
    	L = new Lnode; L->next = NULL;
    	r = L;//尾指针r指向头结点
    	for(int i=0;i<n;i++)
    	{
    		p = new Lnode; cin >> p->data;
    		p->next=NULL:
    		r->next = p;
    		r = p;//指向新的尾结点
    	}
    }
    

    二、循环链表

    前言

    从表中任一结点出发均可以找到表中其他结点;

    带尾指针循环链表的合并

    linklist  connect(linklist ta,linklist tb)
    {//假设ta,tb都是非空单循环链表
    p=ta->next;//p存表头结点
    ta->next=tb->next->next;//tb表头连接ta表尾
    delete tb->next;
    tb->next=p;
    return tb;
    }//时间复杂度o(1)
    

    三,双向链表

    前言
    在单链表的每个结点在增加一个指向其直接前驱的指针域prior,这样的链表就生成了两个方向不同的链;


    typedef struct DuLNode{
    elemtype  data;
    struct Dulnode  *prior,*next;
    }Dulnode,*Dulinklist;
    

    双向链表的插入

    void listlnsert_Dul(Dulinklist &L,int i,elemtype e)
    {
    if(!(p=GetElemp_Dul(L,i)))return error;
    s=new Dulnode;s->data=e;
    s->prior=p->prior;
    p->prior->next=s;
    s->next=p;
    p->prior=s;
    }
    

    双向链表的删除

    void Listdelete_Dul(Dulink &L,int i,elemtype &e){
    //删除带头结点的双向链表L的第i个元素
    e=p->data;
    p->prior->next=p->next;
    p->next->prior=p->prior;
    delete(p);
    return ok;
    }
    

    总结

    链式存储结构的优点:
    1、结点空间可以动态申请和释放;
    2.数据元素的逻辑次序靠结点的指针来指示,插入和删除时不需要移动数据元素;
    五、链式存储结构缺点:
    存储密度小,每个结点的指针域需额外占用存储空间。

    展开全文
  • 链表,是Java中的一种重要的链式数据结构。 众所周知,我们日常用手机电脑收发信息,下载视频和软件,都要进行数据的传输。这些数据都要以一种特定的数据结构来进行传输和存储,否则数据将会是一串毫无意义的0和1,...
  • 循环链表可以从一个结点到达任意节点,而单链表只能顺着链表一直查找下去(因为循环链表可以一直循环下去,而单链表只能走一遍)。 双向链表: 增加了前驱结点,在涉及前驱结点的头插、尾插、删除操作上有所不同...
  • 循环链表就是普通的单链表,最后一个元素存的地址本来是NULL,现在改成头结点的地址,从而形成循环. #include <stdio.h> #include <stdlib.h> #define MAX(X,Y) (X>Y?X:Y) #include <math....
  • 学习目标:循环链表和普通链表的区别 学习内容: 1、 循环单链表头指针在最后的优势 注:只有循环单链表有这个优势,循环双链表不需要 2、 初始化链表的区别 普通链表: bool init(LinkList &l){ l = (Node...
  • 单链表循环链表、双向循环链表总结

    千次阅读 多人点赞 2019-11-23 18:56:31
    链表介绍 不带头结点的单向链表 带头结点的单向链表 循环链表 双向循环链表
  • 单链表,双链表,循环链表区别

    千次阅读 2019-02-18 16:45:06
    单向链表单链表)  单向链表,它包含两个域,一个信息域和一个指针域。这个链接指向表中的下一个节点,而最后一个节点则 指向一个空值NULL。 单向链表只可向一个方向遍历。 查找一个节点的时候需要从第一个节点...
  • 简单理解单链表、双链表循环单链表循环链表 单链表只有后继指针 双链表有后继指针和前驱指针 循环单链表尾指针指向了头指针 循环双链表头结点的前驱指针指向了尾结点,尾结点的后继指针指向了头结点 ...
  • 链表不仅作为链式存储的一种实现方式,还表达了计算机不连续(离散)的存储思想。
  • 循环链表2.1 循环单链表2.2 循环双链表2.3 循环链表判空2.3.1 循环单链表2.3.2 循环双链表3. 静态链表4. 顺序表链表比较4.1 存取方式4.2 逻辑结构、物理结构4.3 基本操作4.4 内存空间总结4.5 怎样选择线性表的...
  • 数据结构第二章--循环单链表 循环链表
  • 结点只有一个指针域为单链表,首尾相接为循环链表。 头指针指向链表第一个结点,存储第一个数据为首元结点,首元结点前可能附设头结点。 无头结点时,头指针为空则为空表;有头结点时,头结点的指针域为空则为空表...
  • 单链表、双链表、循环链表

    千次阅读 2019-09-20 20:39:18
    链表与数组的区别 链表和数组都是线性表,两者区别如下: 数组静态分配内存,链表动态分配内存;更进一步说就是数组不易拓展,但链表易拓展。 数组在内存中连续,链表不连续;更进一步说就是数组可能会造成内存...
  • 文章目录循环链表循环单链表循环双链表静态链表说明 循环链表循环链表一般包括循环单链表和循环双链表,如下图所示: 循环单链表   循环单链表与单链表区别在于,表中最后一个结点的指针不是NULL,而改为...
  • 循环链表(循环单链表和双链表)

    千次阅读 2021-02-04 13:52:36
    循环链表前言一、循环单链表的初始化二、判断是否为空或表尾结点三、循环双链表的初始化四、循环双链表的插入删除 前言 对于循环单链表而言,在进行插入和删除时,可以让指针指向尾部,对于表头(通过尾部找到头部...
  • 文章目录带头结点的双向循环链表单链表区别面试题:写一个双向链表代码实现 带头结点的双向循环链表单链表区别   相比我们讲的无头单向非循环的单链表结构,他的插入和删除都是O(1),也不需要增容,浪费...
  • 循环链表如图所示,与单链表相比较,就是最后一个节点又赋值给了第一个节点,构成了一个环。 所以我们是先的思路也就只在单链表上增加:让最后一个节点指向第一个节点这一个功能。 在循环链表中没有最后一个节点的...
  • 单、双链表的循环链表(十五)

    千次阅读 2022-04-21 18:59:09
    1. 单链表循环链表 <1>.单链表循环链表特点 单链表只能向后操作,不能向前操作,如果从当前结点开始,无法访问该结点前面的结点。 如果最后一个结点的指针指向头节点,形成一个闭环,就可以从任意一个...
  • 线性顺序表、单链表循环链表、双向链表的区别 1、线性顺序表 用一种地址连续的存储单元依次存储线性表的数据元素 2、单链表(又称线性链表) 用一组任意的存储单元(此存储单元可以是连续的也可以是不连续的)来...
  • 题目:有两个循环单链表,链表头指针分别为h1和h2,编写一个函数将链表h2链接到链表 h1之后,要求链接后的链表仍保持循环链表的形式。 分析:题目意思就是将两个循环单链表合并成1个 算法思想:找到h1的表尾p,h2的...
  • 这个资料实现的是循环单链表-双链表,为初学者提供源码
  • 本文实例讲述了Python数据结构算法之链表定义用法。分享给大家供大家参考,具体如下: 本文将为大家讲解: (1)从链表节点的定义开始,以类的方式,面向对象的思想进行链表的设计 (2)链表类插入和删除等成员...
  • 二、循环链表与单链表区别 1、循环链表的操作和单链表基本一致。 2、差别仅在于:当遍历链表时,判别当前指针P是否指向表尾结点的终止条件不同。 3、由于循环链表中没有NULL指针,故涉及遍历操作时,其终止条件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,441
精华内容 25,376
热门标签
关键字:

循环列表与单链表的区别