精华内容
下载资源
问答
  • 抽象数据结构三元组的实现(《数据结构》严蔚敏) 最近学了一段时间严蔚敏的数据结构,想着把抽象数据类型三元组上机实现一下,才发现自己存在很多问题,在CSDN里面看了很多大佬的代码,但是发现一个普遍的问题,...

    抽象数据结构三元组的实现(《数据结构》严蔚敏)

    最近学了一段时间严蔚敏的数据结构,想着把抽象数据类型三元组上机实现一下,才发现自己存在很多问题,在CSDN里面看了很多大佬的代码,但是发现一个普遍的问题,C语言代码里面用到了C++里面的引用传递,但是这在我的Mac上的Xcode上面编译不了,所以花了一两天时间理解指针和数组以及引用传递、值传递和指针传递。并且手动编写了自己的代码。这篇文章写给那些和我有一样问题的朋友。

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #define ERROR 0
    #define OK 1
    #define OVERFLOW -1
    typedef int Status;
    typedef int ElemType;
    typedef ElemType *Triplet;
    Status InitTriplet(Triplet *T,ElemType v1,ElemType v2, ElemType v3)
    {
        *T = (ElemType*)malloc(3*sizeof(ElemType));
        if(!T)exit(OVERFLOW);
        (*T)[0] = v1;
        (*T)[1] = v2;
        (*T)[2] = v3;
        return OK;
    }
    
    Status DestoryTriplet(Triplet *T)
    {
        free(*T);
        *T = NULL;
        return OK;
    }
    
    Status Get(Triplet T, int i, ElemType *e)
    {
        if(i<1 || i>3)return ERROR;
        *e = T[i-1];    
        return OK;
    }
    
    Status Put(Triplet *T, int i, ElemType e)
    {
        if(i<1 || i>3)return ERROR;
        (*T)[i-1] = e;
        return OK;
    }
    
    Status IsAscending(Triplet T)
    {
        return (T[0] <= T[1])? (T[0] <= T[2]? T[0]: T[2]): (T[1] <= T[2]? T[1]: T[2]);
    }
    
    Status Descending(Triplet T)
    {
        return (T[0] >= T[1])? (T[0] >= T[2]? T[0]: T[2]): (T[1] >= T[2]? T[1]: T[2]);
    }
    
    Status Max(Triplet T, ElemType *e)
    {
        *e = (T[0] >= T[1])? (T[0] >= T[2]? T[0]: T[2]): (T[1] >= T[2]? T[1]: T[2]);
        return OK;
    }
    Status Min(Triplet T, ElemType *e)
    {
        *e = (T[0] <= T[1])? (T[0] <= T[2]? T[0]: T[2]): (T[1] <= T[2]? T[1]: T[2]);
        return OK;
    }
    
    int main(int argc, char *argv[])
    {
        Triplet T;
        ElemType *e, e1 = 2, e2 = 3, e3 = 6;
        ElemType e4 = 9;
        e = &e1;
        if(!InitTriplet(&T, e1, e2, e3))return 0;
        Max(T, e);
        printf("三元组中最大值为%d\n",*e);
        Get(T, 1, e);
        printf("三元组中第一个元素为%d\n", *e);
        Put(&T, 2, e4);
        printf("修改后的三元组第二个元素为%d\n", T[1]);
        for(int j=0; j<3; j++)
        {
            printf("三元组中第%d个元素为%d\n", j+1, T[j]);
        }
        DestoryTriplet(&T);
        return 0;
    }
    

    总结:有不懂的地方可以留言,我都会回复的。提醒大家特别注意形参里面的*/是“指针声明符号”,而被调函数中表达式里面的*是“取值运算符”,还有就是主函数中传递参数时需要传递给指针的是“地址”。形参中真正修改到实参的方法只有修改实参指向的内容,而不是修改形参的值,因为形参存的是实参的地址,修改了形参的值之后,找不到实参了,再去取值运算定位不到实参指向的值。

    展开全文
  • [抽象数据类型三元组的定义抽象数据类型三元组的定义ADT Triplet{数据对象:D= {e1,e2,e3 | e1,e2,e3属于Elemset(定义了关系的某个集合)}数据关系:R1={|}基本操作:—InitTriplet(&T,v1,v2,v3)— 初始条件:— ...

    [抽象数据类型三元组的定义

    抽象数据类型三元组的定义

    ADT Triplet{

    数据对象:D= {e1,e2,e3 | e1,e2,e3属于Elemset(定义了关系的某个集合)}

    数据关系:R1={|}

    基本操作:

    —InitTriplet(&T,v1,v2,v3)

    — 初始条件:

    — 操作结果:用e值取代三元组T的第i个元素

    — DestroyTriplet(&T)

    — 初始条件:三元组T已经存在。

    — 操作结果:销毁三元组T。

    —Get(T,i,&e)

    — 初始条件:三元组T已经存在,1<=i<=3,

    — 操作结果:用e返回三元组T的第i个元素。

    — Put(&T,i,e)

    — 初始条件:三元组T已经存在,1<=i<=3,

    — 操作结果:用e值取代三元组T的第i个元素。

    — IsAscending(T)

    — 初始条件:三元组T已经存在。

    — 操作结果:如果三元组T的三个元素按升序排列,则返回TRUE;否则返回FALSE

    —IsDescending(T)

    — 初始条件:三元组T已经存在。

    — 操作结果:如果三元组T的三个元素按降序排列,则返回TRUE;否则返回FALSE

    — Max(T,&e)

    — 初始条件:三元组T已经存在。

    — 操作结果:用e返回三元组T的最大值。

    —Min(T,&e)

    — 初始条件:三元组T已经存在。

    — 操作结果:用e返回三元组T的最小值。

    }ADT Triplet

    抽象数据类型的表示与实现

    类C语言(做了扩充和修改)的表示

    如:预定义常量和类型

    #define TRUE 1

    #define FALSE0

    #define OK1

    #define ERROR0

    #define INFEASIVLE-1

    #define OVERFLOW-2

    Typedef int Status

    Status Get(Triple T,int i,Elemtype *e)

    // 初始条件:三元组T已经存在,1<=i<=3.

    // 操作结果:用e返回三元组T的第i个元素

    {

    If(i<1 || i>3) return ERROR;

    *e = T[i-1];

    Return OK;

    }

    算法和算法分析

    算法(Algorithm):对特定问题求解步骤的一种描述。

    算法的五个重要特性:

    1有穷性 2确定性 3可行性 4输入 4输出

    算法举例————气泡排序算法

    初始条件:N个待排序的数a[0]—a[n-1]

    结果:排序后a[0]—a[n-1]从小到大排列

    1 置标记change=TRUE;

    2 i从n-1知道i=2做(3)-- (6)步

    3 change = FALSE;

    4 j从0知道j=i-1做(5)

    5 若a[j]>a[j+1]则交换他们并置change = TRUE

    6 若change = FALSE 则结束

    7 算法结束

    i从n-1知道i=2 做 2—3 步

    j从0知道j=i-1做 3

    若a[j]>a[j+1]则交换他们

    算法结束

    Void bb_sort(int a[],int n){

    for(i=n-1;i > 1; --i){

    for(j=0;j

    if(a[j]>a[j+1]){a[j]←→a[j+1];}

    } // bb_sort

    算法设计的要求

    算法应达到的目标

    1正确性2可读性3健壮性4效率与低存储量

    算法效率的度量

    1事后统计法

    2事前分析估算法

    ]算法的 时间复杂度 ;基本操作重复执行次数。

    它是问题规模n的某个函数f(n);

    T(n)= O(f(n))

    平均时间复杂度——时间复杂度与输入数据有关时采用平均时间复杂度或最最坏时间复杂度

    // 气泡排序

    时间复杂度只考虑对问题规模的增长率

    在难以精确计算基本操作执行次数时,仅需要求增长率(或阶)即可。

    阶:for(i=2;i<=n:++i)

    For(j=2;j<=i;++j){++x;a[i,j]=x;}

    ++x的执行次数关于n的增长率时O(n平方)

    最大的数量阶 n的n次方 n!

    线性表

    线性表结构的特点:

    存在唯一的第一个数据元素

    存在唯一的最后一个数据元素

    除第一个外。每个数据元素均有且只有一个前驱元素;

    除最后一个外。每个数据元素均有且只有一个后继元素。

    线性表举例;

    字母表 (A,B,C ,,, X Y Z)

    数据序列(6.17.28.50)

    N个元素的线性表

    (a1.a2,a3...an)

    第一个元素没有前驱 最后一个元素没有后继 第i个

    展开全文
  • 抽象数据类型三元组Triplet的表示和实现。 数据类型是一个值的集合和定义在这个值集上的一组操作的总称。按“值”的不同特性,高级程序语言中的数据类型可分为两类:一类是非结构的原子类型,原子类型的值是不可分解...

    抽象数据类型三元组Triplet的表示和实现。

    数据类型是一个值的集合和定义在这个值集上的一组操作的总称。按“值”的不同特性,高级程序语言中的数据类型可分为两类:一类是非结构的原子类型,原子类型的值是不可分解的;另一类是结构类型,结构类型的值是由若干成分按某种结构组成的,因此是可以分解的,并且它的成分可以是非结构的,也可以是结构的。

    抽象数据类型(Abstract Data Type,简称ADT)是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性,而与其在计算机内部如何表示和实现无关,即不论其内部结构如何变化,只要它的数学特性不变,都不影响其外部的使用。

    ** 抽象数据类型三元组Triplet的表示和实现
    
    //- - - - - - - - -采用动态分配的顺序存储结构- - - - - -
    typedef ElemType * Triplet; //由 InitTriplet 分配3个元素存储空间
    
    
    
    //- - - - - - - - -基本操作的函数原型说明- - - - - -
    Status InitTriplet (Triplet &T, ElemType v1, ElemType v2, ElemType v3);
    	// 操作结果:构成了三元组T,元素 e1, e2 和 e3 分别被赋以参数 v1,v2 和 v3 的值。
    
    Status DestroyTriplet (Triplet &T);
    	// 操作结果:三元组 T 被销毁。
    
    Status Get (Triplet T, int i, ElemType &e);
    	// 初始条件:三元组 T 已经存在,1<=i<=3。
    	// 操作结果:用 e 返回 T 的第 i 元的值。
    
    Status Put (Triplet &T, int i, ElemType e);
    	// 初始条件:三元组 T 已存在,1<=i<=3.
    	// 操作结果:改变 T 的第 i 元的值为e。
    
    Status IsAscending (Triplet T);
    	// 初始条件:三元组 T 已存在。
    	// 操作条件:如果 T 的3个元素按升序排列,则返回1,否则返回0。
    
    Status IsDescending (Triplet T);
    	// 初始条件:三元组 T 已存在。
    	// 操作条件:如果 T 的3个元素按降序排列,则返回1,否则返回0。
    
    Status Max (Triplet T, ElemType &e);
    	 // 初始条件:三元组 T 已存在。
    	 // 操作结果:用 e 返回 T 的3个元素中的最大值。
    
    Status Min (Triplet T, ElemType &e);
    	 // 初始条件:三元组 T 已存在。
    	 // 操作结果:用 e 返回 T 的3个元素中的最小值。
    
    
    
    
    ** malloc函数是在内存的动态存储区中分配一个长度为size的连续空间。
    ** 其参数是一个无符号整形数,返回值是一个指向所分配的连续存储域的起始地址的指针。
    ** malloc的语法是:指针名 =(数据类型 * )malloc(长度); 其中(数据类型*)表示指针。
     
    //- - - - - - - - - - - - -基本操作的实现- - - - - - - - - -
    Status InitTriplet (Triplet &T, ElemType v1, ElemType v2, ElemType v3) {
    	// 构造三元组 T,依位置 T 的 3 个元素的初值为 v1,v2,v3。
    	T = (ElemType * ) malloc (3 * sizeof(ElemType));     // 分配 3 个元素的存储空间
    	if (!T) exit(OVERFLOW);     // 分配存储空间失败
    	T[0] = v1;	T[1] = v2;	T[2] = v3;
    	return OK;
    }// InitTriplet
    
    Status DestroyTriplet (Triplet &T) {
    	// 销毁三元组 T。
    	free(T);		T = NULL;
    	return OK;
    }// DestroyTriplet
    
    Status Get (Triplet T, int i, ElemType &e) {
    	// 1<=i<=3,用 e 返回 T 的第 i元的值。
    	if (i<1 || i>3) return ERROR;
    	e = T[ i-1 ];
    	return OK;
    }// Get
    
    Status Put (Triplet &T, int i, ElemType e) {
    	// 1<=i<=3,置 T 的第 i 元的值为e。
    	if ( i<1 || i>3 ) return ERROR;
    	T[ i-1 ] = e;
    	return OK;
    }// Put
    
    Status IsAscending (Triplet T) {
    	// 如果 T 的3个元素按升序排列,则返回1,否则返回0。
    	return (T[0] <= T[1]) && (T[1] <= T[2]);
    }// IsAscending
    
    Status IsDescending (Triplet T) {
    	// 如果 T 的3个元素按降序排列,则返回1,否则返回0。
    	return (T[0] >= T[1]) && (T[1] >= T[2]);
    }// IsDescending
    
    Status Max (Triplet T, ElemType &e) {
    	// 用 e 返回指向 T 的最大元素的值。
    	e = (T[0] >= T[1]) ? ((T[0] >= T[2]) ? T[0] : T[2]) : ((T[1] >= T[2]) ? T[1] : T[2]);
    }// Max
    
    Status Min (Triplet T, ElemType &e) {
    	// 用 e 返回指向 T 的最小元素的值。
    	e = (T[0] <= T[1]) ? ((T[0] <= T[2]) ? T[0] : T[2]) : ((T[1] <= T[2]) ? T[1] : T[2]);
    }// Min
    
    展开全文
  • 数据结构抽象数据类型三元组的表示与实现c/c++ 天依镇楼!!! 大部分童鞋学数据结构的时候应该都是学的清华大学出版社的严蔚敏奶奶的书,但里面都是伪代码,上课老师讲的都很模糊,应该都是纸讲了每个操作的核心...

    【数据结构】抽象数据类型三元组的表示与实现c/c++

    天依镇楼!!!
    在这里插入图片描述
    大部分童鞋学数据结构的时候应该都是学的清华大学出版社的严蔚敏奶奶的书,但里面都是伪代码,上课老师讲的都很模糊,应该都是纸讲了每个操作的核心算法,就那么几句话,同学们下来自己打代码实现的时候会出现很大的问题,各种莫名奇妙的bug,头都要大了有没有,我自己拿出来我的代码给各位参考一下。希望有些帮助,如果没有,就当进来看看图片吧,哈哈哈哈。
    下面代码奉上。

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h> 
    
    //函数结果状态代码
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    #define INFEASIBLE -1
    #define OVERFLOW -2
     
    typedef int Status;
    typedef float ElemType;
    typedef ElemType * Triplet; 
    
    //函数原型 
    Status InitTriplet(Triplet &T,ElemType v1,ElemType v2,ElemType v3);
    void Print(Triplet T);
    Status Get(Triplet T,int i,ElemType &e);
    Status Put(Triplet &T,int i,ElemType e);
    Status IsAscending(Triplet T);
    Status IsDescending(Triplet T);
    Status Max(Triplet T,ElemType &e);
    Status Min(Triplet T,ElemType &e);
    Status DestroyTriplet(Triplet &T);
    void addTriplet(Triplet &T1,Triplet T2);
    
    int main(void){
    	int i,x;
    	Triplet T,T1,T2;
    	//T=(Triplet)malloc(3*sizeof(ElemType));
    	ElemType a,b,c,e;
    	
    	printf("          |$$$抽象数据类型三元组的实现\n");
    	printf("          |该程序可以实现一下几种功能:\n");
    	printf("          |1.创建一个三元组;\n");
    	printf("          |2.获取三元组的第i个值;\n");
    	printf("          |3.改变三元组的第i个值为e;\n");
    	printf("          |4.判断该三元组此时是否升序;\n");
    	printf("          |5.判断该三元组此时是否降序;\n");
    	printf("          |6.求该三元组的最大值;\n");
    	printf("          |7.求该三元组的最小值;\n");
    	printf("          |8.销毁三元组;\n");
    	printf("          |9.实现两个三元组的相加;\n");
    	printf("          |0.退出程序;\n\n\n");
    	printf("请输入要实现的功能:\n");
    	scanf("%d",&x); 
    	while(x){
    		switch(x){
    			case 1:{
    				printf("请输入要创建的三元组的三个值:");
    				scanf("%f%f%f",&a,&b,&c); 
    				InitTriplet(T,a,b,c);
    				Print(T);
    				break;
    			}
    			case 2:{
    				printf("请输入要获取三元组的第几个值:");
    				scanf("%d",&i);
    				Get(T,i,e);
    				printf("该三元组的第%d个值为:%.2f\n",i,e); 
    				break;
    			}
    			case 3:{
    				printf("请输入位置i和数值e:");
    				scanf("%d%f",&i,&e); 
    				Put(T,i,e);
    				printf("此时的三元组为:");
    				Print(T);
    				break;
    			}
    			case 4:{
    				if(IsAscending(T)==1)
    					printf("该三元组为升序!\n");				
    				else
    					printf("该三元组不为升序!\n");								
    				break;
    			} 
    			case 5:{
    				if(IsDescending(T)==1)
    					printf("该三元组为降序!\n");				
    				else
    					printf("该三元组不为降序!\n");	
    				break;
    			}
    			case 6:{
    				Max(T,e);
    				printf("该三元组此时的最大值为%.2f\n",e);
    				break;
    			}
    			case 7:{
    				Min(T,e);
    				printf("该三元组此时的最小值为%.2f\n",e);
    				break;
    			}
    			case 8:{
    				if(DestroyTriplet(T)==1){
    					printf("三元组销毁成功!\n");
    				}
    				else{
    					printf("销毁失败!\n");
    				}
    				break;
    			}
    			case 9:{
    				printf("请输入第一个三元组:");
    				scanf("%f%f%f",&a,&b,&c); 
    				InitTriplet(T1,a,b,c);
    				printf("请输入第二个三元组:");
    				scanf("%f%f%f",&a,&b,&c); 
    				InitTriplet(T2,a,b,c); 
    				addTriplet(T1,T2);
    				printf("合并之后的三元组为:");
    				Print(T1);
    				break;
    			}
    			default:printf("输入错误,请重新输入!\n");
    				continue;
    		}
    		printf("请输入要实现的功能:\n");
    		scanf("%d",&x); 
    	}
    	printf("程序运行完毕,感谢您的使用!\n");
    	return 0;
    }
    //创建 
    Status InitTriplet(Triplet &T,ElemType v1,ElemType v2,ElemType v3){
    	T=(Triplet)malloc(3*sizeof(ElemType));
    	if(!T)
    		return ERROR;	
    	else{
    		T[0]=v1;
    		T[1]=v2;
    		T[2]=v3;
    		return OK;
    	}
    } 
    //输出 
    void Print(Triplet T){
    	printf("%.2f %.2f %.2f\n",T[0],T[1],T[2]);
    }
    //获取 
    Status Get(Triplet T,int i,ElemType &e){
    	//i如果不在范围内,返回错误 
    	if(i<1||i>3){
    		return ERROR;
    	}
    	e=T[i-1];
    	return OK;
    }
    //改变 
    Status Put(Triplet &T,int i,ElemType e){
    	if(i<1||i>3){
    		return ERROR;
    	}
    	T[i-1]=e;
    	return OK;
    } 
    Status IsAscending(Triplet T){
    	//若升序则返回1,否则返回0 
    	return (T[0]<=T[1])&&(T[1]<=T[2]);
    }
    Status IsDescending(Triplet T){
    	//若降序则返回1,否则返回0 
    	return (T[0]>=T[1])&&(T[1]>=T[2]);
    }
    //求最大 
    Status Max(Triplet T,ElemType &e){
    	//这里使用了三目运算符的嵌套来找出最值 
    	e=(T[0]>=T[1])?((T[0]>=T[2])?T[0]:T[2]):((T[1]>=T[2])?T[1]:T[2]);
    	return OK; 
    }
    //求最小 
    Status Min(Triplet T,ElemType &e){
    	e=(T[0]<=T[1])?((T[0]<=T[2])?T[0]:T[2]):((T[1]<=T[2])?T[1]:T[2]);
    	return OK;
    }
    //销毁 
    Status DestroyTriplet(Triplet &T){
    	free(T);
    	T=NULL;
    	return OK;
    }
    //合并 
    void addTriplet(Triplet &T1,Triplet T2){
    	T1[1]+=T2[1];
    	T1[0]+=T2[0];
    	T1[2]+=T2[2];
    } 
    
    展开全文
  • } /**初始化三元组, 并赋予v1, v2, v3的值 */ Status InitTriplet(Triplet *T, ElemType v1, ElemType v2, ElemType v3) { *T = (ElemType *)malloc(3*sizeof(ElemType)); if (!T) exit(OVERFLOW); (*T)[0] = v1; ...
  • 数据结构实验一:抽象数据类型Triplet的实现和表示; 实验代码: #include <iostream> #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define OK 1 #define TRUE 1 #...
  • 在visual C++ 6.0环境下运行
  • 数据结构三元组

    2018-01-01 09:24:07
    数据结构(清华大学出版社)课程中的三元组,定义与实现,C语言描述
  • 实验1 抽象数据类型 5142 简单三元组 要求:建立一个三元组抽象类型,根据给定的主函数实现三元组的创建,销毁,赋值,遍历,求最大值等操作。 main.cpp /******************main.cpp********************* 测试...
  • 主要功能:构造三元组;销毁三元组;用e返回T的第i元的值;置T的第i元的值为e;判断是否为升序排列;判断是否为降序排列;求最大值;求最小值;显示三元组。 1 #include <stdio.h> 2 #include <stdlib.h&...
  • 这个博客基本操作大部分来自教材《数据结构C语言版》严蔚敏版,实现了书中的大部分功能,并且用了三个文件。 一个是主函数,一个是功能模块,一个是头文件定义,用VC6.0++完成 //头文件声明 #ifndef _FUNC_H #...
  • /* 抽象数据类型Triplet和ElemType的基本操作(8个) */ int main() { Triplet T;//自定义数据类型 ElemType m; Status i; i=InitTriplet(&T,5,7,9); /* i=InitTriplet(&T,5.0,7.1,9.3); /* 当ElemType为双精度型...
  • //三元组 感觉要改变结构里的值时用&t,不改变用t status init_triplet(triplet &t,element_type v1,element_type v2,element_type v3);//创建三元组 status destory_triplet(triplet &t); //销毁三元组 status get...
  • 数据结构三元组操作

    2019-07-30 23:39:53
    复习数据结构,发现今天才真正了解数据结构是怎么一回事。当初学的完全忘了,这次从新开始吧。 1.抽象数据类型 /* ADT Triplett { 数据对象:D={e1,e2,e3|e1,e2,e3∈ElemSet(定义了关系运算的某个集合) } ...
  • 抽象数据类型(三元组ADT、复数四则运算) 数据结构 湖南大学
  • 设计实现抽象数据类型“三元组”,要求动态分配内存。每个三元组由任意三个实数的序列构成,基本操作包括:创建一个三元组,取三元组的任意一个分量,置三元组的任意一个分量,求三元组的最大分量,求三元组的最小...
  • 现在随着课堂实验写一写抽象数据类型了,话不多说上代码。 ps:因为输入输出可以自己瞎鸡儿搞,所以用了很多输出语句显得代码很冗长,但是实际上上全部都是c的基础,请读者耐心观看。 #include<stdio.h> ...
  • 抽象数据结构

    千次阅读 2020-01-23 09:49:40
    1.抽象数据类型定义 抽象数据类型( Abstract Data Type... 抽象数据类型是一个数学模型以及定义在其上的一操作组成,因此,抽象数据类型一般通过数据对象、数据关系以及基本操作来定义,即抽象数据类型三要素...
  • 数据结构三元组

    千次阅读 2018-07-13 19:56:10
    三元组的表示(1)、目的:对于在实际问题中出现的大型的稀疏矩阵,若用常规分配方法在计算机中储存,将会产生大量的内存浪费,而且在访问和操作的时候也会造成大量时间上的浪费,为了解决这一问题,从而善生了多种...
  • 抽象数据结构(Abstract Data Type)(ADT) 1.定义:抽象数据结构是指在一个数学模型以及定义在此模型中的一系列操作。 注意:❶抽象数据类型不考虑计算机内的具体存储结构与运算的具体实现方法。 (就是说抽象...
  • Triplet.c: #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status;...//----------采用动态分配的顺序存储结构--------- typedef Ele...
  • 数据结构(C语言版)严蔚敏版的第一章的内容,抽象数据类型Triplet的操作实现,用C语言写的,比较简单,容易理解
  • 三元组基本操作 首先建一个项目,就叫Triplet 新建三个文件 Tripletc.h文件 #ifndef TRIIPLET_H_INCLUDED #define TRIIPLET_H_INCLUDED #include<bits/stdc++.h> using namespace std; #define TRUE 1 #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,353
精华内容 3,741
关键字:

抽象数据结构三元组

数据结构 订阅