双链表的代码实现（上）

已于 2024-04-03 13:31:33 修改
阅读量102 收藏
点赞数
文章标签： 链表 数据结构 java c语言
于 2023-08-04 07:49:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55094971/article/details/128503703
版权

        双链表，又称双向链表。顾名思义，和单链表的数据组织形式一样，有指针域和数据域。只不过和单链表不同的是双链表拥有两个指针域分别指向前驱结点（直接前驱）和后继结点（直接后继）。因此与单链表相比，双链表中访问一个结点的前、后结点更方便。

        以下就是带头结点的双链表的不同代码实现：

        C语言（DoubleLinkedList）

#ifndef DOUBLELINKEDLIST_H_INCLUDED
#define DOUBLELINKEDLIST_H_INCLUDED
typedef int ElemType;
typedef struct Node
{
    ElemType elem;
    struct Node *prior;
    struct Node *next;
}LNode,*LinkedList;
void InitList(LinkedList *L)
{
    (*L)=(LNode*)malloc(sizeof(LNode));
    (*L)->next=NULL;
    (*L)->prior=NULL;
}
void DestroyList(LinkedList *L)
{
    LNode *p=(*L);
    while((*L)!=NULL)
    {
        p=(*L);
        (*L)=p->next;
        free(p);
        p=NULL;
    }
}
void ClearList(LinkedList *L)
{
    LNode *p=(*L);
    while(p->next!=NULL)
    {
        p=(*L)->next;
        (*L)->next=p->next;
        free(p);
    }
}
int ListEmpty(LinkedList *L)
{
    if((*L)->next!=NULL)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
int ListLength(LinkedList *L)
{
    LNode *p=(*L);
    int i=0;
    while(p->next!=NULL)
    {
        p=p->next;
        i++;
    }
    return i;
}
ElemType GetElem(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    else
    {
        LNode *p=(*L)->next;
        int i=0;
        while(i<index)
        {
            i++;
            p=p->next;
        }
        return p->elem;
    }
}
int LocateElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    int i=0;
    while(i<ListLength(L)&&p!=NULL)
    {
        if(p->elem==elem)
        {
            return i;
        }
        p=p->next;
        i++;
    }
    return -1;
}
ElemType PriorElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p!=NULL)
    {
        if(p->elem==elem&&LocateElem(L,elem)!=0)
        {
            return p->prior->elem;
        }
        p=p->next;
    }
    return -1;
}
ElemType NextElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p->next!=NULL&&LocateElem(L,elem)!=ListLength(L)-1)
    {
        if(p->elem==elem)
        {
            return p->next->elem;
        }
        p=p->next;
    }
    return -1;
}
void addFirst(LinkedList *L,ElemType elem)
{
    LNode *s,*p=(*L);
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    s->next=p->next;
    p->next=s;
    s->prior=p;
    if(s->next!=NULL)
    {
        s->next->prior=s;
    }
}
void addAfter(LinkedList *L,ElemType elem)
{
    LNode *p=(*L),*s;
    while(p->next!=NULL)
    {
        p=p->next;
    }
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    s->next=p->next;
    s->prior=p;
    p->next=s;
}
int ListInsert(LinkedList *L,int index,ElemType elem)
{
    if(index<0||index>ListLength(L))
    {
        return -1;
    }
    else if(index==0)
    {
        addFirst(L,elem);
        return 1;
    }
    else
    {
        LNode *p=(*L),*s;
        int i=0;
        while(i<index)
        {
            p=p->next;
            i++;
        }
        s=(LNode*)malloc(sizeof(LNode));
        s->elem=elem;
        s->next=p->next;
        s->prior=p;
        p->next=s;
        if(s->next!=NULL)
        {
            s->next->prior=s;
        }
        return 1;
    }
}
int ListDelete(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    else if(index==ListLength(L)-1)
    {
        LNode *p=(*L),*del;
        int i=0;
        while(i<index)
        {
            p=p->next;
            i++;
        }
        del=p->next;
        del->prior->next=NULL;
        del->prior=NULL;
        free(del);
    }
    else
    {
        LNode *p=(*L),*del;
        int i=0;
        while(i<index)
        {
            p=p->next;
            i++;
        }
        del=p->next;
        del->prior->next=del->next;
        del->next->prior=del->prior;
        free(del);
    }
    return 1;
}
void TraverseList(LinkedList *L)
{
    LNode *p=(*L)->next;
    while(p!=NULL)
    {
        printf("%d\t",p->elem);
        p=p->next;
    }
    printf("\n");
}
void TraverseListByReverseOrder(LinkedList *L)
{

    if(ListEmpty(L))
    {
        printf("\n");
    }
    else
    {
        LNode *p=(*L)->next;
        while(p->next!=NULL)
        {
            p=p->next;
        }
        while(p->prior!=NULL)
        {
            printf("%d\t",p->elem);
            p=p->prior;
        }
        printf("\n");
    }
}

#endif // DOUBLELINKEDLIST_H_INCLUDED

        C语言测试用例代码：

#include <stdio.h>
#include <stdlib.h>
#include <C:\Users\12952\Desktop\testc\DoubleLinkedList.h>
int main()
{
    LinkedList list;
    while(1)
    {
        printf("1:初始化顺序表  2:销毁顺序表  3:清理顺序表  4:判断表空\n5:返回表长  6:利用下标获取元素值  7:返回元素的位置  8:返回前驱元素\n9:返回后继元素  10:插入顺序表  11:删除表元素  12:遍历线性表\n13:前插元素 14:后插元素  15:逆序遍历线性表\n请选择操作选项:\n");
        int op;
        scanf("%d",&op);
        switch(op)
        {
        case 1:
            {
                InitList(&list);
                break;
            }
        case 2:
            {
                DestroyList(&list);
                break;
            }
        case 3:
            {
                ClearList(&list);
                break;
            }
        case 4:
            {
                if(ListEmpty(&list)==1)
                {
                    printf("表为空\n");
                }
                else
                {
                    printf("表不为空\n");
                }
                break;
            }
        case 5:
            {
                printf("表长为:%d\n",ListLength(&list));
                break;
            }
        case 6:
            {
                printf("请输入下标值:");
                int get;
                scanf("%d",&get);
                if(GetElem(&list,get)!=-1)
                {
                    printf("下标值%d对应的元素值为:%d\n",get,GetElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 7:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                if(LocateElem(&list,get)!=-1)
                {
                    printf("元素%d对应的下标值为:%d\n",get,LocateElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 8:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                if(PriorElem(&list,get)!=-1)
                {
                    printf("元素%d对应的前驱元素为:%d\n",get,PriorElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 9:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                if(NextElem(&list,get)!=-1)
                {
                    printf("元素%d对应的后继元素为:%d\n",get,NextElem(&list,get));
                }
                else
                {
                    printf("无此元素\n");
                }
                break;
            }
        case 10:
            {
                printf("请输入元素值:");
                int get;
                scanf("%d",&get);
                printf("请输入元素的位置:");
                int get1;
                scanf("%d",&get1);
                if(ListInsert(&list,get1,get)==1)
                {
                    printf("元素插入成功.\n");
                    TraverseList(&list);
                }
                else
                {
                    printf("插入失败\n");
                }
                break;
            }
        case 11:
            {
                printf("请输入下标值:");
                int get;
                scanf("%d",&get);
                if(ListDelete(&list,get)==1)
                {
                    printf("已删除元素\n");
                    TraverseList(&list);
                }
                else
                {
                    printf("未找到此元素\n");
                }
                break;
            }
        case 12:
            {
                printf("表中元素如下:\n");
                TraverseList(&list);
                break;
            }
        case 13:
            {
                printf("请输入元素的值:");
                int get;
                scanf("%d",&get);
                addFirst(&list,get);
                TraverseList(&list);
                break;
            }
        case 14:
            {
                printf("请输入元素的值:");
                int get;
                scanf("%d",&get);
                addAfter(&list,get);
                TraverseList(&list);
                break;
            }
        case 15:
            {
                printf("表中元素如下:\n");
                TraverseListByReverseOrder(&list);
                break;
            }
        }
    }
    return 0;
}

        Java代码:

package DataStructure.LinearList;
public class LinkedList1 {
    protected Object elem;
    protected LinkedList1 next;
    protected LinkedList1 prior;
    public LinkedList1(Object elem)
    {
        this.elem=elem;
    }
    public LinkedList1(){}
}

 

package DataStructure.LinearList;
public class DoubleLinkedList {
    private LinkedList1 list;
    private LinkedList1 head;
    public void InitList()
    {
        list=new LinkedList1();
        this.head=list;
        list.next=null;
        list.prior=null;
        list.elem=null;
    }
    public Boolean DestoryList()
    {
        ClearList();
        head.next=null;
        head.prior=null;
        head=null;
        return true;
    }
    public Boolean ClearList()
    {
        LinkedList1 pre=head;
        LinkedList1 temp=pre.next;
        while (temp!=null)
        {
            pre.elem=null;
            pre.prior=null;
            pre.next=null;
            pre=temp;
            temp=temp.next;
        }
        return true;
    }
    public Boolean ListEmpty()
    {
        if (head.next!=null)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    public int ListLength()
    {
        LinkedList1 temp=head;
        int i=0;
        while (temp.next!=null)
        {
            i++;
            temp=temp.next;
        }
        return i;
    }
    public Object GetElem(int index)
    {
        if(index<0||index>=this.ListLength())
        {
            return -1;
        }
        else {
            LinkedList1 temp=head;
            int i=0;
            while (i<index)
            {
                i++;
                temp=temp.next;
            }
            return temp.elem;
        }
    }
    public int LocateElem(Object elem)
    {
        LinkedList1 temp=head;
        for(int i=0;i<this.ListLength();i++)
        {
            if (temp.elem.equals(elem))
            {
                return i;
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Object PriorElem(Object elem)
    {
        int i=0;
        LinkedList1 temp=head;
        while (i<this.ListLength())
        {
            if (temp.elem.equals(elem))
            {
                try {
                    return temp.prior.elem;
                }
                catch (NullPointerException e)
                {
                    return -1;
                }
            }
            else
            {
                temp=temp.next;
            }
            i++;
        }
        return -1;
    }
    public Object NextElem(Object elem)
    {
        int i=0;
        LinkedList1 temp=head;
        while (i<this.ListLength()-1)
        {
            if (temp.elem.equals(elem))
            {
                return temp.next.elem;
            }
            else
            {
                temp=temp.next;
            }
            i++;
        }
        return -1;
    }
    public Boolean ListInsert(Object elem,int index)
    {
        if(index<0||index>this.ListLength())
        {
            return false;
        }
        LinkedList1 temp=head;
        LinkedList1 node=new LinkedList1(elem);
        if(index==0)
        {
            node.next=temp;
            temp.prior=node;
            node.prior=null;
            head=node;
            return true;
        }
        if(index>0)
        {
            int i=1;
            while(i<index)
            {
                temp=temp.next;
                i++;
            }
            node.next=temp.next;
            temp.next.prior=node;
            temp.next=node;
            node.prior=temp;
        }
        return true;
    }
    public void addFirst(Object elem)
    {
        LinkedList1 node=new LinkedList1(elem);
        node.next = head;
        head.prior=node;
        head=node;
    }
    public void addAfter(Object elem)
    {
        int i=0;
        LinkedList1 temp=head;
        if (this.ListLength()==0)
        {
            addFirst(elem);
        }
        else
        {
            while (i<this.ListLength()-1)
            {
                temp=temp.next;
                i++;
            }
            LinkedList1 node=new LinkedList1(elem);
            node.next=temp.next;
            temp.next.prior=node;
            temp.next=node;
            node.prior=temp;
        }
    }
    public Boolean DeleteElem(int index)
    {
        if(index<0||index>this.ListLength()-1)
        {
            return false;
        }
        if(index==0)
        {
            LinkedList1 pre=head;
            LinkedList1 temp=pre.next;
            temp.prior=null;
            head=temp;
            pre=null;
            return true;
        }
        else
        {
            LinkedList1 temp=head;
            for (int i = 0; i < index-1; i++) {
                temp=temp.next;
            }
            LinkedList1 delete=temp.next;
            temp.next=delete.next;
            delete.next.prior=temp;
            delete.next=null;//可有可无
            delete.prior=null;//可有可无
            return true;
        }
    }
    public void TraverseList()
    {
        LinkedList1 temp=head;
        while(temp.next!=null)
        {
            System.out.print(temp.elem+"\t");
            temp=temp.next;
        }
        System.out.println("");
    }
    public void TraverseListByReverseOrder()
    {
        int i=0;
        LinkedList1 temp=head;
        while (i<this.ListLength()-1)
        {
            temp=temp.next;
            i++;
        }
        while (temp!=null)
        {
            System.out.print(temp.elem+"\t");
            temp=temp.prior;
        }
        System.out.println("");
    }
}

        Java测试用例代码：

import DataStructure.LinearList.DoubleLinkedList;
import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        DoubleLinkedList list=new DoubleLinkedList();
        Scanner sc=new Scanner(System.in);
        int op;
        while (true)
        {
            System.out.println("1:初始化线性表;2:销毁线性表;3:清理线性表;4:判断表空;5:返回表长;6:按下标值获取元素;7:返回元素所在位置;" +
                    "8:返回前驱元素;9:返回后继元素;10:插入线性表;11:前插元素;12:后插元素;13:按下标值删除元素;14:遍历线性表;15:逆序遍历线性表");
            System.out.println("请输入操作选项：");
            op=sc.nextInt();
            switch (op)
            {
                case 1:
                {
                    list.InitList();
                    System.out.println("初始化完成");
                    break;
                }
                case 2:
                {
                    list.DestoryList();
                    System.out.println("销毁完成");
                    break;
                }
                case 3:
                {
                    list.ClearList();
                    System.out.println("清理完成");
                    break;
                }
                case 4:
                {
                    if(list.ListEmpty())
                    {
                        System.out.println("表为空");
                    }
                    else
                    {
                        System.out.println("表不为空");
                    }
                    break;
                }
                case 5:
                {
                    System.out.printf("表长为:%d\n",list.ListLength());
                    break;
                }
                case 6:
                {
                    System.out.print("请输入下标值:");
                    int getch=sc.nextInt();
                    System.out.println("下标"+getch+"对应的元素值为:"+list.GetElem(getch));
                    break;
                }
                case 7:
                {
                    System.out.print("请输入元素值:");
                    Object getch=sc.nextInt();
                    System.out.println("元素"+getch+"对应的下标为:"+list.LocateElem(getch));
                    break;
                }
                case 8:
                {
                    System.out.print("请输入元素值:");
                    Object getch=sc.nextInt();
                    if((int)list.PriorElem(getch)!=-1)
                    {
                        System.out.println("元素"+getch+"对应的前驱元素为:"+list.PriorElem(getch));
                    }
                    else
                    {
                        System.out.println("无此元素");
                    }
                    break;
                }
                case 9:
                {
                    System.out.print("请输入元素值:");
                    Object getch=sc.nextInt();
                    if((int)list.NextElem(getch)!=-1)
                    {
                        System.out.println("元素"+getch+"对应的后继元素为:"+list.NextElem(getch));
                    }
                    else
                    {
                        System.out.println("无此元素");
                    }
                    break;
                }
                case 10:
                {
                    System.out.print("请输入要插入的元素:");
                    int getch=sc.nextInt();
                    System.out.print("请输入插入的位置:");
                    int getch1= sc.nextInt();
                    if (list.ListInsert(getch,getch1))
                    {
                        System.out.println("插入成功");
                        list.TraverseList();
                    }
                    else
                    {
                        System.out.println("插入失败");
                        list.TraverseList();
                    }
                    break;
                }
                case 11:
                {
                    System.out.print("请输入要插入的元素值:");
                    Object getch=sc.nextInt();
                    list.addFirst(getch);
                    list.TraverseList();
                    break;
                }
                case 12:
                {
                    System.out.print("请输入要插入的元素值:");
                    Object getch=sc.nextInt();
                    list.addAfter(getch);
                    list.TraverseList();
                    break;
                }
                case 13:
                {
                    System.out.print("请输入下标值:");
                    int getch=sc.nextInt();
                    list.DeleteElem(getch);
                    list.TraverseList();
                    break;
                }
                case 14:
                {
                    System.out.println("元素如下:");
                    list.TraverseList();
                    break;
                }
                case 15:
                {
                    System.out.println("元素如下:");
                    list.TraverseListByReverseOrder();
                    break;
                }
            }
        }
    }
}

 

 

 

 

 

 

荧光百叶草
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素 9.将游标重置指向链表中的第一个数据元素 10.将游标移动指向到链表中的下一个数据元素 11.将游标移动指向到链表中的上一个数据元素 12.直接指定删除链表中的某个数据元素
双向链表的代码实现
qq_42557052的博客
11-14 681
#include <corecrt_malloc.h> constexpr auto OK = 1; constexpr auto Error = 0; constexpr auto True = 1; constexpr auto False = 0; typedef int Status; typedef int ElemType; //定义双链表结构体 typedef stru...
双向链表代码实现
weixin_44001521的博客
12-26 240
#include<iostream> using namespace std; typedef int ElementType;//定义类型 typedef struct DuLNode { ElementType data; struct DuLNode * prior;//前继 struct DuLNode * next;//后继 }DuLNode,* DuLinkLi...
双链表代码实现
YogaK的博客
04-01 124
package cn.dwk.链表; public class DoubleLinkedListDemo { public static void main(String[] args) { // 先创建节点 HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨"); HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟"); HeroNode2 hero3 = new HeroNode2(3, "吴用",
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
C++ 构造双向链表的实现代码
12-26
//构造双向链表，实现从控制台输入，插入，删除，求大小size等操作#include “stdafx.h”#include <iostream>using namespace std;//定义双向链表的节点template<class>struct NODE{ NODE* pre; T data; NODE* ...
基于C++的双链表实现
03-28
实现功能： void CreateList(T a[], int n); // 由a数组中的元素建造顺序表 void DispList(); // 输出顺序表L中的所有元素 int ListLength(); // 求顺序表的长度 bool GetElem(int i, T &e); // 求顺序表中某序列号...
golang双链表的实现代码示例
09-18
主要介绍了golang双链表的实现代码示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
双链表代码实现和讲解
ddhod64668的专栏
09-20 143
1、什么是链表 　　请移步看我前一篇https://www.cnblogs.com/han200113/p/11549338.html 2、双链表和单链表有什么不同？ 　　　　　　　　 双链表相比单链表的date域(节点内容)和next(指向下一个节点)多了一个pre(指向前一个节点) 单链表只能向后或向后查找，而...
双向链表C代码实现
Riseboy的博客
04-08 249
##双向循环链表代码实现 ###结点结构 //定义结点 typedef struct Node{ ElemType data; struct Node *prior; struct Node *next; }Node; typedef struct Node * LinkList; ###创建链表 Status createLinkList(LinkList *L){ ...
王道数据结构实践代码----双链表的实现（C语言版）
繁臻的小窝
08-28 660
王道数据结构实践代码----单链表的实现（C语言版） 前言 日期：2021年8月28日 书籍：王道2021年数据结构考研复习指导 代码内容：实现双链表的实现，包括初始化，插入新元素，删除新元素，输出，查询 代码难点 1.双链表插入、删除的操作 上图操作的语句顺序不是唯一的，但也不是任意的，①和②两步必须在④步之前，否则p的后继结点的指针就会丢掉，导致插入失败。 为了加深理解，读者可以在纸上画出示意图。 若问题改成要求在结点p之前插入结点s,请读者思考具体的操作步骤。 此处①②无顺序要求 若问题改成要
双链表的实现
weixin_44481341的博客
08-04 33
双链表的代码 public class DoubleLinkedList { DoubleLinkedList pre; DoubleLinkedList next; int n; public static void print(DoubleLinkedList node){ while (node!=null){ System.out.print(node.n+" "); node = node.next.
双链表的实现（C语言）---数据结构
不倒翁.
10-03 566
文章目录1.定义链表的结构体2.链表的插入2.1 链表的尾插2.2链表的头插2.3任意位置插入3.链表节点的删除3.1链表的尾删3.2链表的头删3.3任意位置的删除4.链表的修改4.1链表的查找4.2链表数据的修改5.清除链表5.1清理链表中的所有节点，不包括头结点5.2清理链表中的所有节点，包括头结点 链表可以说是数据结构中最基础的一部分，它分为单链表和双链表，他们的区别在于，单链表的结构中只有一个节点来指向它的后面的元素，而双链表中有两个节点，一个节点可以指向它前面的元素，一个可以指向它后面的元素，这就
双链表创建及代码实现对其的操作
我不想学习但是必须学习
08-06 117
在上一次了解了单链表的代码实现，以及对单链表操作。可以发现单链表具有以下的缺点： 1)单向链表，查找的方向只能是一个方向，从头开始，而双向链表可以向前或者向后查找。 2) 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除节点时，总是找到temp，temp是待删除节点的前一个节点来删除的。 双链表图示： 双向链表的遍历，添加，修改，删除的操作思路分析： 1）遍历：和单链表一样，只是可以向前，也可以向后查找。 2）添加（默认添加到双向链表的最后。） 　　步骤：先找到双链
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 326
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1063
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
「探索数据结构：了解顺序表」
2301_80321602的博客
05-17 526
顺序表是一种线性表的存储结构，它是由一组物理地址连续的存储单元（通常是数组）依次存储线性表中的元素。顺序表中的元素在内存中是连续存储的，通过元素在数组中的下标来访问和操作元素。顺序表的优点是访问元素的时间复杂度为O(1)，即可以通过下标直接访问元素，操作效率高；缺点是插入和删除元素时需要移动其他元素，时间复杂度为O(n)，效率较低。首先，我们需要定义动态顺序表的数据类型SLDataType和结构体SeqList。动态顺序表使用数组arr存储数据，size表示当前有效数据个数，capacity。
“ 树 ” 的概念
2401_82669797的博客
05-14 686
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。：若一个结点含有子结点，则这个结点称为其子结点的父结点；：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点；具有相同父结点的结点互称为兄弟结点；：一个结点含有的子树的个数称为该结点的度；：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
JAVA实现双向循环链表代码
07-14
Sure! Here's an example of Java code to implement a doubly circular linked list: ```java public class DoublyCircularLinkedList { private Node head; private int size; ... private class Node { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

荧光百叶草

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值