数据结构-链表顺序结构、链式结构（单链表、循环链表、双向链表）

最新推荐文章于 2022-09-05 21:48:11 发布
原创 最新推荐文章于 2022-09-05 21:48:11 发布 · 335 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #单链表 #链表

本文详细介绍了线性表的顺序存储与链式存储结构，包括单链表、循环链表及双向链表的实现原理与操作方法，如初始化、插入、删除等，并通过实例演示了各方法的应用。

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

线性结构顺序存储结构

// 优点：
// 1.无须关系表中元素之间的关系。
// 2.可以快速的得到任何元素
// 缺点：
// 1.插入和删除需要移动大量的元素
// 2.当线性表过大时，无法确定元素的大小
// 3.容易造成内存碎片

#include "stdio.h"
#define MAXLEN 10
typedef struct LIST{
    int Data[MAXLEN];
    int len;
} List;

// 初始化
void init(List* list);
// 线性表是否为空
int isEmpty(List list);
// 插入元素
int insertData(List* list, int index, int number);
// 删除元素
int deleteData(List* list, int index);
// 线性表长度
int getLen(List list);
// 清空线性表元素
int clearList(List list);
// 获取线性表元素
int getListData(List list, int index);
// 显示线性表所有元素
int showList(List list);

int main()
{
    int ret;
    List a;
    init(&a);
    ret = showList(a);
    if (ret != 0) {
        printf("show list error\n");
        return -11;
    }
    ret = insertData(&a, 0, 10);
    if (ret != 0) {
        printf("insertData list error\n");
        return -11;
    }
    ret = insertData(&a, 1, 20);
    if (ret != 0) {
        printf("insertData list error\n");
        return -11;
    }
    ret = insertData(&a, 2, 30);
    if (ret != 0) {
        printf("insertData list error\n");
        return -11;
    }
    ret = insertData(&a, 3, 40);
    if (ret != 0) {
        printf("insertData list error\n");
        return -11;
    }
    ret = showList(a);
    if (ret != 0) {
        printf("showList list error\n");
        return -11;
    }
    printf("list a len = %d\n",getLen(a));
    ret = deleteData(&a, 4);
    if (ret != 0) {
        printf("deleteData list error\n");
        return -11;
    }
    printf("list a len = %d\n",getLen(a));
    ret = showList(a);
    if (ret != 0) {
        printf("showList list error\n");
        return -11;
    }
    printf("get list data = %d\n",getListData(a,3));
    ret = clearList(a);
    if (ret != 0) {
        printf("clearList list error\n");
        return -11;
    }
    ret = showList(a);
    if (ret != 0) {
        printf("showList list error\n");
        return -11;
    }

    return 0;
}


void init(List* list)
{
    list->len = 0;
}
int isEmpty(List list)
{
    if (list.len == 0) {
        return 0;
    }
    return -1;
}
int insertData(List* list, int index, int number)
{
    if (list == NULL) {
        printf("addData fucntion param(list) error...return -1\n");
        return -1;
    }

    if (index > MAXLEN) {
        printf("addData fucntion param(i) error...return -1\n");
        return -1;
    }

    if (index == 0 && list->len == 0) {
        list->Data[0] = number;
        list->len++;
        return 0;
    }else if(index == list->len)
    {
        list->Data[list->len] = number;
        list->len++;
        return 0;
    }

    for(int i = list->len; i >= index-1; i--){
        list->Data[i] = list->Data[i-1];
    }
    list->Data[index-1] = number;
    list->len++;

    return 0;
}

int deleteData(List* list, int index)
{
    if (list == NULL) {
        printf("deleteData fucntion param(list) error...return -1\n");
        return -1;
    }
    if (index <= 0 || index > list->len) {
        printf("deleteData fucntion param(index) error...return -1\n");
        return -1;
    }

    if (list->len == 0) {
        printf("this list is empty,operater error");
        return 0;
    }else if(list->len == index)
    {
        list->Data[list->len-1] = 0;
        list->len--;
        return 0;
    }

    for (int i=index-1; i < list->len-1; i++) {
        list->Data[i] = list->Data[i+1];
    }
    list->Data[list->len-1] = 0;
    list->len--;

    return 0;
}

int getLen(List list)
{
    return list.len;
}

int clearList(List list)
{

    for (int i=0; i < list.len; i++) {
        list.Data[i] = 0;
    }
    list.len = 0;
    return 0;
}

int getListData(List list, int index)
{
    if (index <= 0 || index > list.len) {
        printf("getListData fucntion param(index) error...return -1\n");
        return -1;
    }
    return list.Data[index-1];
}

int showList(List list)
{
    if (list.len == 0) {
        printf("this list is empty\n");
        return 0;
    }
    for (int i=0; i<list.len; i++) {
        printf("%d ",list.Data[i]);
    }
    printf("\n");
    return 0;
}

线性表的链式存储结构 带头结点 单链表

#include "stdio.h"
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"


typedef struct Node{
    int data; // 数据域
    struct Node* next; // 指针域
} Node;

typedef struct Node* LinkList;


//初始化线性表
int initList(LinkList* list);
//线性表是否为空
int isEmpty(LinkList list);
//清空线性表
int clearList(LinkList list);
//线性表的长度
int getListLen(LinkList list);
//获取线性表的元素
int getListData(LinkList list, int index);
//判断元素是否在线性表中
int dataIsList(LinkList list, int value);
//插入元素
int insertDataInList(LinkList* list, int index, int value);
//删除元素
int deleteDataInList(LinkList* list, int index);
//打印链表
int showList(LinkList list);
//随机产生n个元素的值，建立带头节点的单链表(头插法)
int createListFirst(LinkList* list,int n);
//随机产生n个元素的值，建立带头节点的单链表(尾插法)
int createListEnd(LinkList* list, int n);

//初始化线性表 实际上就是创建了一个头结点
int initList(LinkList* list)
{
    *list = (LinkList)malloc(sizeof(Node)); // 产生头结点
    if (!(*list)) {
        printf("init linklist error.\n");
        return -1;
    }
    (*list)->next = NULL;

    return 0;
}
//线性表是否为空
int isEmpty(LinkList list)
{
    if (list->next) {
        printf("this list not empty\n");
    }else{
        printf("this list is empty\n");
    }
    return 0;
}
//清空线性表
int clearList(LinkList list)
{
    printf("clear this list \n");
    LinkList l = list->next;
    LinkList p;
    while (l) {
        p = l;
        free(l);
        l->next = NULL;
        l = p->next;
    }
    list->next = NULL;
    return 0;
}
//线性表的长度
int getListLen(LinkList list)
{
    LinkList l = list->next;
    int i=0;
    while (l) {
        i++;
        l = l->next;
    }
    return i;
}
//获取线性表的元素
int getListData(LinkList list, int index)
{
    int len = getListLen(list);
    if (index > len) {
        printf("function getListData param(index) more than list len....index = %d len = %d\n",index,len);
        return -1;
    }
    LinkList l = list->next;
    int num = 1;
    while (l && num < index) {
        l = l->next;
        num++;
    }

    return l->data;
}
//判断元素是否在线性表中
int dataIsList(LinkList list, int value)
{
    LinkList l = list->next;
    while (l) {
        if (l->data == value) {
            printf("the data(%d) exist the list\n",value);
            return 0;
        }
        l = l->next;
    }
    printf("dont exist this data(%d) in list\n",value);
    return 0;
}
//插入元素 在list链表中index位置，插入元素value
int insertDataInList(LinkList* list, int index, int value)
{
    // 当链表没有节点的时候，就是表头，
    // 当index为链表长度是，插在最末。
    int j=1;
    int len = getListLen(*list);
    LinkList newNode,newlist;
    newlist = (*list);

    newNode = (LinkList)malloc(sizeof(Node));
    newNode->data = value;

//    printf("\n");
    if (getListLen(*list) == 0) {
//        printf("11111111111111111111111\n");
        newlist->next = newNode;
        newlist = newNode;
        newlist->next = NULL;
    }else if(index >=getListLen(*list) ){
//        printf("22222222222222222222222 value = %d,len = %d,index = %d\n",value,len,index);

        while (1) {
            newlist = newlist->next;
            if (j == len)
            {
                break;
            }
            j++;
        }
//        printf("while after nowNode = %d\n",newlist->data);
        newlist->next = newNode;
        newlist = newNode;
        newlist->next = NULL;
    }else{
//        printf("333333333333333333333333 value = %d,len = %d,index = %d\n",value,len,index);
        while (1) {
            newlist = newlist->next;
            if (j == index) {
                break;
            }
            j++;
        }
//        printf("while after nowNode = %d\n",newlist->data);
        // 先接起来，在断开
        newNode->next = newlist->next;
        newlist->next = newNode;
    }
    return 0;
}

//删除元素
int deleteDataInList(LinkList* list, int index)
{
    int len = getListLen(*list);
    int num = 0;
    LinkList l = (*list)->next;

    if (index > len) {
        printf("function deleteDataInList param(index) more than list len....index = %d len = %d\n",index,len);
        index = len;
    }
    if (index == 1 || index == 0) {
        (*list)->next = (*list)->next->next;
        return 0;
    }

    while (l && num < index-2) {
        l = l->next;
        num++;
    }

    printf("delete data is %d\n",l->next->data);
    free(l->next);
    l->next = l->next->next;
    return 0;
}
//打印链表
int showList(LinkList list)
{
    LinkList l = list->next;
    printf("list have data : ");
    while (l) {
        printf("%d ",l->data);
        l = l->next;
    }
    printf("\n");
    return 0;
}
//随机产生n个元素的值，建立带头节点的单链表(头插法)
int createListFirst(LinkList* list,int n)
{
    LinkList l;
    int i;
    srand(time(0));
    *list = (LinkList)malloc(sizeof(Node));
    (*list)->next = NULL;
    for (i = 0; i<n; i++) {
        l = (LinkList)malloc(sizeof(Node));
        l->data = rand()%100;
        l->next = (*list)->next;
        (*list)->next = l;
        printf("%d ",l->data);
    }
    printf("\n");
    return 0;
}
//随机产生n个元素的值，建立带头节点的单链表(尾插法)
int createListEnd(LinkList* list, int n)
{
    LinkList l,r;
    int i;
    srand(time(0));
    *list = (LinkList)malloc(sizeof(Node));
    r = *list;
    for (i=0; i<n;i++) {
        l = (LinkList)malloc(sizeof(Node));
        l->data = rand()%100;
        r->next = l;
        r = l;
        printf("%d ",l->data);
    }
    printf("\n");
    r->next = NULL;
    return 0;
}

int main1()
{
    LinkList linklist; // 这个就是头结点
    linklist->next = NULL;

    isEmpty(linklist);

    int ret = initList(&linklist);
    if (ret != 0) {
        printf("function initList error... %d \n",ret);
    }
    for (int i=1; i<6; i++) {
        ret = insertDataInList(&linklist, 1, i);
        showList(linklist);
    }

    showList(linklist);                             // 1 5 4 3 2
    int len = getListLen(linklist);
    printf("this list len is : %d\n",len);          // 5
    deleteDataInList(&linklist, 2);                 // 5
    showList(linklist);                             // 1 4 3 2

    deleteDataInList(&linklist, 0);                 // 1
    showList(linklist);                             // 4 3 2

    deleteDataInList(&linklist, 10);                // 2
    showList(linklist);                             // 4 3

    int data = getListData(linklist,4);
    if (data == -1)
    {
        printf("function getListData error\n");
    }else{
        printf("get data is %d\n",data);                // 2
    }

    dataIsList(linklist,30);                        // dont exist


    clearList(linklist);
    isEmpty(linklist);
    int len1 = getListLen(linklist);
    printf("this list len is : %d\n",len1);
    return 0;
}
//  验证头插法和尾插法
int main2()
{
    LinkList l;
    initList(&l);
    createListFirst(&l, 10);
    showList(l);

    LinkList p;
    initList(&p);
    createListEnd(&p, 10);
    showList(p);
    return 0;
}

线性表的链式存储结构 带头结点 循环链表

#include "stdio.h"
#include "math.h"
#include "stdlib.h"


typedef struct Node{
    int data; // 数据域
    struct Node* next; // 指针域
} Node;

typedef struct Node* LinkList;


//初始化线性表
int initList(LinkList* list);
//线性表是否为空
int isEmpty(LinkList list);
//清空线性表
int clearList(LinkList list);
//线性表的长度
int getListLen(LinkList list);
//获取线性表的元素
int getListData(LinkList list, int index);
//判断元素是否在线性表中
int dataIsList(LinkList list, int value);
//插入元素
int insertDataInList(LinkList* list, int index, int value);
//删除元素
int deleteDataInList(LinkList* list, int index);
//打印链表
int showList(LinkList list);
//打印链表 用于确定是否是循环链表
int showList_1(LinkList list,int index);

int main()
{
    LinkList linklist; // 这个就是头结点
    linklist->next = NULL;

    int ret = initList(&linklist);
    if (ret != 0) {
        printf("function initList error... %d \n",ret);
    }
    for (int i=1; i<6; i++) {
        ret = insertDataInList(&linklist, 1, i);
    }

//    showList(linklist);                             // 1 5 4 3 2
    showList_1(linklist,2);

    return 0;
}


//初始化线性表 实际上就是创建了一个头结点
int initList(LinkList* list)
{
    *list = (LinkList)malloc(sizeof(Node)); // 产生头结点
    if (!(*list)) {
        printf("init linklist error.\n");
        return -1;
    }
    (*list)->next = NULL;

    return 0;
}
//线性表是否为空
int isEmpty(LinkList list)
{
    if (list->next) {
        printf("this list not empty\n");
    }else{
        printf("this list is empty\n");
    }
    return 0;
}
//清空线性表
int clearList(LinkList list)
{
    printf("clear this list \n");
    LinkList l = list->next;
    LinkList p;
    while (l) {
        p = l;
        free(l);
        l->next = NULL;
        l = p->next;
    }
    list->next = NULL;
    return 0;
}
//线性表的长度
int getListLen(LinkList list)
{
    LinkList l = list->next;
    int i=0;
    while (1) {

        if (l == list || l == NULL) {
            break;
        }
        l = l->next;
        i++;
    }
    return i;
}
//获取线性表的元素
int getListData(LinkList list, int index)
{
    int len = getListLen(list);
    if (index > len) {
        printf("function getListData param(index) more than list len....index = %d len = %d\n",index,len);
        return -1;
    }
    LinkList l = list->next;
    int num = 1;
    while (l && num < index) {
        l = l->next;
        num++;
    }

    return l->data;
}
//判断元素是否在线性表中
int dataIsList(LinkList list, int value)
{
    LinkList l = list->next;
    while (l) {
        if (l->data == value) {
            printf("the data(%d) exist the list\n",value);
            return 0;
        }
        l = l->next;
    }
    printf("dont exist this data(%d) in list\n",value);
    return 0;
}
//插入元素 在list链表中index位置，插入元素value
int insertDataInList(LinkList* list, int index, int value)
{
    // 当链表没有节点的时候，就是表头，
    // 当index为链表长度是，插在最末。
    int j=1;
    int len = getListLen(*list);
    LinkList newNode,newlist;
    newlist = (*list);

    newNode = (LinkList)malloc(sizeof(Node));
    newNode->data = value;

    //    printf("\n");
    if (len == 0) {
        //        printf("11111111111111111111111\n");
        newlist->next = newNode;
        newlist = newNode;
        newlist->next = *list;
    }else if(index >=len ){
        //        printf("22222222222222222222222 value = %d,len = %d,index = %d\n",value,len,index);

        while (1) {
            newlist = newlist->next;
            if (j == len)
            {
                break;
            }
            j++;
        }
        //        printf("while after nowNode = %d\n",newlist->data);
        newlist->next = newNode;
        newlist = newNode;
        newlist->next = *list;
    }else{
        //        printf("333333333333333333333333 value = %d,len = %d,index = %d\n",value,len,index);
        while (1) {
            newlist = newlist->next;
            if (j == index) {
                break;
            }
            j++;
        }
        //        printf("while after nowNode = %d\n",newlist->data);
        // 先接起来，在断开
        newNode->next = newlist->next;
        newlist->next = newNode;
    }
    return 0;
}

//删除元素
int deleteDataInList(LinkList* list, int index)
{
    int len = getListLen(*list);
    int num = 0;
    LinkList l = (*list)->next;

    if (index > len) {
        printf("function deleteDataInList param(index) more than list len....index = %d len = %d\n",index,len);
        index = len;
    }
    if (index == 1 || index == 0) {
        (*list)->next = (*list)->next->next;
        return 0;
    }

    while (l && num < index-2) {
        l = l->next;
        num++;
    }

    printf("delete data is %d\n",l->next->data);
    free(l->next);
    l->next = l->next->next;
    return 0;
}
//打印链表
int showList(LinkList list)
{
    LinkList l = list->next;
    printf("list have data : ");
    while (l != list) {
        printf("%d ",l->data);
        l = l->next;
    }
    printf("\n");
    return 0;
}
//打印链表 用于确定是否是循环链表
int showList_1(LinkList list, int index)  // index = 2
{
    int j=1;
    LinkList l = list->next;
    printf("list have data : ");
    while (1) {

        if (j == index) {
            break;
        }
        j++;
        l = l->next;
    }
    int tmp = l->data;
    while (1) {

        l = l->next;
        if (l != list) {
            printf("%d ",l->data);
        }
        if (tmp == l->data) {
            break;
        }
    }

    printf("\n");
    return 0;
}
#include "stdio.h"
#include "math.h"
#include "stdlib.h"




// 线性表的链式存储结构 带头结点   双向链表
typedef struct Node{
    int data; // 数据域
    struct Node* prior; //直接前驱指针
    struct Node* next; //直接后继指针
} Node;

typedef struct Node* LinkList;


//初始化线性表
int initList(LinkList* list);       //ok
//线性表的长度
int getListLen(LinkList list);      //ok
//插入元素
int insertDataInList(LinkList* list, int index, int value);      //ok
//删除元素
int deleteDataInList(LinkList* list, int index);      //ok
//打印链表
int showList(LinkList list);    //ok

int main()
{
    LinkList linklist; // 这个就是头结点
    linklist->next = NULL;

    int ret = initList(&linklist);
    if (ret != 0) {
        printf("function initList error... %d \n",ret);
    }
    for (int i=1; i<6; i++) {
        ret = insertDataInList(&linklist, 1, i);
        showList(linklist);
    }
    deleteDataInList(&linklist, 30);
    showList(linklist);


    return 0;
}


//初始化线性表 实际上就是创建了一个头结点
int initList(LinkList* list)
{
    *list = (LinkList)malloc(sizeof(Node)); // 产生头结点
    if (!(*list)) {
        printf("init linklist error.\n");
        return -1;
    }
    (*list)->next = NULL;
    (*list)->prior = NULL;

    return 0;
}
//线性表是否为空
int isEmpty(LinkList list)
{
    if (list->next) {
        printf("this list not empty\n");
    }else{
        printf("this list is empty\n");
    }
    return 0;
}
//清空线性表
int clearList(LinkList list)
{
    printf("clear this list \n");
    LinkList l = list->next;
    LinkList p;
    while (l) {
        p = l;
        free(l);
        l->next = NULL;
        l = p->next;
    }
    list->next = NULL;
    return 0;
}
//线性表的长度
int getListLen(LinkList list)
{
    LinkList l = list->next;
    int i=0;
    while (1) {

        if (l == list || l == NULL) {  // l == list 是处理循环链表的条件
            break;
        }
        l = l->next;
        i++;
    }
    return i;
}
//获取线性表的元素
int getListData(LinkList list, int index)
{
    int len = getListLen(list);
    if (index > len) {
        printf("function getListData param(index) more than list len....index = %d len = %d\n",index,len);
        return -1;
    }
    LinkList l = list->next;
    int num = 1;
    while (l && num < index) {
        l = l->next;
        num++;
    }

    return l->data;
}
//判断元素是否在线性表中
int dataIsList(LinkList list, int value)
{
    LinkList l = list->next;
    while (l) {
        if (l->data == value) {
            printf("the data(%d) exist the list\n",value);
            return 0;
        }
        l = l->next;
    }
    printf("dont exist this data(%d) in list\n",value);
    return 0;
}
//插入元素 在list链表中index位置，插入元素value
int insertDataInList(LinkList* list, int index, int value)
{
    LinkList l = (*list);
    LinkList newNode = (LinkList)malloc(sizeof(Node));
    newNode->data = value;
    newNode->prior = NULL;
    newNode->next = NULL;
    int j = 1;
    int len = getListLen(*list);
//        printf("\n");
    if (len == 0) {
//        printf("11111111111111111111111\n");
        l->next = newNode;
        newNode->prior = l;
        newNode->next = NULL;
    }else if(index >=len ){
//        printf("22222222222222222222222 value = %d,len = %d,index = %d\n",value,len,index);
        while (1) {
            l = l->next;
            if (j == len) {
                break;
            }

            j++;
        }
//        printf("l->data = %d ,j=%d ",l->data,j);
        l->next = newNode;
        newNode->prior = l;
        newNode->next = NULL;
    }else{
//        printf("333333333333333333333333 value = %d,len = %d,index = %d\n",value,len,index);
        while (1) {
            l = l->next;
            if (j == index) {
                break;
            }

            j++;
        }
//        printf("l->data = %d ,j=%d ",l->data,j);
        newNode->prior = l;
        newNode->next = l->next;
        l->next->prior = newNode;
        l->next = newNode;
    }
//    printf("\n");
    return 0;
}

//删除元素
int deleteDataInList(LinkList* list, int index)
{
    int len = getListLen(*list);
    int num = 0;
    LinkList l = (*list);

    if (index > len) {
        printf("function deleteDataInList param(index) more than list len....index = %d len = %d\n",index,len);
        index = len;
    }
    if (index == 1 || index == 0) {
        printf("delete data is %d\n",l->next->data);
        l->next = l->next->next;
        l->next->next->prior = l;
        return 0;
    }

    while (l && num < index-2) {
        l = l->next;
        num++;
    }

    printf("delete data is %d\n",l->next->data);
    l->next->next->prior = l;
    l->next = l->next->next;
    return 0;
}
//打印链表
int showList(LinkList list)
{
    LinkList l = list->next;
    printf("list have data : ");
    while (l) {
        printf("%d ",l->data);
        l = l->next;
    }
    printf("\n");
    return 0;
}
//打印链表 用于确定是否是循环链表
int showList_1(LinkList list, int index)  // index = 2
{
    int j=1;
    LinkList l = list->next;
    printf("list have data : ");
    while (1) {

        if (j == index) {
            break;
        }
        j++;
        l = l->next;
    }
    int tmp = l->data;
    while (1) {

        l = l->next;
        if (l != list) {
            printf("%d ",l->data);
        }
        if (tmp == l->data) {
            break;
        }
    }

    printf("\n");
    return 0;
}
顺序结构与链式结构
none
04-22 4744
摘抄自，严蔚敏 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 数据结构在计算机内存中的存储包括数据元素的存储和元素之间的关系的表示。 元素之间的关系在计算机中有两种不同的表示方法：顺序表示和非顺序表示。由此得出两种不同的存储结构：顺序存储结构和链式存储结构。 顺序存储结
数据结构之顺序链表
大象身边的小蚂蚁
10-06 112
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define N 32 #include&lt;string.h&gt; typedef struct seqlist { int data[N]; int last; }seqlist_t; seqlist_t * seqlist_creat() //初始化一个空的顺序...
数据结构之顺序存储结构和链式存储结构分析 , 图文并茂 , 又涨姿势了
热门推荐
刘跃辉的博客
09-05 11万+
在计算机中，数据元素并不是孤立、杂乱无序的，而是具有内在联系的数据集合。数据元素之间存在一种或多种特定关系，也就是数据的组织形式。为编写出一个 好"的程序，必须分析待处理对象的特性及各处理对象之间存在的关系。这也就是研究数据结构的意义所在。
双向链表按照顺序添加-----------韩顺平老师讲的数据结构
qq_39944028的博客
08-28 467
addOrderBy就是按照顺序添加，所有代码可以直接复制测试，测试用例也已经写好 package com.atguigu.linkedlist; public class DoubleLinkedListDemo { public static void main(String[] args) { //先创建节点 HeroNode2 hero1 = new HeroNode2(1, "松江", "及时雨"); HeroNode2 hero2 = new HeroNode2(2, "
2.C-数据结构-线性表-链表源码
最新发布
09-07
循环链表是一种特殊的链表，其尾节点的指针指向头节点，形成了一个环状结构，适用于实现循环队列等数据结构。 在编程实现链表时，通常需要定义节点结构体，其中至少包括数据域和指向下一个节点的指针域。为了管理...
数据结构-链表.pdf
08-15
数据结构-链表 数据结构是计算机科学和信息技术领域中的一个基础概念，指的是...链表是一种非常重要的数据结构，它可以分为单向链表、循环链表和双向循环链表等。链表的优点是插入和删除操作方便，缺点是存取速度慢。
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
- **链表分类**：在实际应用中，最常见的链表类型是无头单向非循环链表（常作为其他数据结构的子结构）和带头双向循环链表（用于独立存储数据）。 - **链表的实现**：链表节点通常包含数据和指向下一个节点的指针...
数据结构-链表相关功能和算法
06-11
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着不可或缺的角色。相比于数组，链表在处理动态数据集合时提供了更大的灵活性。在这个"数据结构-链表相关功能和算法"的主题中，我们将深入探讨链表的...
C语言实现顺序存储结构的循环链表
u012159565的专栏
12-25 460
c语言实现顺序存储结构下的循环链表
数据结构—循环链表、顺序表与链表的对比
weixin_45796387的博客
02-03 427
目录标题带头双向循环链表的增删查改顺序表与链表的对比 带头双向循环链表的增删查改 在实际链表的结构中，带头双循环链表结构最复杂，一般用在单独存储数据。 实际中使用的链表数据结构，都是带头双向循环链表。 另外这个结构虽然复杂，但是使用代码实现以后会带来很多优势，实现反而简单了。 链表的实现接口 List.h #include<stdio.h> #include<stdlib.h> #include<assert.h> // 带头+双向+循环链表增删查改
顺序表专题(3)——双向链表
Jakob_Hu的博客
05-17 255
双向链表概念双向链表节点实现双向链表实现 概念 双向链表是一种更复杂的链表，每个节点有两个指针域，一个指向前一个节点，如果当前节点为头节点时，指向空值；另一个链接指向下一个节点，如果当前节点为尾节点时，指向空值。 以一个简单的例子进行演示，如下， 双向链表节点实现 class DoubleNode: def __init__(self, item): self.prev...
数据结构——线性表 （顺序表、单链表、静态链表、循环链表、双向链表）
厚积而薄发，谋定而后动
04-12 1万+
线性表 ---顺序存储结构 ---链式存储结构（单链表、静态链表、循环链表、双向链表）
【数据结构】顺序表和单链表的区别
ifiwere的博客
03-17 1万+
little fairy 的第x篇博客。 顺序表和链表都是常见的线性结构。 顺序表和链表最基本的差异为：顺序表，逻辑相邻，物理也相邻（可以直接访问其前驱和后继）。链表，逻辑相邻，物理不相邻（需要通过辅助信息才能访问其前驱和后继）。 顺序表：储存在连续空间中。 （1）结构体//本例为不定长的顺序表。定长的顺序表相当于一个给定长度的数组，储存数据个数有限。 typedef struct...
数据结构--顺序表&链表
imp0128的博客
07-26 471
数据结构--顺序表&链表1.线性表2.顺序表2.1概念及基本结构2.2 接口实现 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以顺序结构和链式结构的形式存储。 特征： 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型； 数据元素之间具有一
顺序表与链表结构及解
qq_68140277的博客
08-07 994
在接触该知识点时，我们已经初步的了解了编程的基本规则和程序的意义，在此我们更深一步的去探索计算机在面对众多数据时，我们的前人是如何用不同的结构和方法，去解决不同类型和需求数据的处理。...
单链表结构实现和循环链表及双向链表的定义
qq_42932834的博客
06-06 999
单链表基础结构实现 这里我并没有写增删改查的功能，参考了数据结构严蔚敏版一书。然后我发现按他的那段初始化伪代码实现后，结点倒过来了，不过并不影响道理。 重点需要搞清楚单链表的结构，C好久没用去学面向对象了，结构体和malloc我有点忘记了，码在这里以后忘了当参考。 #include <iostream> #include <cstdio> #include <cs...
数据结构-链表表示与信息处理
"严蔚敏数据结构中的单链表表示" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和操作这些数据。单链表是数据结构的一种，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在清华...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值