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

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

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

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

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

我只讲一些自己的看法。

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

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

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

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

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

第一步：三元组的创建

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

[cpp] view plain copy

1. typedef int* Triplet;//整型指针，作为数组的起始地址，可以在使用的时候再申请内存  
2. typedef int ElemType;//集合中元素的类型  
3. typedef int Status;//函数的类型  

第二步:三元组的操作

[cpp] view plain copy

1. Status InitTriplet(Triplet *T,ElemType v1,ElemType v2,ElemType v3)  
2. {  
3.     //操作结果：构造三元组(v1,v2,v3)  
4.     *T = (ElemType*)malloc(3*sizeof(ElemType));//分配3个元素的存储空间  
5.     if(!(*T)) exit(OVERFLOW);//分配存储空间失败  
6.     (*T)[0] = v1;  
7.     (*T)[1] = v2;  
8.     (*T)[2] = v3;  
9.     return OK;  
10. }  
11.   
12. Status DestoryTriplet(Triplet *T)  
13. {  
14.     //操作结果：三元组被销毁  
15.     free(*T);  
16.     *T = NULL;  
17.     return OK;  
18. }  
19.   
20. Status Get(Triplet T,int i,ElemType *e)  
21. {  
22.     //初始条件：三元组T已经存在，1<=i<=3  
23.     //操作结果：用e返回T的第i元的值  
24.     if(i<1||i>3) return ERROR;  
25.     (*e) = T[i-1];  
26.     return OK;  
27. }  
28.   
29. Status Put(Triplet T,int i ,ElemType e)  
30. {  
31.     //初始条件：三元组T已经存在，1<=i<=3  
32.     //操作结果：改变T的第i元值为e  
33.     if(i<1||i>3) return ERROR;  
34.     T[i-1] = e;  
35.     return OK;  
36. }  
37.   
38. Status IsAscending(Triplet T)  
39. {  
40.     //初始条件：三元组T已存在  
41.     //操作结果：如果T的三个元素按升序排列，则返回1，否则返回0  
42.     return (T[0]<=T[1])&&(T[1]<=T[2]);  
43. }  
44.   
45. Status IsDescending(Triplet T)  
46. {  
47.     //初始条件：三元组T已存在  
48.     //操作结果：如果T的三个元素按降序排列，则返回1，否则返回0  
49.     return (T[0]>=T[1])&&(T[1]>=T[2]);  
50. }  
51.   
52. Status Max(Triplet T,ElemType *e)  
53. {  
54.     //初始条件：三元组T已存在  
55.     //操作结果：用e返回T的3个元素中最大的值  
56.     (*e) = T[0]>T[1]?T[0]:T[1];  
57.     (*e) = (*e)>T[2]?(*e):T[2];  
58.     return OK;  
59. }  
60.   
61. Status Min(Triplet T,ElemType *e)  
62. {  
63.     //初始条件：三元组T已存在  
64.     //操作结果：用e返回T的3个元素中最小的值  
65.     (*e) = T[0]<T[1]?T[0]:T[1];  
66.     (*e) = (*e)<T[2]?(*e):T[2];  
67.     return OK;  
68. }  

第三步:完整代码实现

[cpp] view plain copy

1. #include <iostream>  
2. #include <stdio.h>  
3. #include <string.h>  
4. #include <stack>  
5. #include <queue>  
6. #include <map>  
7. #include <set>  
8. #include <vector>  
9. #include <math.h>  
10. #include <bitset>  
11. #include <algorithm>  
12. #include <climits>  
13. #include <ctype.h>  
14. #include <malloc.h>  
15. #include <limits.h>  
16. #include <stdlib.h>  
17. #include <io.h>  
18. #include <process.h>  
19. using namespace std;  
20.   
21. #define TRUE 1  
22. #define FALSE 0  
23. #define OK 1  
24. #define ERROR 0  
25. #define INFEASIBLE -1  
26.   
27.   
28. typedef int* Triplet;//整型指针，作为数组的起始地址，可以在使用的时候再申请内存  
29. typedef int ElemType;//集合中元素的类型  
30. typedef int Status;//函数的类型  
31.   
32. Status InitTriplet(Triplet *T,ElemType v1,ElemType v2,ElemType v3)  
33. {  
34.     //操作结果：构造三元组(v1,v2,v3)  
35.     *T = (ElemType*)malloc(3*sizeof(ElemType));//分配3个元素的存储空间  
36.     if(!(*T)) exit(OVERFLOW);//分配存储空间失败  
37.     (*T)[0] = v1;  
38.     (*T)[1] = v2;  
39.     (*T)[2] = v3;  
40.     return OK;  
41. }  
42.   
43. Status DestoryTriplet(Triplet *T)  
44. {  
45.     //操作结果：三元组被销毁  
46.     free(*T);  
47.     *T = NULL;  
48.     return OK;  
49. }  
50.   
51. Status Get(Triplet T,int i,ElemType *e)  
52. {  
53.     //初始条件：三元组T已经存在，1<=i<=3  
54.     //操作结果：用e返回T的第i元的值  
55.     if(i<1||i>3) return ERROR;  
56.     (*e) = T[i-1];  
57.     return OK;  
58. }  
59.   
60. Status Put(Triplet T,int i ,ElemType e)  
61. {  
62.     //初始条件：三元组T已经存在，1<=i<=3  
63.     //操作结果：改变T的第i元值为e  
64.     if(i<1||i>3) return ERROR;  
65.     T[i-1] = e;  
66.     return OK;  
67. }  
68.   
69. Status IsAscending(Triplet T)  
70. {  
71.     //初始条件：三元组T已存在  
72.     //操作结果：如果T的三个元素按升序排列，则返回1，否则返回0  
73.     return (T[0]<=T[1])&&(T[1]<=T[2]);  
74. }  
75.   
76. Status IsDescending(Triplet T)  
77. {  
78.     //初始条件：三元组T已存在  
79.     //操作结果：如果T的三个元素按降序排列，则返回1，否则返回0  
80.     return (T[0]>=T[1])&&(T[1]>=T[2]);  
81. }  
82.   
83. Status Max(Triplet T,ElemType *e)  
84. {  
85.     //初始条件：三元组T已存在  
86.     //操作结果：用e返回T的3个元素中最大的值  
87.     (*e) = T[0]>T[1]?T[0]:T[1];  
88.     (*e) = (*e)>T[2]?(*e):T[2];  
89.     return OK;  
90. }  
91.   
92. Status Min(Triplet T,ElemType *e)  
93. {  
94.     //初始条件：三元组T已存在  
95.     //操作结果：用e返回T的3个元素中最小的值  
96.     (*e) = T[0]<T[1]?T[0]:T[1];  
97.     (*e) = (*e)<T[2]?(*e):T[2];  
98.     return OK;  
99. }  
100.   
101. int main()  
102. {  
103.     Triplet T;  
104.     Status i;  
105.     ElemType e;  
106.     ElemType a,b,c,n;  
107.     //创建三元组  
108.     printf("请输入三元组的三个元素：\n");  
109.     scanf("%d%d%d",&a,&b,&c);  
110.     i = InitTriplet(&T,a,b,c);  
111.     if(i)  
112.     {  
113.         printf("调用初始化函数成功！三元组T的元素为：%d,%d,%d\n",T[0],T[1],T[2]);  
114.     }  
115.     else  
116.     {  
117.         printf("调用初始化函数失败\n");  
118.         return 0;  
119.     }  
120.     puts("");  
121.   
122.     //取出三元组内的元素  
123.     printf("请输入想取出三元组中的第几个元素(1<=i<=3)：");  
124.     scanf("%d",&n);  
125.     i = Get(T,n,&e);  
126.     if(i)  
127.     {  
128.         printf("三元组T中的第%d个元素为：%d\n",n,e);  
129.     }  
130.     else  
131.     {  
132.         printf("取出失败\n");  
133.     }  
134.     puts("");  
135.   
136.     //修改三元组内的元素  
137.     printf("请输入想要修改三元组哪个位置的元素(1<=i<=3)：");  
138.     scanf("%d",&n);  
139.     puts("");  
140.     printf("请输入想要插入的值：");  
141.     scanf("%d",&e);  
142.     i = Put(T,n,e);  
143.     if(i)  
144.     {  
145.         printf("插入成功，现在的三元组是：%d,%d,%d\n",T[0],T[1],T[2]);  
146.     }  
147.     else  
148.     {  
149.         printf("插入失败\n");  
150.     }  
151.     puts("");  
152.   
153.     //判断升序与降序  
154.     i = IsAscending(T);  
155.     printf("该三元组是否升序:%s\n",i?"是":"不是");  
156.     i = IsDescending(T);  
157.     printf("该三元组是否降序:%s\n",i?"是":"不是");  
158.     puts("");  
159.   
160.     //返回最大元素与最小元素  
161.     i = Max(T,&e);  
162.     if(i)  
163.         printf("该三元组最大的元素是：%d\n",e);  
164.     i = Min(T,&e);  
165.     if(i)  
166.         printf("该三元组最小的元素是：%d\n",e);  
167.     puts("");  
168.   
169.     //删除三元组  
170.     i = DestoryTriplet(&T);  
171.     if(i)  
172.     printf("删除成功\n");  
173.     else  
174.     printf("删除失败\n");  
175.   
176.     return 0;  
177. }  

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