精华内容
下载资源
问答
  • 0x01.线性表 C数据结构与算法-基础整理-线性表-01:顺序表操作集 C数据结构与算法-基础整理-...C数据结构与算法-基础整理-栈和队列-01:栈基础操作 C数据结构与算法-基础整理-栈和队列-02:队列基础操作 ...

    包含所有基于C语言的数据结构基础知识总结的博客。

    0x01.线性表

    C数据结构与算法-基础整理-线性表-01:顺序表操作集

    C数据结构与算法-基础整理-线性表-02:双向链表操作集

    C数据结构与算法-基础整理-线性表-03:循环链表解决约瑟夫环

    C数据结构与算法-基础整理-线性表-04:静态链表

    0x02.栈和队列

    C数据结构与算法-基础整理-栈和队列-01:栈的基础操作

    C数据结构与算法-基础整理-栈和队列-02:队列的基础操作

    C数据结构与算法-栈应用-01:判断括号匹配问题

    C数据结构与算法-栈应用-02:逆波兰算法

    0x03.树

    C数据结构与算法-基础整理-树-01:树的相关术语性质整理

    C数据结构与算法-基础整理-树-02:二叉树的建立及四种遍历方式

    C数据结构与算法-基础整理-树-03:图解-通过前序遍历对递归执行原理的深入理解

    C数据结构与算法-基础整理-树-04:图解-树的中序遍历

    C数据结构与算法-基础整理-树-05:图解-树的后序遍历

    C数据结构与算法-基础整理-树-06:线索二叉树(一)

    C数据结构与算法-基础整理-树-07:线索二叉树(二)

    C数据结构与算法-基础整理-树-08:二叉排序树

    C数据结构与算法-基础整理-树-09:平衡二叉树(AVL树)

    C数据结构与算法-基础整理-树-10:赫夫曼树

    0x04.图

    C数据结构与算法-基础整理-图-01:图的相关术语整理集合

    C数据结构与算法-基础整理-图-02:图的最常见的两种创建方式

    C数据结构与算法-基础整理-图-03:十字链表,邻接多重表

    C数据结构与算法-基础整理-图-04:深度优先搜索和广度优先

    C数据结构与算法-基础整理-图-05:普里姆算法详解

    C数据结构与算法-基础整理-图-06:克鲁斯卡尔算法详解

    C数据结构与算法-基础整理-图-07:详解迪杰斯特拉算法

    C数据结构与算法-基础整理-图-08:详解弗洛伊德算法

    C数据结构与算法-基础整理-图-09:拓扑排序和关键路径

    0x05.查找

    C数据结构与算法-基础整理-查找-01:有序表的三种查找

    C数据结构与算法-基础整理-查找-02:哈希表的理解

    0x06.排序

    C数据结构与算法-基础整理-排序-01:三种简单排序算法

    C数据结构与算法-基础整理-排序-02:希尔排序

    C数据结构与算法-基础整理-排序-03:堆排序

    C数据结构与算法-基础整理-排序-04:归并排序

    C数据结构与算法-基础整理-排序-05:快速排序

    C数据结构与算法-基础整理-排序-06:七种经典排序算法的比较

    0x07.经典算法

    C数据结构与算法-经典算法-01:KMP模式匹配算法详解

    展开全文
  • 引用标志符(&)在C里不支持,那应该怎么改才能在c里使用Status InitList_Sq( SqList &L )
  • 关于c语言的数据结构----图(一)

    千次阅读 2018-06-14 20:51:59
    最近做了一些数据结构有关图习题,就在这里说一下自己做题 以及走弯路吧。 其中有几道比较经典比如在一个有向图邻接表存储结构上,算出这个图入度和出度。下面是输入输出: 输入: 6 6 A B C D E F ...

    最近做了一些数据结构有关图的习题,就在这里说一下自己做的题 以及走的弯路吧。

    其中有几道比较经典的比如在一个有向图邻接表的存储结构上,算出这个图的入度和出度。下面是输入输出:

    输入:
    6 6
    A B C D E F
    A B
    A C
    B D
    C D
    D E
    C F
    输出:
    A 0 2 2
    B 1 1 2
    C 1 2 3
    D 2 1 3
    E 1 0 1
    F 1 0 1

    其实写过的同学应该觉得很简单,但是也有很多人一头雾水,会觉得什么是邻接表,出入度又怎么实现。

    其实邻接表很简单,就是将一个数组里存入图中有的顶点,然后每个数组元素又是一个链表,链着以它为起点,以其他点为终点的那个终点顶点。而在创建有向图和无向图时要注意,有向图有起点终点,而无向图没有,所以创建时两个端点都要连接。下面是邻接表的结构图:

    这里写图片描述

    知道了邻接表就可以开始干活了,至于连出度入度是什么都不知道的童鞋,可以百度一下,在此就不多赘述了。

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    
    using namespace std;
    #define MAX_VERTEX_NUM  20
    
    typedef struct ArcNode
    {
        int  adjvex;
        ArcNode *nextarc;
    
    } ArcNode;
    
    typedef struct Vnode
    {
        char data;
        int in;
        int out;
        ArcNode * firstarc;
    } Vnode, AdjList[MAX_VERTEX_NUM];
    
    
    typedef struct
    {
        AdjList  vertices;
        int  vexnum, arcnum;
    
    } ALGraph;
    

    先建一个连接表,然后将创建和输出的函数实现。

    void CreatALGraph(ALGraph *G)
    {
        int i,j,k,weight;
        char q,p;
        ArcNode *s;
    
        cin>>G->vexnum>>G->arcnum;
    
        for(i=0; i<G->vexnum; i++)
        {
            cin>>G->vertices[i].data;
            G->vertices[i].in = 0;
            G->vertices[i].out = 0;
            G->vertices[i].firstarc=NULL;
        }
    
        for(k=0; k<G->arcnum; k++)
        {
            cin>>q>>p;
            i = q-'A';
            j = p-'A';
            G->vertices[j].in++;
            G->vertices[i].out++;
            s=(ArcNode*)malloc(sizeof(ArcNode));
            s->adjvex=j;
            s->nextarc=G->vertices[i].firstarc;
            G->vertices[i].firstarc=s;
        }
    }
    
    void outALGraph(ALGraph *G)
    {
        int i,sum=0;
    
        for(i = 0; i<G->vexnum; i++)
        {
            sum = G->vertices[i].in+G->vertices[i].out;
            cout<< G->vertices[i].data<<" "<<G->vertices[i].in<<" "<<G->vertices[i].out<<" "<<sum<<endl;
            sum = 0;
        }
    
    }

    最后是main函数

    int main()
    {
    
        ALGraph *G = (ALGraph*)malloc(sizeof(ALGraph));
        CreatALGraph(G);
        outALGraph(G);
        return 0;
    }

    由于题目的输入是A、B、C这样的顶点,我在创建时就把入度和出度就算了出来,这里注意结构体内部元素也要改变。

    cin>>q>>p;
            i = q-'A';
            j = p-'A';
            G->vertices[j].in++;
            G->vertices[i].out++;

    上面就是核心的算法,用ASCII码的加减法就实现了。

    以上就是创建一个有向图并算出它的入度出度。

    展开全文
  • 使用C语言实现数据结构中图操作,链式创建,两种形式遍历,查找路径及最短路径 。访问某个顶点邻接点
  • C语言实现数据结构之归并排序

    万次阅读 2018-09-19 09:48:21
    C/C++实现数据结构之2路-归并排序 归并排序和交换排序、选择排序思想不一样,归并含义是将两个或两个以上有序表组合成一个新有序表。假定待定排序表含有n个记录,则可以看成是N个有序子表。每个子表长度为...

    C/C++实现数据结构之2路-归并排序

    归并排序和交换排序、选择排序的思想不一样,归并的含义是将两个或两个以上的有序表组合成一个新的有序表。假定待定排序表含有n个记录,则可以看成是N个有序的子表。每个子表长度为1,然后两两归并,得到N/2个长度为2或1的有序表。再两两归并。如此重复,直到获得一个长度为n的有序表为止。这种方法称为2路归并排序

    函数实现:

    merge()函数的功能是将两个有序表归并为一个有序表,其中我们需要使用到辅助数组arr2来存储排序结果。在这里我们假设对数组进行操作。不对有序表结构进行排序。由于数组的下标是从0开始,就变得和普通的有序表不同。一般来说。有序表的第0个元素在排序中会作为哨兵元素。哨兵元素的种种好处在这里就不在阐述了。

    设两段有序表A[low,mid],B[mid+1,high]存放在同一顺序表中相邻的位置上。每次从数组中找两个数,进行大小比较,然后存入辅助数组,然后重复执行这个操作。直到其中一段有序表被遍历完毕。即这里的循环条件可以设为
    low<mid&&mid+1<high(伪代码)

    当其中一段有序表被遍历完后,我们可以将另一段有序表直接存入辅助数组。由于是有序表,所以直接存入辅助表不会导致有序表的特性被破坏。

    下面我们来看代码
    int arr1[10] = {9,8,7,6,5,4,3,2,1,0}, arr2[10];//原数组arr1,临时空间数组arr2
    void merge(int low, int mid, int high) {
    	int i = low, j = mid + 1, k = low;
    	while (i <= mid && j <= high)
    		if (arr1[i]<arr1[j])
    			arr2[k++] = arr1[i++];
    		else
    			arr2[k++] = arr1[j++];
    	while (i <= mid)
    		arr2[k++] = arr1[i++];
    	while (j <= high)
    		arr2[k++] = arr1[j++];
    	for (i = low; i <= high; i++) {
    		arr1[i] = arr2[i];
    	}
    }
    

    上述代码中的while循环只会执行一个!!!!!

    以上代码只能将两个有序表合并为一个有序表。但是由于程序刚开始的时候,有序表为单个元素本身,所以我们需要一个递归来使我们的merge函数每次执行时的表都为有序表。这个我们需要通过一个函数mergesort来操控。

    void mergeSort(int a, int b) {
    	//直到a=b时,停止递归。
    	if (a<b) {
    		int mid = (a + b) / 2;
    		mergeSort(a, mid);
    		mergeSort(mid + 1, b);
    		merge(a, mid, b);
    	}
    }
    
    

    当a=b时,递归停止,那么a减b的绝对值仅为1,那么能够保证第一次传入Merge函数的是一个有序子表。从而导致每次传入的表都为有序子表。

    完整代码

    #include "stdio.h"
    
    int arr1[10] = {9,8,7,6,5,4,3,2,1,0}, arr2[10];//原数组arr1,临时空间数组arr2
    void merge(int low, int mid, int high) {
    	int i = low, j = mid + 1, k = low;
    	while (i <= mid && j <= high)
    		if (arr1[i]<arr1[j])
    			arr2[k++] = arr1[i++];
    		else
    			arr2[k++] = arr1[j++];
    	while (i <= mid)
    		arr2[k++] = arr1[i++];
    	while (j <= high)
    		arr2[k++] = arr1[j++];
    	for (i = low; i <= high; i++) {
    		arr1[i] = arr2[i];
    	}
    }
    
    void mergeSort(int a, int b) {
    	//直到a=b时,停止递归。
    	if (a<b) {
    		int mid = (a + b) / 2;
    		mergeSort(a, mid);
    		mergeSort(mid + 1, b);
    		merge(a, mid, b);
    	}
    }
    
    int main() {
    	int i;
        mergeSort(0, 9);
    	return 0;
    }
    
    

    当然你们也可以使用动态定义的方式来定义数组,那么这里传入mergeSort的参数就需要改变了。

    展开全文
  • 这篇文章主要介绍了c语言 数据结构实现之字符串相关资料,需要同学朋友可以参考下。 c语言 数据结构实现之字符串 串采用定长顺序存储结构(由c4-1.h定义)基本操作(13个),包括算法4.2,4.3,4.5 #include <...

    前言:
    这篇文章主要介绍了c语言 数据结构实现之字符串的相关资料,需要的同学朋友可以参考下。

    c语言 数据结构实现之字符串
    串采用定长顺序存储结构(由c4-1.h定义)的基本操作(13个),包括算法4.2,4.3,4.5  
     

    #include <stdio.h> 
    #include <string.h> 
    #include <malloc.h> 
    // SString是数组,故不需引用类型 
    #define OK 1  
    #define TRUE 1  
    #define FALSE 0  
    #define ERROR 0  
    #define INFEASIBLE -1  
      
    #define DestroyString ClearString // DestroyString()与ClearString()作用相同 
    #define MAX_STR_LEN 40 // 用户可在255(1个字节)以内定义最大串长 
    typedef char SString[MAX_STR_LEN+1]; // 0号单元存放串的长度 
    typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等  
      
      
    Status StrAssign(SString T,char *chars) 
    { // 生成一个其值等于chars的串T 
      int i; 
      if(strlen(chars)>MAX_STR_LEN) 
        return ERROR; 
      else 
      { 
        T[0]=strlen(chars); 
        for(i=1;i<=T[0];i++) 
          T[i]=*(chars+i-1); 
        return OK; 
      } 
    } 
      
    void StrCopy(SString T,SString S) 
    { // 由串S复制得串T 
      int i; 
      for(i=0;i<=S[0];i++) 
        T[i]=S[i]; 
    } 
      
    Status StrEmpty(SString S) 
    { // 若S为空串,则返回TRUE,否则返回FALSE 
      if(S[0]==0) 
        return TRUE; 
      else 
        return FALSE; 
    } 
      
    int StrCompare(SString S,SString T) 
    {// 初始条件:串S和T存在。操作结果:若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0 
      int i; 
      for(i=1;i<=S[0]&&i<=T[0];++i) 
        if(S[i]!=T[i]) 
          return S[i]-T[i]; 
      return S[0]-T[0]; 
    } 
      
    int StrLength(SString S) 
    { // 返回串S的元素个数 
      return S[0]; 
    } 
      
    void ClearString(SString S) 
    { // 初始条件:串S存在。操作结果:将S清为空串 
      S[0]=0; // 令串长为零 
    } 
      
    Status Concat(SString T,SString S1,SString S2) // 算法4.2改 
    { // 用T返回S1和S2联接而成的新串。若未截断,则返回TRUE,否则FALSE 
      int i; 
      if(S1[0]+S2[0]<=MAX_STR_LEN) 
      { // 未截断 
        for(i=1;i<=S1[0];i++) 
          T[i]=S1[i]; 
        for(i=1;i<=S2[0];i++) 
          T[S1[0]+i]=S2[i]; 
        T[0]=S1[0]+S2[0]; 
        return TRUE; 
      } 
      else 
      { // 截断S2 
        for(i=1;i<=S1[0];i++) 
          T[i]=S1[i]; 
        for(i=1;i<=MAX_STR_LEN-S1[0];i++) 
          T[S1[0]+i]=S2[i]; 
        T[0]=MAX_STR_LEN; 
        return FALSE; 
      } 
    } 
      
    Status SubString(SString Sub,SString S,int pos,int len) 
    { // 用Sub返回串S的第pos个字符起长度为len的子串。算法4.3 
      int i; 
      if(pos<1||pos>S[0]||len<0||len>S[0]-pos+1) 
        return ERROR; 
      for(i=1;i<=len;i++) 
        Sub[i]=S[pos+i-1]; 
      Sub[0]=len; 
      return OK; 
    } 
      
    int Index(SString S,SString T,int pos) 
    { // 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数值为0。 
      // 其中,T非空,1≤pos≤StrLength(S)。算法4.5 
      int i,j; 
      if(1<=pos&&pos<=S[0]) 
      { 
        i=pos; 
        j=1; 
        while(i<=S[0]&&j<=T[0]) 
          if(S[i]==T[j]) // 继续比较后继字符 
          { 
            ++i; 
            ++j; 
          } 
          else // 指针后退重新开始匹配 
          { 
            i=i-j+2; 
            j=1; 
          } 
          if(j>T[0]) 
            return i-T[0]; 
          else 
            return 0; 
      } 
      else 
        return 0; 
    } 
      
    Status StrInsert(SString S,int pos,SString T) 
    { // 初始条件:串S和T存在,1≤pos≤StrLength(S)+1 
      // 操作结果:在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入返回FALSE 
      int i; 
      if(pos<1||pos>S[0]+1) 
        return ERROR; 
      if(S[0]+T[0]<=MAX_STR_LEN) 
      { // 完全插入 
        for(i=S[0];i>=pos;i--) 
          S[i+T[0]]=S[i]; 
        for(i=pos;i<pos+T[0];i++) 
          S[i]=T[i-pos+1]; 
        S[0]+=T[0]; 
        return TRUE; 
      } 
      else 
      { // 部分插入 
        for(i=MAX_STR_LEN;i>=pos+T[0];i--) 
          S[i]=S[i-T[0]]; 
        for(i=pos;i<pos+T[0]&&i<=MAX_STR_LEN;i++) 
          S[i]=T[i-pos+1]; 
        S[0]=MAX_STR_LEN; 
        return FALSE; 
      } 
    } 
      
    Status StrDelete(SString S,int pos,int len) 
    { // 初始条件:串S存在,1≤pos≤StrLength(S)-len+1 
      // 操作结果:从串S中删除第pos个字符起长度为len的子串 
      int i; 
      if(pos<1||pos>S[0]-len+1||len<0) 
        return ERROR; 
      for(i=pos+len;i<=S[0];i++) 
        S[i-len]=S[i]; 
      S[0]-=len; 
      return OK; 
    } 
      
    Status Replace(SString S,SString T,SString V) // 此函数与串的存储结构无关 
    { // 初始条件:串S,T和V存在,T是非空串 
      // 操作结果:用V替换主串S中出现的所有与T相等的不重叠的子串 
      int i=1; // 从串S的第一个字符起查找串T 
      Status k; 
      if(StrEmpty(T)) // T是空串 
        return ERROR; 
      do 
      { 
        i=Index(S,T,i); // 结果i为从上一个i之后找到的子串T的位置 
        if(i) // 串S中存在串T 
        { 
          StrDelete(S,i,StrLength(T)); // 删除该串T 
          k=StrInsert(S,i,V); // 在原串T的位置插入串V 
          if(!k) // 不能完全插入 
            return ERROR; 
          i+=StrLength(V); // 在插入的串V后面继续查找串T 
        } 
      }while(i); 
      return OK; 
    } 
      
    void StrPrint(SString T) 
    { // 输出字符串T。另加 
      int i; 
      for(i=1;i<=T[0];i++) 
        printf("%c",T[i]); 
      printf("\n"); 
    } 
    void get_next(SString T,int next[]) 
    { // 求模式串T的next函数值并存入数组next。算法4.7 
      int i=1,j=0; 
      next[1]=0; 
      while(i<T[0]) 
        if(j==0||T[i]==T[j]) 
        { 
          ++i; 
          ++j; 
          next[i]=j; 
        } 
        else 
          j=next[j]; 
    } 
      
    void get_nextval(SString T,int nextval[]) 
    { // 求模式串T的next函数修正值并存入数组nextval。算法4.8 
      int i=1,j=0; 
      nextval[1]=0; 
      while(i<T[0]) 
        if(j==0||T[i]==T[j]) 
        { 
          ++i; 
          ++j; 
          if(T[i]!=T[j]) 
            nextval[i]=j; 
          else 
            nextval[i]=nextval[j]; 
        } 
        else 
          j=nextval[j]; 
    } 
      
    int Index_KMP(SString S,SString T,int pos,int next[]) 
    { // 利用模式串T的next函数求T在主串S中第pos个字符之后的位置的KMP算法。 
      // 其中,T非空,1≤pos≤StrLength(S)。算法4.6 
      int i=pos,j=1; 
      while(i<=S[0]&&j<=T[0]) 
        if(j==0||S[i]==T[j]) // 继续比较后继字符 
        { 
          ++i; 
          ++j; 
        } 
        else // 模式串向右移动 
          j=next[j]; 
      if(j>T[0]) // 匹配成功 
        return i-T[0]; 
      else 
        return 0; 
    } 
      
    void main() 
    { 
      int i,*p; 
      SString s1,s2; // 以教科书算法4.8之上的数据为例 
      StrAssign(s1,"aaabaaaab"); 
      printf("主串为: "); 
      StrPrint(s1); 
      StrAssign(s2,"aaaab"); 
      printf("子串为: "); 
      StrPrint(s2); 
      p=(int*)malloc((StrLength(s2)+1)*sizeof(int)); // 生成s2的next数组空间 
      get_next(s2,p); // 利用算法4.7,求得next数组,存于p中 
      printf("子串的next数组为: "); 
      for(i=1;i<=StrLength(s2);i++) 
        printf("%d ",*(p+i)); 
      printf("\n"); 
      i=Index_KMP(s1,s2,1,p); // 利用算法4.6求得串s2在s1中首次匹配的位置i 
      if(i) 
        printf("主串和子串在第%d个字符处首次匹配\n",i); 
      else 
        printf("主串和子串匹配不成功\n"); 
      get_nextval(s2,p); // 利用算法4.8,求得next数组,存于p中 
      printf("子串的nextval数组为: "); 
      for(i=1;i<=StrLength(s2);i++) 
        printf("%d ",*(p+i)); 
      printf("\n"); 
      printf("主串和子串在第%d个字符处首次匹配\n",Index_KMP(s1,s2,1,p)); 
      getchar(); 
    }
    

    实现效果:

    主​​​​串为:aaabaaab
    子串为:aaaab
    子串的next数组为: 0 1 2 3 4
    主串和子串在第五个字符处首次匹配
    子串的nextval数组为: 0 0 0 0 4
    主串和子串在第五个字符处首次匹配

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    很多初学者,对c\c++的概念都是模糊不清的,c\c++是什么,能做什么,学的时候,该按照什么线路去学习,学完往哪方面发展,想深入了解,想学习的同学欢迎加入c\c++学习q 欢迎加入c/c++小白学习,群号:850829190
    有大量干货(零基础以及进阶的经典实战)分享给大家

     

    展开全文
  • 对于很多初学c语言的同学·,虽然都能理解数据结构中的思想,但是不一定能用c一行一行撸出一个完整的代码,我最近也正好在重新看数据结构,所以就把c语言实现数据结构源代码放出来帮助初学者。
  • C语言实现数据结构顺序存储

    千次阅读 2019-05-25 16:03:00
    C语言实现数据结构顺序存储 // 头文件 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define MAXSIZE 10 //顺序存储结构 模仿数组相关操作 typedef int DataType; typedef ...
  • c语言数据结构和数据类型 C语言的数据类型 (Data types in C Language) Data types specify how we enter data into our programs and what type of data we enter. C language has some predefined set of data ...
  • C语言动态数据结构

    千次阅读 2016-12-23 20:59:37
    动态数据结构是 动态存储分配链表是一种常见基础数据结构,是一种线性表,但是并不会按线性顺序存储数据,而是在每一个节点里存到下一个节点指针(Pointer)静态链表:所有节点在程序中定义,而不是临时开辟...
  • C语言各种数据结构所占字节数

    千次阅读 2018-01-26 20:43:50
    在谈到这个问题之前,即C语言各种数据结构所占字节数,我们先来了解一下最基本概念,字长和字节 1:字长: 计算机每个字所包含位数称为字长。根据计算机不同,字长有固定和可变两种。固定字长,即字...
  • 基于C语言的通用数据结构和算法库

    千次阅读 2015-07-02 12:04:34
    本人最近在学习数据结构的...C语言没有像C++那样的STL库,语言本身并不是一种真正意义上的高级语言,实现项目中真正用到的算法中的C语言的数据结构也很少,要么是按照自己的需求来实现,要么一般都用C++来完成大型的项
  • 数据结构-C语言实现线性表 SqList.h头文件 /*文件名:SqList.h*/ #include <stdio.h> #include <stdlib.h> //函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define ...
  • C语言实现递归法先序创建二叉树,用非递归法进行先序和层次遍历输出节点。希望各位IT精英可以加以详细注释
  • 因为之前我们学的数据...今天无意接触到c语言的数据结构,发现里面的函数时这样写的 Status Pop(SqStack &s,SElement &e);我想问一下这样不是可以理解为引用传参吗? 但是c语言是不支持引用传参的,求大佬指点一下
  • c语言节点 链条是什么意思??????????????????
  • C语言实现数据结构的链表

    千次阅读 2007-04-14 22:48:00
    为了能正确表示结点间的逻辑关系,在存储每个结点值的同时,还必须存储指示其后继结点的地址信息,这个信息称为指针或链下面是C语言实现链表的数据结构及基本的算法。# include # include typedef char DataType; //...
  • 大三刚刚过去了一个月的时间,现在的我回头看看大一的C语言和大二的数据结构,深深的感觉当时学习不够透彻许多东西没有深刻印象。 正值国庆节结束,十月初,我决定计划在十月里复习C语言和数据结构。 主要内容: ...
  • C语言数据结构栈链式结构

    千次阅读 2018-06-04 21:45:28
    链式结构 链表节点 typedef struct node { char c; // 数据 struct node *next; // 指针 }node, *pt; 栈顶指针 typedef struct stack { pt top; ...
  • 求大神解答…在此谢谢比较急…希望大家能够帮帮忙哇…这是我们课程设计不怎么会 ![图片说明](https://img-ask.csdn.net/upload/201506/26/1435325726_263981.png)![图片说明]...
  • } int depth(bitree t)//树深度 { if (t == NULL) return 0; else { int m = depth(t->lchild); int n = depth(t->rchild); if (m > n) return (m + 1); else return (n + 1); } } status ...
  • C语言数据结构第一篇(绪论)

    千次阅读 2020-10-07 19:49:23
    本人今天开始学习C语言的数据结构,每天会在这个平台记录自己的学习,一是可以作为督促自己每天坚持xue
  • C语言描述数据结构

    千次阅读 2007-08-21 00:16:00
    C语言描述数据结构 学好计算机,主要要从三个方面做起,其中,第一步就是要学好各种语言,这是第一步,对各种语言有一个大体了解;然后就是数据结构了,它是计算机中一门核心课程,也是一门信息计算;在...
  • #include #include #include "ljb.h" int visited[M];...///图遍历 void dfs(linkedgraph g,int i) {  edgenode *p;  printf("visit vertex:%c\n",g.adjivex[i].vertex);  visited[i]=1;  p=g.a
  • C语言实现数据结构循环链表

    千次阅读 2007-04-18 23:41:00
    C语言实现数据结构循环链表# include # include typedef struct node //定义链表中结点结构{ int code; struct node *next;}NODE,*LinkList; /*错误信息输出函数*/void Error(char *message){ fprintf...
  • 整合王道考研答案和理论, 还有小甲鱼的数据结构, 郝斌的数据结构,各有特点吧 最值得研究的还是后序遍历的非递归算法, 当时想了使用flag, 想到了多用一个栈, 想到了很多种方式,最后都以失败告终,经过网络查找, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,291
精华内容 16,516
关键字:

c语言的数据结构

c语言 订阅
数据结构 订阅