C语言之常用数据结构

最新推荐文章于 2024-05-16 22:00:46 发布
最新推荐文章于 2024-05-16 22:00:46 发布
阅读量2.5k 收藏 43
点赞数 5
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/znufe_newer/article/details/104965977
版权

目录

 

一、顺序表

二、单链表

三、双向链表

三、顺序栈

四、循环队列

五、二叉树

一、顺序表

顺序表是线性表的顺序存储，通过一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。假定线性表的元素类型为ElemType，则线性表的顺序存储类型描述为：

    //静态分配
    #define MaxSize 50
    typedef int ElemType;
    typedef struct{
	    ElemType data[MaxSize];
	    int length;
    }SqList;

C语言中一维数组可以进行动态分配避免溢出；

（1）插入操作

    bool ListInsert(SqList &L,int i,ElemType e){
        //在顺序表L的第i（1<=i<=L.length+1）个位置插入新元素e
	    if(i<1 || i>L.length+1)
	    	return false;
	    if(L.length>=MaxSize)
		    return false;
	    for(int j=L.length;j>=i;j--)            //将第i个元素及之后的元素后移
		    L.data[j]=L.data[j-1];
	    L.data[i-1]=e;
	    L.length++;
	    return true;
    }

（2）删除操作

    bool ListDelete(SqList &L,int i, ElemType &e){
    //删除顺序表L中第i个未知的元素
	if(i<1 || i>L.length)
		return false;
	e=L.data[i-1];
	for(int j=i;j<L.length;j++)
		L.data[j-1]=L.data[j];
	L.length--;
	return true;
    }

（3）按值查找

    bool LocateElem(SqList &L,ElemType e){
    //查找顺序表中值为e的元素，查找成功则返回元素位置，否则返回0
	int i;
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
	return 0;
    }

 

二、单链表

单链表是线性表的链式存储，通过一组任意的储存单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表节点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。单链表中的节点类型如下：

    typedef struct LinkNode{
        ElemType data;
        struct LinkNode *next;
    }LinkNode, *LinkList;

通常用头指针来标识一个单链表，此外为了操作上的方便，在单链表第一个节点之前附加一个结点，称为头结点。

（1）建立单链表

    LinkList CreatList1(LinkList &L){ 
    //头插法建立单链表
	LNode *s;int x;
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf("%d",&x);
	}
	return L;
    } 

    LinkList CreatList2(LinkList &L){
    //尾插法建立单链表
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	LNode *s,*r=L;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;
		scanf("%d",&x);
	}
	r->next=NULL;
	return L;
    }

（2）按序号查找节点值

    LNode *GetElem(LinkList L,int i){
    //取出单链表L（带头节点）中第i个位置的结点指针
	    int j=1;
	    LNode *p=L->next;
	    if(i==0)
		    return L;
	    if(i<1)
		return NULL;
	    while(p&&j<i){
		    p=p->next;
		    j++;
	    }
	    return p;
    }

（3）按值查找表结点

    LNode *LocateElem(LinkList L,ElemType e){
    //查找单链表L（带头结点）中数据值等于e的结点指针，否则返回NULL
	    LNode *p=L->next;
	    while(p!=NULL&&p->data!=e)
		    p=p->next;
	    return p;
    }

（4）插入结点

    bool ListFrontInsert(LinkList L,int i,ElemType e){
    //将值为x的新节点插入到单链表的第i个位置桑
	LinkList p=GetElem(L,i-1);
	    if(NULL==p){
		    return false;
	    }
	    LinkList s=(LNode*)malloc(sizeof(LNode));
	    s->data=e;
	    s->next=p->next;
	    p->next=s;
	    return true;
    }

三、双向链表

双向链表在单链表的基础上增加了一个指向其前驱的prior指针，结点类型及相关函数描述如下：

    typedef int ElemType;
    typedef struct DNode{
	    ElemType data;
	    struct DNode *prior,*next;
    }DNode,*DLinkList;

    DLinkList Dlist_head_insert(DLinkList &DL){ 
    //头插法
	DNode *s;int x;
	DL=(DLinkList)malloc(sizeof(DNode));
	DL->next=NULL;
	DL->prior=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(DNode*)malloc(sizeof(DNode));
		s->data=x;
		s->next=DL->next;
		if(DL->next!=NULL){
			DL->next->prior=s;
		}
		s->prior=DL;
		DL->next=s;
		scanf("%d",&x);
	}
	return DL;
    } 

    DLinkList Dlist_tail_insert(DLinkList &DL){
    //尾插法
	int x;
	DL=(DLinkList)malloc(sizeof(DNode));
	DNode *s,*r=DL;
	DL->prior=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(DNode*)malloc(sizeof(DNode));
		s->data=x;
		r->next=s;
		s->prior=r;
		r=s;
		scanf("%d",&x);
	}
	r->next=NULL;
	return DL;
    } 

    DNode *GetElem(DLinkList DL,int i){
    //返回第i个位置的结点指针
	int j=1;
	DNode *p=DL->next;
	if(i==0)
		return DL;
	if(i<1)
		return NULL;
	while(p&&j<i){
		p=p->next;
		j++;
	}
	return p;
    }
    
    bool DListFrontInsert(DLinkList DL,int i,ElemType e){
    //插入结点
	DLinkList p=GetElem(DL,i-1);
	if(NULL==p){
		return false;
	}
	DLinkList s=(DNode*)malloc(sizeof(DNode));
	s->data=e;
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;
	p->next=s;
	return true;
    }
    
    bool DListDelete(DLinkList DL,int i){
    //删除第i个结点
	DLinkList p=GetElem(DL,i-1);
	if(NULL==p){
		return false;
	}
	DLinkList q;
	q=p->next;
	if(q==NULL)
		return false;
	p->next=q->next;
	if(q->next!=NULL){ //删除最后一个元素，需要的判断 
		q->next->prior=p;
	}
	free(q);
	return true;
    }

三、顺序栈

顺序栈是采用顺序存储的栈，它利用一组地址连续的储存单元存放自栈底到栈顶的数据元素，同时设一个指针top指示当前栈顶位置。

    //实现栈 可以用数组，也可以用链表 
    #define MaxSize 50
    typedef int ElemType;
    typedef struct {
        ElemType data[MaxSize];
        int top;
    }SqStack;
    
    typedef struct LinkNode{
        ElemType data;
        struct LinkNode *next;
    }*LiStack;

    void InitStack(SqStack &S){
    //初始化
	S.top=-1;
    }

    bool StackEmpty(SqStack &S){
    //栈判空
	if(S.top==-1)
		return true;
	else
		return false;
    }

    bool Push(SqStack &S,ElemType x){
    //进栈
	if(S.top==MaxSize-1){
		return false;
	}
	S.data[++S.top]=x;
	return true;
    }

    bool Pop(SqStack &S,ElemType &x){
    //出栈
	if(-1==S.top)
		return false;
	x=S.data[S.top--];
	return true;
    }

    bool GetTop(SqStack &S,ElemType &x){
    //读取栈顶元素
	if(-1==S.top)
		return false;
	x=S.data[S.top];
	return true;
    }

四、循环队列

循环队列是将顺序队列臆造为一个环状空间，即把存储队列元素的表从逻辑上视为一个环，称为循环队列。

顺序队列结点类型描述如下：

    //队列可以用数组也可用链表实现 
    #define MaxSize 5
    typedef int ElemType;
    typedef struct{
	    ElemType data[MaxSize];
	    int front,rear;
    }SqQueue;

    void InitQueue(SqQueue &Q) {
    //初始化
	    Q.rear=Q.front=0;
    }

    bool isEmpty(SqQueue &Q) {
    //判队空
	    if(Q.rear==Q.front)
		    return true;
	    else	
		    return false;
    } 

    bool EnQueue(SqQueue &Q,ElemType x){
    //入队
	    if((Q.rear+1)%MaxSize==Q.front)
		    return false;
	    Q.data[Q.rear]=x;
	    Q.rear=(Q.rear+1)%MaxSize;
	    return true;
    }

    bool DeQueue(SqQueue &Q,ElemType &x){
    //出队
	    if(Q.rear==Q.front)
		    return false;
	    x=Q.data[Q.front];
	    Q.front=(Q.front+1)%MaxSize; 
	    return true;
}

链式队列描述如下：

    typedef int ElemType;
    typedef struct LinkNode{
	    ElemType data;
	    struct LinkNode *next;
    }LinkNode;
    typedef struct{
	    LinkNode *front,*rear;
    }LinkQueue;
      
    void InitQueue(LinkQueue &Q){
    //初始化
	    Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
	    Q.front->next=NULL; 
    }

    bool IsEmpty(LinkQueue &Q){
    //判队空
	    if(Q.front==Q.rear)
		    return true;
	    else
		    return false;
    }

    void EnQueue(LinkQueue &Q,ElemType x){
    //入队
	    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	    s->data=x;s->next=NULL;
	    Q.rear->next=s;
	    Q.rear=s;
    }

    bool DeQueue(LinkQueue &Q,ElemType &x){
    //出队
	    if(Q.front==Q.rear) return false;
	    LinkNode *p=Q.front->next;
	    x=p->data;
	    Q.front->next=p->next;
	    if(Q.rear==p)
		    Q.rear=Q.front;
	    free(p);
	    return true;
    }

五、二叉树

     //链式存储
     typedef struct BiNode
     {
         char data;
         struct BiTNode *lchild,*rchild;
      }BiNode,*BiTree;
     //前中后序遍历
    void Inorder(BiTree T){
        if(T == NULL) return ;
        Inorder(T->lchild);
        // visit(T->data);
        printf("%c ", T->data);
        Inorder(T->rchild);
    }

    void preorder(BiTree T){
        if(T == NULL) return ;
        // visit(T->data);
        printf("%c ", T->data);
        Inorder(T->lchild);
        Inorder(T->rchild);
    }

    void postorder(BiTree T){
        if(T == NULL) return ;
        Inorder(T->lchild);
        Inorder(T->rchild);
        // visit(T->data);
        printf("%c ", T->data);
    }    
    //层次遍历
    void leverorder(BiTree BT){
        InitQueue(Q);
        BiTree P;
        EnQueue(Q,BT);
        while(!IsEmpty(Q){
            DeQueue(Q,P);
            visit(P);
            if(p->lchild!=NULL)
                EnQueue(Q,p->lchild);
            if(p->rchild!=NULL)
                EnQueue(Q,p->rchild);
            }
        }   
    }
    //非递归
    void inorder(BiTree T){
        InitStack(S);
        BiNode *p = T;
        while(!StackEmpty(S) || p){
            if(!p) {
                Push(S, p);
                p = p->lchild;
            }else {
                Pop(S, p);
                printf("%c ", p->data);
                p = p->rchild;
            }
        }
    }

    void postorder(BiTree T){
        InitStack(S);
        BiNode *p = T, *last = NULL;
    while(!StackEmpty(S) || p){
        if(p){
            Push(S, p);
            p = p->lchild;
            }
            else {
                GetTop(S, p);
                if(p->rchild && p == last){ // 向右子树 递归
                    Pop(S, p);
                    printf("%c ", p->data);
                    last = p;
                    p = NULL;
                }else {
                    p = p->rchild;
                }
            }
        }
    }

 

zuel_newer
关注
  • 5
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构
m0_60377292的博客
10-18 142
逆向工程（Reverse engineering）是一种技术过程，即对一项目标产品进行逆向分析及研究，从而演绎并得出该产品的处理流程、组织结构、功能性能规格等设计要素，以制作出功能相近但不完全一样的产品的过程。在CTF中，逆向工程一般是指软件逆向工程，即对已经编译完成的可执行文件进行分析，研究程序的行为和算法，然后以此为依据，计算出出题人想隐藏的flag。 ...
C语言中常用的数据结构
2301_76510320的博客
05-25 4151
链表是一种动态的数据结构，它由一系列结点组成，每个结点包含数据和指向下一个结点的指针。树是一种由一组结点和一组连接这些结点的边组成的数据结构，每个结点有一个父结点和零个或多个子结点。图是一种由一组结点和一组连接这些结点的边组成的数据结构，每个结点可以有零个或多个相邻结点。树（Tree）：由一组结点和一组连接这些结点的边组成的数据结构，每个结点有一个父结点和零个或多个子结点。图（Graph）：由一组结点和一组连接这些结点的边组成的数据结构，每个结点可以有零个或多个相邻结点。
c++数据结构中 顺序队列的队首队尾_C语言动态数据结构
weixin_39728221的博客
11-24 588
分配内存空间函数malloc分配内存空间函数calloc释放内存空间函数free函数名：malloc函数功能：是在内存的动态存储区中分配一块确定长度的连续空间函数原型：void * malloc(long NumBytes)该函数分配了长度为NumBytes个字节的内存区域，并返回指向这块内存的指针。返回类型为void类型，因此需要在返回时对其进行强制类型转换，转换为需要的类型。如果分...
数据结构（C语言版）
2301_78561643的博客
05-16 1925
线性结构的特点是：在数据元素的非空有限集中，存在唯一的一个被称为“第一个”的数据元素存在唯一的一个被称为“最后一个”的数据元素除第一个外，集合中的每个元素均只有一个前驱除最后一个外，集合中的每个元素均只有一个后继线性表：最常用且最简单的一种数据结构，即一个线性表是n个数据元素的有限序列在稍复杂的线性表中，一个数据元素可以由若干个数据项组成，在这种情况下，数据元素被称为记录，含有大量记录的线性表又称为文件同一线性表中的元素必定由相同的特性，即属于同一数据对象，相邻数据元素之间存在着序偶关系。
c语言数据结构
RONG_YAO的博客
07-25 1万+
一、数据结构构造概述 1.1、什么是数据结构 数据结构是计算机存储，管理数据的方式。数据必须依据某种逻辑联系组织在一起存储在计算机内，数据结构研究的就是这种数据的存储结构和数据的逻辑结构。 二、线性表 三、栈和队列 四、二叉树 五、查找方法 六、排序方法 ...
C语言数据结构知识点小结(全）
Shen Mu Xin's Blog
07-14 3万+
C语言数据结构小结，B站青岛大学-王卓授课笔记
数据结构（C语言版本）
热门推荐
conanswp的专栏
04-22 14万+
数据结构（C语言版本） 第1章 绪论 1.常用的数据结构类型：集合、线性、树形、图状。 2.数据结构： - 逻辑结构：数据元素之间的关系 - 存储结构：数据结构在计算机中的表示。存储结构分为：顺序存储结构和链式存储结构。 3.算法是对特定问题求解步骤的一种描述，算法具有如下特性：有穷性、确定性、可行性、输入、输出。 4.算法的度量： - 时间复杂度 - 空间复杂度 ...
常用数据结构 - C语言实现
最新发布
06-18
数据结构 NOTONLLY的SBT模板.cpp NOTONLLY的划分树模板.cpp NOTONLLY的后缀数组模板.cpp RMQ-ST算法.cpp RMQ线段树.cpp SBT.cpp SBT2.cpp splay伸展树.cpp ST表.cpp Treap.cpp Trie树.cpp 二叉堆.cpp 二维线段树.cpp...
常用数据结构C语言源码
03-21
这个"常用数据结构C语言源码"的压缩包包含了多个章节，每个章节都涉及一个特定的数据结构或算法，让我们一一解析。 1. **第2章：算法** 算法是解决问题或执行任务的明确步骤。在这一章中，你可能会找到一些基础...
C语言实现常用的数据结构.rar
04-22
“线性表”是基本的数据结构之一，可以看作是一组按特定顺序排列的元素集合。在C语言中，通常使用数组或链表来实现线性表。 “循环队列”是队列的变体，它的队尾在达到数组末尾后会回到数组开头，形成一个循环。...
C语言基础学习常用数据结构和算法
12-31
包括但不限于 https://blog.csdn.net/qq_42464569/article/details/109785657 目录中的所有代码，有基础数据结构的实现，简单的树、图算法，基本排序算法和查找相关算法
C语言数据结构代码-包含所有常用数据结构实现方式
12-02
本压缩包"**C语言数据结构代码-包含所有常用数据结构实现方式**"提供了C语言实现的各种常见数据结构和算法，这对于学习和理解数据结构以及提升编程技能非常有帮助。 1. **线性表**: 线性表是最基本的数据结构之一，...
数据结构-C语言
weixin_52972575的博客
12-08 2302
字符串 串的简介 在串的操作中，通常以“串的整体”作为操作对象，如在串中查找某个字串，在串中某个位置插入一个子串，删除一个子串等。 串的存储结构 顺序存储（用的多） 静态定义字符串 //静态定义字符串，在编译时刻就确定了串的大小 #include<stdio.h> #define MAXLEN 255 //串的最大长度 typedef struct{ char ch[MAXLEN+1]; //存储串的一维数组 int length; //串的当前长度
c语言八大数据结构有哪些,C语言中都有哪些常见的数据结构你都知道几个？？...
weixin_35976993的博客
05-18 1882
上次在面试时被面试官问到学了哪些数据结构，那时简单答了栈、队列/(ㄒoㄒ)/~~其它就都想不起来了，今天有空整理了一下几种常见的数据结构，原来我们学过的数据结构有这么多~首先，先来回顾下C语言中常见的基本数据类型吧O(∩_∩)OC语言的基本数据类型有：整型int，浮点型float，字符型char等等添加描述那么，究竟什么是数据结构呢？数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一...
深入浅出C语言——数据结构概念
weixin_55051736的博客
08-31 1813
数据结构（英语：data structure）是计算机中存储、组织数据的方式。数据结构是一种具有一定逻辑关系，在计算机中应用某种存储结构，并且封装了相应操作的数据元素集合。它包含三方面的内容，逻辑关系、存储关系及操作。随着应用程序变得越来越复杂和数据越来越丰富，几百万、几十亿甚至几百亿的数据就会出现，而对这么大对数据进行搜索、插入或者排序等的操作就越来越慢，数据结构就是用来解决这些问题的。......
C语言-数据结构
2201_75441920的博客
04-18 1757
数据结构简单介绍
数据结构基础知识
m0_59200231的博客
08-06 297
数据结构的基础知识
详细阐述C语言常用的数据结构
04-13
C语言常用的数据结构包括数组、链表、栈、队列、树和图等。其中，数组是一组相同类型的数据元素的集合，可以通过下标访问，是最基本的数据结构。链表是一种动态数据结构，其中每个节点包含数据和指向下一个节点的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值