链表，顺序表，链队，链栈，顺序队，顺序栈，二叉树的基本操作函数

最新推荐文章于 2021-05-11 20:37:26 发布
最新推荐文章于 2021-05-11 20:37:26 发布
阅读量494 收藏 2
点赞数
分类专栏： 数据结构 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wp1027322856/article/details/78327599
版权


链表的基本操作：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct node{
    int data;
    struct node *next;
}list,*L;


L creat(void)
{
    L l1 = malloc(sizeof(list));
    l1->data = -1;
    l1->next = NULL;
    return l1;
}


int getlen(L l1)
{
    int i = 0;
    L h = l1->next;
    while(h != NULL)
    {
        i++;
        h = h->next;
    }
    return i;
}


void show(L l1)
{
    L h = l1->next;
    while( h != NULL)
    {
        printf("%d,",h->data);
        h = h->next;
    }
    printf("\n");
}


int dellist(L l1,int pos)
{
    L h = l1;
    int len = getlen(l1);
    if(h->next == NULL)
    {
        printf("list is empty\n");
        return -1;
    }


    if(pos < 0 || pos > len-1)
    {
        printf("pos error\n");
        return -1;
    }


    while(pos--)
    {
        h = h->next;
    }
    
    L d = h->next;
    h->next = d->next;
    free(d);
    return 0;
}


int insert(L l1,int pos,int val)
{
    L h = l1;
    int len = getlen(l1);
    if(pos < 0 || pos > len)
    {
        printf("pos error\n");
        return -1;
    }
    while(pos--)
    {
        h = h->next;
    }
    L s = malloc(sizeof(list));
    s->data = val;
    s->next = h->next;
    h->next = s;
    return 0;
}


int changlist(L l1,int pos,int val)
{
    L h = l1->next;
    int len = getlen(l1);
    if(pos < 0 || pos > len-1)
    {
        printf("pos error\n");
        return -1;
    }
    while(pos--)
    {
        h = h->next;
    }
    h->data = val;
    return 0;
}


int search(L l1,int pos)
{
    L h = l1->next;
    int len = getlen(l1);
    if(pos < 0 || pos > len-1)
    {
        printf("pos err\n");
        return -1;
    }
    int i;
    while(pos--)
    {
        h = h->next;
    }
    printf("find %d\n",h->data);
    return h->data;
}


int main()
{
    L l1 = creat();
    show(l1);
    insert(l1,0,1);
    insert(l1,1,11);
    show(l1);
    insert(l1,2,22);
    insert(l1,3,33);
    show(l1);
    dellist(l1,2);
    show(l1);
    search(l1,1);
    return 0;
}





顺序表的基本操作：

#include<stdio.h>
#include<stdlib.h>
#define MAX 100
typedef struct Snode{
    int a[MAX];
    int len;
}snode,*sqlist;


sqlist creat(void)
{
    sqlist list = (sqlist)malloc(sizeof(snode));
    if(list == NULL)
    {
        printf("creat error\n");
        return NULL;
    }


    list->len = 0;
    return list;
}

int listisfull(sqlist l)
{
    return (l->len == MAX ? 1 : 0);
}


int getlen(sqlist l)
{
    return l->len;
}

int listisempty(sqlist l)
{
    if(l->len == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int insert(sqlist l,int pos ,int val)
{
    int len = l->len;
    if(len == MAX)
    {
        return -1;
    }
    if(pos < 0 || pos > len)
    {
        printf("pos error");
        return -1;
    }
    int i;
    for(i = len -1; i>=pos;i--)
    {
        l->a[i+1] = l->a[i];
    }
    l->a[pos] = val;
    l->len++;
    return 0;
}

int ChangeList(sqlist L,int pos,int val)
{
    int len = L->len;
    if(pos<0||pos>len-1){
        printf("pos error\n");
        return -1;
    }
    L->a[pos] = val;
    return 0;
}

int SearchList(sqlist L,int pos)
{
    int len = L->len;
    if(pos<0||pos>len-1){
        printf("pos error\n");
        return -1;
    }
    printf("find :%d\n",L->a[pos]);


    return L->a[pos];
    
}
int SearchListByVal(sqlist L,int val)
{
    int len = L->len;
    int i;
    for(i=0;i<len;i++){
        if(L->a[i]==val){
            printf("find pos:%d,val:%d\n",i,L->a[i]);
            return 0;
        }
    }
    
    printf("find nothing\n");
    return -1;
}
int ClearList(sqlist L)
{
    L->len=0;
}

void ShowList(sqlist L)
{
    int len = L->len;
    int i;
    for(i=0;i<len;i++){
        printf("%d,",L->a[i]);
    }
    printf("\n");
}

int DelList(sqlist L,int pos)
{
    int len = L->len;
    if(len==0){
        printf("list is empty\n");
        return -1;
    }
    if(pos<0||pos>len-1){
        printf("pos error\n");
        return -1;
    }

    int i;
    for(i=pos;i<len;i++){
        L->a[i]=L->a[i+1];
    }

    L->len--;
    return 0;
}

int main()
{
    return 0;
}



二叉树：

#include<stdio.h>
typedef struct node{
    int data;
    struct node *lchild;
    struct node *rchild;
}bt,*bitree;

bitree creat(void)
{
    bitree t = NULL;
    char c;
    scanf("%c",&c);
    if(c != '#')
    {
        t = malloc(sizeof(bt));
        t->data = c;
        t->lchild = creat();
        t->rchild = creat();
    }
    return t;
}

void qianxu(bitree t)
{
    if(t == NULL)
    {
        printf("the bitree is empty");
        return;
    }
    printf("%c,",t->data);
    qianxu(t->lchild);
    qianxu(t->rchild);
}
void zhongxu(bitree t)
{
    if(t == NULL)
    {
        printf("the bitree is empty");
        return;
    }
    qianxu(t->lchild);
    printf("%c,",t->data);
    qianxu(t->rchild);
}
void qianxu(bitree t)
{
    if(t == NULL)
    {
        printf("the bitree is empty");
        return;
    }
    qianxu(t->lchild);
    qianxu(t->rchild);
    printf("%c,",t->data);
}



typedef int data_t
struct node{
    data_t data;
    struct node *next;
};


链队：

linkqueue.h：

typedef int data_t
struct node{
    data_t data;
    struct node *next;
};

typedef struct node Lnode;
typedef struct node *linklist;

//将头尾指针包在一起
struct qnode{   
    linklist front;
    linklist rear;
};
typedef struct qnode Lqnode;
typedef struct qnode * linkqueue;

linkqueue CreateQueue();             //创建空队
int EmptyQueue(linkqueue LQ);        //判空
int ClearQueue(linkqueue Q);         //清空队
int GetLenth();                      //获取队列长度
int EnQueue(linkqueue LQ,data_t val);//入队
data_t DeQueue(linkqueue LQ);        //出队
void DestroyQueue();                 //销毁

linkqueue.c： 

#include <stdio.h>
#include <stdlib.h>
#include "linkqueue.h"

int EnQueue(linkqueue LQ,int val)
{
    if(EmptyQueue(LQ)){

        LQ->rear=LQ->front;
        //注意：如果是空队，注意修改尾指针指向

    }

    linklist s = malloc(sizeof(Lnode));  //生成一个新的节点
    s->data = val;                       

    s->next = NULL;                      //插入到末尾
    LQ->rear->next = s;

    LQ->rear = s;                        //修改尾指针
    return 0;

}
int EmptyQueue(linkqueue LQ)
{
    //没有有效数据，只剩头节点
    if(LQ->front->next==NULL){
        return 1;
    }
    else {
        return 0;
    }
}

int DeQueue(linkqueue LQ)
{
    if(EmptyQueue(LQ)){
        printf("queue is empty\n");
        return -1;
    }
    

    linklist d = LQ->front->next;  //记录删除节点位置
    int val = d->data;             //取值
    
    LQ->front->next  = d->next;    //删除
    free(d);                       //释放
    
    return val;
}
测试用的main.c 

#include <stdio.h>
#include "linkqueue.h"
#include <stdlib.h>

int main(void)
{

    linklist h = malloc(sizeof(Lnode));
    linklist s1= malloc(sizeof(Lnode));
    linklist s2= malloc(sizeof(Lnode));
    linklist s3= malloc(sizeof(Lnode));

    h->data = -1;
    s1->data = 11;
    s2->data = 22;
    s3->data = 33;

    h->next = s1; s1->next=s2; s2->next=s3; s3->next=NULL;
    

    linkqueue lq = malloc(sizeof(Lqnode));
    lq->front = h;
    lq->rear = s3;

    while(!EmptyQueue(lq)){
        printf("%d\n",DeQueue(lq));
    }

    EnQueue(lq,100);
    EnQueue(lq,200);
    EnQueue(lq,300);

    while(!EmptyQueue(lq)){
        printf("%d\n",DeQueue(lq));
    }

    return 0;
}


顺序队：

squeue.h：

#ifndef _SQUEUE_H
#define _SQUEUE_H

#define MAX 10

typedef int data_t;
struct node{
    data_t a[MAX];
    int front;
    int rear;
};
typedef struct node Sqnode;
typedef struct node * squeue;

squeue CreateQueue(void);                //创建
int EmptyQueue(squeue SQ);               //判空
int FullQueue(squeue SQ);                //判满
int EnQueue(squeue SQ,data_t val);       //入队
data_t DeQueue(squeue SQ);               //出队

#endif

squeue.c 

#include <stdio.h>
#include <stdlib.h>
#include "squeue.h"

squeue CreateQueue(void)
{
    squeue sq = malloc(sizeof(Sqnode));
    sq->front=sq->rear=0;

    return sq;
}

int EmptyQueue(squeue SQ)
{
    return (SQ->rear==SQ->front?1:0);
}

int FullQueue(squeue SQ)
{
    int rear  = SQ->rear;
    int front = SQ->front;

    if( (rear+1)%MAX == front ){
        return 1;
    }
    else{
        return 0;
    }
}
int EnQueue(squeue SQ,int val)
{
    if(FullQueue(SQ)){
        printf("queue is full\n");
        return -1;
    }
    SQ->rear=SQ->rear%MAX;

    SQ->a[SQ->rear] = val;

    SQ->rear++;

    return 0;
}
int DeQueue(squeue SQ)
{
    if(EmptyQueue(SQ)){
        printf("queue is empty\n");
        return -1;
    }
    
    SQ->front = SQ->front%MAX;
    int val = SQ->a[SQ->front];
    SQ->front++;
    return val;
}
main.c 

#include <stdio.h>
#include "squeue.h"
int main(void)
{
    squeue SQ = CreateQueue();

    EnQueue(SQ,11);
    EnQueue(SQ,22);
    EnQueue(SQ,33);

    while(!EmptyQueue(SQ)){
        printf("%d\n",DeQueue(SQ));
    }

    return 0;
}

链栈：

linkstack.h

#ifndef _LINKSTACK_H
#define _LINKSTACK_H


struct node{
    int data;
    struct node *next;
};
typedef struct node Lnode;
typedef struct node *linkstack;

linkstack CreateStack(void);           //创建
int GetStackLenth(linkstack S);        //栈的元素个数
int GetTop(linkstack S);               //取栈顶
int ClearStack(linkstack S);           //清空栈
int StackEmpty(linkstack S);           //判空
int PopStack(linkstack S);             //出栈
int PushStack(linkstack S,int val);    //入栈
void DestroyStack();                   //销毁

#endif
linkstack.c 
#include <stdio.h>
#include <stdlib.h>
#include "linkstack.h"
//创建一个空栈
linkstack CreateStack(void)
{
    linkstack top = malloc(sizeof(Lnode));
    top->data = -1;
    top->next = NULL;

    return top;
}

int PushStack(linkstack S,int val)
{
    //新节点
    linkstack x = malloc(sizeof(Lnode));
    x->data = val;

    //插入（先链后断）
    x->next = S->next;
    S->next = x;

    return 0;
}

int StackEmpty(linkstack S)
{
    if(S->next==NULL){
        return 1;
    }
    else {
        return 0;
    }
}


int PopStack(linkstack S)
{
    if(StackEmpty(S)){
        printf("stack is empty\n");
        return -1;
    }

    linkstack d = S->next;  //记录删除位置
    int val = d->data;      //取值
    
    S->next = d->next;      //删除 

    free(d);                //释放

    return val;
}
main.c 

#include <stdio.h>
#include "linkstack.h"

int main(void)
{
    linkstack mystack = CreateStack();
    
    PushStack(mystack,123);
    PushStack(mystack,456);
    PushStack(mystack,500);


    while(!StackEmpty(mystack)){
        printf("%d\n",PopStack(mystack));
    }
    
    PushStack(mystack,100);
    PushStack(mystack,200);
    PushStack(mystack,300);
    
    while(!StackEmpty(mystack)){
        printf("%d\n",PopStack(mystack));
    }
    return 0;
}


顺序栈：

sstack.h

typedef int data_t;
struct snode{
    data_t a[MAX];
    int top; //记录栈顶元素下标
};
typedef struct snode Snode;
typedef struct snode * stack;

stack CreateStack(void);          //创建空栈
int StackIsFull(stack S);         //判空
int PushStack(stack S,data_t val);//压栈
int StackIsEmpty(stack S);        //判满
data_t PopStack(stack S);         //弹栈

/*自己实现*/
int ClearStack(stack S);        //清空栈
int GetTop(stack S);            //获取栈顶
int GetStackLenth(stack S);     //获取栈的元素个数
int ShowStack(stack S);         //打印栈
int DestroyStack(stack S);      //销毁栈

#endif

stack.c

#include <stdio.h>
#include <stdlib.h>
#include "sstack.h"
stack CreateStack(void)
{
    stack  s = malloc(sizeof(Snode));
    s->top = -1;  //创建空栈

    return s;
}

int StackIsFull(stack S)
{
    if (S->top == MAX-1){
        return 1;
    }
    else {
        return 0;
    }
}

int PushStack(stack S,int val)
{
    if(StackIsFull(S)){
        printf("stack is full\n");
        return -1;
    }
    S->top++;
    S->a[S->top] = val;

}

int StackIsEmpty(stack S)
{
    if(S->top==-1){
        return 1;
    }
    else {
        return 0;
    }
}

int PopStack(stack S)
{
    if(StackIsEmpty(S)){
        printf("stack is empty\n");
        return -1;
    }

    int val = S->a[S->top];
    S->top--;
    return val;
}
int ClearStack(stack S)
{
    S->top=-1;
}
int GetTop(stack S)
{
    if(StackIsEmpty(S)){
        printf("stack is empty\n");
        return -1;
    }
    return S->a[S->top];
}
int GetStackLenth(stack S)
{
    return (S->top+1);
}
int ShowStack(stack S)
{
    int i;
    int len = GetStackLenth(S);

    for(i=0;i<len;i++){
        printf("%d,",S->a[i]);
    }
    printf("\n");
}
int DestroyStack(stack S)
{
    free(S);
}


main.c

#include <stdio.h>
#include <stdlib.h>
#include "sstack.h"

int main(void)
{

    stack mystack = CreateStack();

#if 0
    int n;
    scanf("%d",&n);
    
    while(n){

        PushStack(mystack,n%2);
        n = n/2;
    }

    while(!StackIsEmpty(mystack)){
        printf("%d",PopStack(mystack));
    }
    printf("\n");
#endif 

    PushStack(mystack,11);
    PushStack(mystack,22);
    PushStack(mystack,33);

    printf("%d\n",GetTop(mystack));
    printf("%d\n",GetStackLenth(mystack));

    ClearStack(mystack);

    ShowStack(mystack);

    /*
    while(!StackIsEmpty(mystack)){
        printf("pop:%d\n",PopStack(mystack));
    }
    */
    return 0;
}


双向链表的基本操作； 

 //链表的结构
  5 typedef struct doubleLink
  6 {
  7     int data;
  8     struct doubleLink *pre;
  9     struct doubleLink *next;
 10 }dnode;
 11 
 12 //创建链表
 13 dnode* Creatdlink()
 14 {
 15     dnode* head;
 16     dnode* p;
 17     dnode* pnext;
 18     int temp;
 19     head = (dnode*)malloc(sizeof(dnode));
 20     head->pre = NULL;
 21     head->next = NULL;
 22     p = head;
 23     printf("请输入数据:");
 24     while (scanf("%d", &temp)!=EOF)
 25     {
 26         pnext = (dnode*)malloc(sizeof(dnode));
 27         pnext->data = temp;
 28         p->next = pnext;
 29         pnext->pre = p;
 30         pnext->next = NULL;
 31         p = pnext;
 32     }
 33     return head;
 34 }
 35 
 36 //插入结点
 37 dnode* insertdnode(dnode* head, int pos, int i)
 38 {
 39     int temp;
 40     dnode* prev;
 41     dnode* p;
 42     prev = head;
 43     for (temp = 0; temp < pos - 1; temp++)
 44         prev = prev->next;
 45     p = (dnode*)malloc(sizeof(dnode));
 46     p->data = i;
 47     p->pre = prev;
 48     p->next = prev->next;                                                                                     
 49     prev->next = p;
 50     prev->next->pre = p;
 51     return head;
 52 }
 53 
 54 //删除结点
 55 dnode* deletednode(dnode* head, int i)
 56 {
 57     dnode* p;
 58     p = head;
 59     while (p != NULL)
 60     {
 61         if (p->data == i)
 62         {
 63             p->pre->next = p->next;
 64             p->next->pre = p->pre;
 65             free(p);
 66             return head;
 67         }
 68         p = p->next;
 69     }
 70     printf("data is not found\n");
 71     return head;
 72 }

链表反向

void reverse(test* head)

{

test* pe = head;

test* ps = head->next;

while(ps)

{

pe->next = ps->next;

ps->next = head; 

head = ps; 

ps = pe->next;

}

}



wp1027322856
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树遍历顺序栈实现
11-29
自己真正实现的 完整的代码 二叉树的实验代码 看别人写没有用 还得自己写 写出了就会了
c c++ 顺序表 链表 队 栈 树类模板实现 以及例子
01-27
在本主题中，我们将深入探讨几种重要的数据结构及其在C/C++中的实现：顺序表、链表、队列、栈和树。这些数据结构不仅在算法设计中扮演着关键角色，而且在实际应用如操作系统、数据库、网络编程等领域也有广泛的应用...
数据结构的顺序栈、链式栈、链队列、循环队列的实现
love_786的博客
07-19 669
如何实现栈和队的操作
二叉数顺序栈
MChuajian的博客
11-07 336
第五章  树和二叉树翻转学习任务       一、本章的重点 分二大部分：树和二叉树。       从逻辑结构上分，树是表示一对多和一种结构，一般用于表达祖先后代、上下级和整合部分等相关关系。        本章学习，在前面的线性表相关的基础上，进一步复杂的数据结构。掌握具体层次对象的数据结构表达和存储方法，以及操作方法。了解树特别是二叉树的广泛应用。 二、学习目标
数据结构（链表-链栈-二叉排序树BST-平衡二叉树AVL-红黑树-B树）(C++)
wuerfang的博客
06-08 521
几种数据结构：链表、链栈、二叉树（C++）引言线性链表链栈二叉树二叉排序树平衡二叉树(`AVL树`) 引言 本文的主要内容为线性链表、链栈、二叉排序树、平衡二叉树等几种数据及C++实现，主要参考了李长河主编的《C++程序设计》教材，其中线性链表、链栈、二叉排序树的代码可从该主编的GitHub上的第8.3节处获取。 本文记录如有错误，万望指正。笔者的邮箱为：wuxiaofang555555@163.com 。本文的代码亦可以从笔者的GitHub上获取. 线性链表 线性链表 也称为单链表（singly
顺序队列基础操作
Misty_Rain_的博客
12-07 339
顺序队列基础操作 环境及程序说明 /* 环境：Dev C++ TDM-GCC 4.9.2 64-bit Profiling 输出大小: 1.85951137542725 MiB 编译时间: 1.72s 顺序队列操作（使用模板） 包括队列的插入、删除、访问队首、清空、判断是否为空或者满 */ 头文件 #include<iostream> using nam...
数据结构实验源码+顺序表的基本操作C++语言
05-03
相比于顺序表，链表插入和删除操作更灵活，因为不需要移动元素，只需要改变指针。但访问链表中的元素不如顺序表快，需要从头开始遍历。单链表的操作有创建、插入、删除、查找和打印链表。 接着，我们讨论**树**这种...
使用C++链表实现二叉树的存储及基本操作
10-06
本项目通过结合链表的基本操作来实现二叉树的存储，以及包括前序、中序、后序遍历在内的各种基本操作。以下是关于这个主题的详细讲解。 首先，我们需要理解二叉树的基本概念。二叉树是由节点（或称为顶点）构成的...
c编写的数据结构创建顺序表、链表、栈、队列、树的代码
05-29
创建顺序表通常涉及动态数组，通过malloc或calloc函数分配内存。可以实现插入、删除和查找等操作。在C语言中，需要关注数组的大小和动态扩展。 2. **链表（Lianbiao.c）**： 链表是一种非连续的内存空间数据结构，...
用二叉链表实现二叉树的基本操作.pdf
11-25
"用二叉链表实现二叉树的基本操作.pdf" 本资源为一份关于使用二叉链表实现二叉树的基本操作的教程，包括构造、遍历等基本操作。文中提供了C++代码，展示了如何使用二叉链表实现二叉树的基本操作，包括先序遍历、...
顺序队列(循环队列)的常用操作(C语言)
10-19
C语言实现顺序队列（循环队列）的常用操作，包括初始化顺序队，创建顺序队，入队，出队，计算队的长度，清空队列等等
以单链表为存储结构，对多个班级的学生成绩进行操作
05-13
*****文件输入方式******用C语言编写程序，以单链表为存储结构，对多个班级（以两个班为例）的学生成绩进行管理，要求实现如下功能： （1）通过终端或文件输入若干学生的班级号、学号、成绩，将每个班的数据分别保存在不同的单链表中，数据元素按成绩由高到低的顺序存放；然后分别按顺序（由高到低）输出各班的成绩表。 （2）输入班级、学号和成绩变更（如+5，-3），对各班至少1人的成绩进行修正，修正后仍要保持数据按成绩由高到低有序；然后分别按顺序输出各班的成绩表。 （3）分别输出各班的总人数、最高分、最低分、平均分。
数据结构的几个程序顺序栈，链式栈，顺序队，链式队，排序
12-02
这是一个关于数据结构的几个程序，有顺序栈，链式栈，顺序队，链式队，排序
单链表，队列，链队，链栈，排序，顺序表，顺序栈算法实现.zip
03-26
里面7个文件夹，分别是单链表，队列，链队，链栈，排序，顺序表，顺序栈。都实现了插入删除查找等操作，c++代码，可以直接运行。
顺序队列和链式队列的实现
11-08
顺序队列和链式队列的实现
数据结构课程实验->迷宫->分别用链栈，链队，顺序栈，顺序队实现。
Logan
10-30 752
迷宫     实现老鼠走迷宫程序。     功能要求：①输出每一步尝试的状态，直到走完迷宫或无法走通②在迷宫有解的前提下，输出从起点到终点的最短通路。     设计要求：迷宫至少10×10；起点和终点可自定义，也可固定；迷宫可随机生成，也可固定，可以无解；两个功能可用不同算法和程序实现；输出可以是图形界面，也可以是文本界面（如下例）。 # # # # # # # # # # # 0 # # 0 0...
C语言实现链队基本操作
Zhangjf的博客
05-11 329
C语言实现链队基本操作（以简单排队问题为例） 通过调用简单函数实现顺序表的相关操作。代码编译环境为VS2019 16.9.4。因为VS的某些原因，scanf写为了scanf_s，作用是一样的，在其他编译环境中可将scanf_s改回去。 建议运行后体验： #include<stdio.h> //输入输出头文件 #include<stdlib.h> //标准头文件 #include<stdbool.h> //布尔类型头文件 typedef long long int Ele
数据结构（链式二叉树及快速排序的算法实现）
水里的鱼
05-21 624
链式二叉树的算法实现 算法实现的目标：动态构造一个链式二叉树、并且用先序、中序、后序遍历这个链式二叉树。 一个结点包括三个部分：左孩子的指针域、数据域、右孩子的指针域。 所以创建链式二叉树的步骤为：把左指针域指向他的左孩子，右指针域指向他的右孩子。 # include <stdio.h> # include <stdlib.h> typedef struct BTNod...
数据结构学习笔记-链表，链栈，链式队列
04-02 120
这是最近学习过的数据结构的一些基本线性存储方式， 整理一下笔记，其中双链表和循环list等操作，思想类似，就不做整理了 //链表操作 #include<iostream> using namespace std; template <class T> struct Node //节点设置 { T data; //节点存储的元素
据顺序存储结构建立二叉树二叉链表代码
最新发布
04-27
据顺序存储结构建立二叉树的二叉链表代码如下： ```cpp #include using namespace std; // 二叉树结点定义 struct TreeNode { int data; TreeNode* left; TreeNode* right; }; // 根据顺序存储结构建立二叉树...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值