数据结构学习之路-第一章：绪论

出处：http://blog.csdn.net/libin1105/article/details/47935379

正如很多专业教材一样，绪论是少不了的，自然这本书也不例外。

绪论中概括了我们整本书所将要学习的内容，也就是数据结构这本书所探寻的几大重点：集合，线性表，树，森林，图。

很多理论的东西，书本已经解释的很详细了，我在这里就不必再多废话了。

我只讲一些自己的看法。

首先，只要是写程序的人，都应该知道一个式子“程序=数据结构+算法”，数据结构的重要性不言而喻。

而如果有搞ACM的同学的话，那么对于各种数据结构都不会陌生，数据结构可是算法竞赛中的一大核心，没有被各种数据结构虐过，就不算是真正搞过ACM的人了。

本人其实也只是个渣渣，由于就读的学校属于二流中的二流，老师们的水平也比较有限，数据结构这门课讲的并不深入，自己当时学的也不彻底，在搞ACM的过程中，数据结构这方面也十分的不扎实，所以带着要复习巩固提升自己数据结构这方面的能力，于是才开始了写这连载性的博文了。

进入重点，首先绪论中先给我们来个热身，那就是三元组的建立。

这算是一个最简单的集合吧，那么我们就按照书本的步骤来进行

第一步：三元组的创建

所谓的集合，通俗而言就是以数组形式来保存的了，所以我们可以定义一个数组，所以我们在一开始，先来定义几个类型

[cpp] view
plain copy

typedef int* Triplet;//整型指针，作为数组的起始地址，可以在使用的时候再申请内存  

typedef int ElemType;//集合中元素的类型  

typedef int Status;//函数的类型  

第二步:三元组的操作

[cpp] view
plain copy

Status InitTriplet(Triplet *T,ElemType v1,ElemType v2,ElemType v3)  

{  

    //操作结果：构造三元组(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;  

}  

  

Status DestoryTriplet(Triplet *T)  

{  

    //操作结果：三元组被销毁  

    free(*T);  

    *T = NULL;  

    return OK;  

}  

  

Status Get(Triplet 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;  

}  

  

Status Put(Triplet T,int i ,ElemType e)  

{  

    //初始条件：三元组T已经存在，1<=i<=3  

    //操作结果：改变T的第i元值为e  

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

    T[i-1] = e;  

    return OK;  

}  

  

Status IsAscending(Triplet T)  

{  

    //初始条件：三元组T已存在  

    //操作结果：如果T的三个元素按升序排列，则返回1，否则返回0  

    return (T[0]<=T[1])&&(T[1]<=T[2]);  

}  

  

Status IsDescending(Triplet T)  

{  

    //初始条件：三元组T已存在  

    //操作结果：如果T的三个元素按降序排列，则返回1，否则返回0  

    return (T[0]>=T[1])&&(T[1]>=T[2]);  

}  

  

Status Max(Triplet T,ElemType *e)  

{  

    //初始条件：三元组T已存在  

    //操作结果：用e返回T的3个元素中最大的值  

    (*e) = T[0]>T[1]?T[0]:T[1];  

    (*e) = (*e)>T[2]?(*e):T[2];  

    return OK;  

}  

  

Status Min(Triplet T,ElemType *e)  

{  

    //初始条件：三元组T已存在  

    //操作结果：用e返回T的3个元素中最小的值  

    (*e) = T[0]<T[1]?T[0]:T[1];  

    (*e) = (*e)<T[2]?(*e):T[2];  

    return OK;  

}  

第三步:完整代码实现

[cpp] view
plain copy

#include <iostream>  

#include <stdio.h>  

#include <string.h>  

#include <stack>  

#include <queue>  

#include <map>  

#include <set>  

#include <vector>  

#include <math.h>  

#include <bitset>  

#include <algorithm>  

#include <climits>  

#include <ctype.h>  

#include <malloc.h>  

#include <limits.h>  

#include <stdlib.h>  

#include <io.h>  

#include <process.h>  

using namespace std;  

  

#define TRUE 1  

#define FALSE 0  

#define OK 1  

#define ERROR 0  

#define INFEASIBLE -1  

  

  

typedef int* Triplet;//整型指针，作为数组的起始地址，可以在使用的时候再申请内存  

typedef int ElemType;//集合中元素的类型  

typedef int Status;//函数的类型  

  

Status InitTriplet(Triplet *T,ElemType v1,ElemType v2,ElemType v3)  

{  

    //操作结果：构造三元组(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;  

}  

  

Status DestoryTriplet(Triplet *T)  

{  

    //操作结果：三元组被销毁  

    free(*T);  

    *T = NULL;  

    return OK;  

}  

  

Status Get(Triplet 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;  

}  

  

Status Put(Triplet T,int i ,ElemType e)  

{  

    //初始条件：三元组T已经存在，1<=i<=3  

    //操作结果：改变T的第i元值为e  

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

    T[i-1] = e;  

    return OK;  

}  

  

Status IsAscending(Triplet T)  

{  

    //初始条件：三元组T已存在  

    //操作结果：如果T的三个元素按升序排列，则返回1，否则返回0  

    return (T[0]<=T[1])&&(T[1]<=T[2]);  

}  

  

Status IsDescending(Triplet T)  

{  

    //初始条件：三元组T已存在  

    //操作结果：如果T的三个元素按降序排列，则返回1，否则返回0  

    return (T[0]>=T[1])&&(T[1]>=T[2]);  

}  

  

Status Max(Triplet T,ElemType *e)  

{  

    //初始条件：三元组T已存在  

    //操作结果：用e返回T的3个元素中最大的值  

    (*e) = T[0]>T[1]?T[0]:T[1];  

    (*e) = (*e)>T[2]?(*e):T[2];  

    return OK;  

}  

  

Status Min(Triplet T,ElemType *e)  

{  

    //初始条件：三元组T已存在  

    //操作结果：用e返回T的3个元素中最小的值  

    (*e) = T[0]<T[1]?T[0]:T[1];  

    (*e) = (*e)<T[2]?(*e):T[2];  

    return OK;  

}  

  

int main()  

{  

    Triplet T;  

    Status i;  

    ElemType e;  

    ElemType a,b,c,n;  

    //创建三元组  

    printf("请输入三元组的三个元素：\n");  

    scanf("%d%d%d",&a,&b,&c);  

    i = InitTriplet(&T,a,b,c);  

    if(i)  

    {  

        printf("调用初始化函数成功！三元组T的元素为：%d,%d,%d\n",T[0],T[1],T[2]);  

    }  

    else  

    {  

        printf("调用初始化函数失败\n");  

        return 0;  

    }  

    puts("");  

  

    //取出三元组内的元素  

    printf("请输入想取出三元组中的第几个元素(1<=i<=3)：");  

    scanf("%d",&n);  

    i = Get(T,n,&e);  

    if(i)  

    {  

        printf("三元组T中的第%d个元素为：%d\n",n,e);  

    }  

    else  

    {  

        printf("取出失败\n");  

    }  

    puts("");  

  

    //修改三元组内的元素  

    printf("请输入想要修改三元组哪个位置的元素(1<=i<=3)：");  

    scanf("%d",&n);  

    puts("");  

    printf("请输入想要插入的值：");  

    scanf("%d",&e);  

    i = Put(T,n,e);  

    if(i)  

    {  

        printf("插入成功，现在的三元组是：%d,%d,%d\n",T[0],T[1],T[2]);  

    }  

    else  

    {  

        printf("插入失败\n");  

    }  

    puts("");  

  

    //判断升序与降序  

    i = IsAscending(T);  

    printf("该三元组是否升序:%s\n",i?"是":"不是");  

    i = IsDescending(T);  

    printf("该三元组是否降序:%s\n",i?"是":"不是");  

    puts("");  

  

    //返回最大元素与最小元素  

    i = Max(T,&e);  

    if(i)  

        printf("该三元组最大的元素是：%d\n",e);  

    i = Min(T,&e);  

    if(i)  

        printf("该三元组最小的元素是：%d\n",e);  

    puts("");  

  

    //删除三元组  

    i = DestoryTriplet(&T);  

    if(i)  

    printf("删除成功\n");  

    else  

    printf("删除失败\n");  

  

    return 0;  

}  

总体来说，绪论没有什么好讲的，关键只是让大家熟悉数据结构，好了，这次就到此为止吧。