短学期有感

短学期最后一个作业,程序设计,我们写了N久,结果代码无法封装到MFC中,于是改成了DOS,在期限的最后一个晚上,我仔细检查了一下全局变量的声明,结果发现在初始化头文件中声明了一个多余的实例,我把它去掉之后,然后在Afxstd中声明变量变量,然后在各个文件中外部引用,结果可以用了,于是我们又信心十足,把代码集装到MFC中,经过反复的调试,在晚十二点之前,成果终于出来了......在这个过程中,我们克服了很多困难,比如文件操作,数据的传送和保存,有时候一个小错误连调试都无法解决,害得我们常常要浪费好几个小时,可惜今天老师什么也没问,直接让我们PASS了,虽然感觉算法简单了点,可是这都是华哥一句一句代码写进去的啊!华哥纯爷们!!!没有参考任何源程序.我的框架也刚好和代码吻合,这说明在开始进行工作前,协商好变量,函数是非常重要的,不然效率会非常低下!

当我们决定改成DOS时,曾非常沮丧,可是在别人的鄙视下,我们不认输,战胜了可恶的MFC!,最终战胜了自己!同志们啊,要相信哥,哥的话是对的,还是士兵突击里的那句话:不抛弃!也不放弃!

在这次大作业下,我得到了很多东西,第一个是团体合作,其实这也是第一次在团队中做程序设计,团队的成员都是老师分配,彼此之间的特点不熟悉,一开始我还担心什么沟通问题,结果都是白担心了,大家的合作非常愉快,特别是框架和代码块的吻合过程实在是天衣无缝,我看到别人的设计都是在一台机器线性工作,而我们是同时进行,并且结果配合得非常好,这让我体会到,事先在小组中讨论好工作的开展是非常重要的.

第二个是彼此的信任和鼓励,我们在调试过程中遇到了很多困难,有时候你的代码错了,有时候我的代码错了,可是我们不相互埋怨,而是耐心的查找错误,对对方非常信任,相信一定能够解决这个问题.在这个过程中,我体会到一个道理,一个让别人感到有安全感,可以信任的人,才是成熟的人,所以我在这次合作中,心里一直有一个信念,绝不能让队友失望,所以才有了在最后时刻重用MFC的精彩一幕,每当我们克服一个BUG时都非常的兴奋.所以从现在开始,我要让自己的父母不再为自己担心,要让自己喜欢的人不再为自己感到失望,要让身边的人感觉自己值得信任!

像许三多那样,傻傻地笑,不为别人的一些无意地伤人话感到气愤,何必为了一些小人之心的话语而伤了自己的心情呢?像许三多那样,傻傻地坚持,不抛弃不放弃!坚持自己的理想,坚持自己的感情!所以,我决不放弃某人!!!!!!某人你看到了吗????

 

 

 

 

Code:

1. //************************  sorts.h  ***************************   
2. //                 Generic sorting algorithms   
3. //               overloading of < and = required   
4.   
5. //conflict with <algorithms>, <queue>   
6. //template<class T>   
7. //inline void swap (T& e1, T& e2) {   
8. //    T tmp = e1; e1 = e2; e2 = tmp;   
9. //}   
10.   
11. template<class T>   
12. void insertionsort(T data[], int n) {   
13.     for (int i = 1, j; i < n; i++) {   
14.         T tmp = data[i];   
15.         for (j = i; j > 0 && tmp < data[j-1]; j--)   
16.             data[j] = data[j-1];   
17.         data[j] = tmp;   
18.     }   
19. }   
20.   
21. template<class T>   
22. void selectionsort(T data[], int n) {   
23.     for (int i = 0, least, j; i < n-1; i++) {   
24.         for (j = i+1, least = i; j < n; j++)   
25.             if (data[j] < data[least])   
26.                 least = j;   
27.         swap(data[least],data[i]);   
28.     }   
29. }   
30.   
31. template<class T>   
32. void bubblesort(T data[], int n) {   
33.     for (int i = 0; i < n-1; i++)   
34.         for (int j = n-1; j > i; --j)   
35.             if (data[j] < data[j-1])   
36.                 swap(data[j],data[j-1]);   
37. }   
38.   
39. template<class T>   
40. void ShellSort(T data[], int arrSize) {   
41.     register int i, j, hCnt, h;   
42.     int increments[20], k;   
43. //  create an appropriate number of increments h   
44.     for (h = 1, i = 0; h < arrSize; i++) {   
45.         increments[i] = h;   
46.         h = 3*h + 1;   
47.     }   
48.  // loop on the number of different increments h   
49.     for (i--; i >= 0; i--) {   
50.         h = increments[i];   
51.      // loop on the number of subarrays h-sorted in ith pass   
52.         for (hCnt = h; hCnt<2*h; hCnt++) {   
53.          // insertion sort for subarray containing every hth element of array data   
54.             for (j = hCnt; j < arrSize; ) {   
55.                 T tmp = data[j];   
56.                 k = j;   
57.                 while (k-h >= 0 && tmp < data[k-h]) {   
58.                     data[k] = data[k-h];   
59.                     k -= h;   
60.                 }   
61.                 data[k] = tmp;   
62.                 j += h;   
63.             }   
64.         }   
65.     }   
66. }   
67.   
68. template<class T>   
69. void moveDown (T data[], int first, int last) {   
70.     int largest = 2*first + 1;   
71.     while (largest <= last) {   
72.         if (largest < last && // first has two children (at 2*first+1 and   
73.             data[largest] < data[largest+1]) // 2*first+2) and the second   
74.              largest++;                      // is larger than the first;   
75.   
76.         if (data[first] < data[largest]) {   // if necessary,   
77.              swap(data[first],data[largest]);// swap child and parent,   
78.              first = largest;                // and move down;   
79.              largest = 2*first+1;   
80.         }   
81.         else largest = last+1;  // to exit the loop: the heap property   
82.     }                           // isn't violated by data[first];   
83. }   
84.   
85. template<class T>   
86. void heapsort(T data[], int size) {   
87.     int i;   
88.     for (i = size/2 - 1; i >= 0; --i)   // create the heap;   
89.         moveDown (data,i,size-1);   
90.     for (i = size-1; i >= 1; --i) {   
91.         swap(data[0],data[i]); // move the largest item to data[i];   
92.         moveDown(data,0,i-1);  // restore the heap property;   
93.     }   
94. }   
95.   
96. template<class T>   
97. void quicksort(T data[], int first, int last) {   
98.     int lower = first+1, upper = last;   
99.     swap(data[first],data[(first+last)/2]);   
100.     T bound = data[first];   
101.     while (lower <= upper) {   
102.         while (data[lower] < bound)   
103.              lower++;   
104.         while (bound < data[upper])   
105.              upper--;   
106.         if (lower < upper)   
107.              swap(data[lower++],data[upper--]);   
108.         else lower++;   
109.     }   
110.     swap(data[upper],data[first]);   
111.     if (first < upper-1)   
112.         quicksort (data,first,upper-1);   
113.     if (upper+1 < last)   
114.         quicksort (data,upper+1,last);   
115. }   
116.   
117. template<class T>   
118. void quicksort(T data[], int n) {   
119.     int i, max;   
120.     if (n < 2)   
121.         return;   
122.     for (i = 1, max = 0; i < n; i++)// find the largest   
123.         if (data[max] < data[i])    // element and put it   
124.             max = i;                // at the end of data[];   
125.     swap(data[n-1],data[max]); // largest el is now in its   
126.     quicksort(data,0,n-2);     // final position;   
127. }   
128.   
129. template<class T>   
130. void merge(T array1[], int first, int last) {   
131.     int mid = (first + last) / 2;   
132.     int i1 = 0, i2 = first, i3 = mid + 1;   
133.     while (i2 <= mid && i3 <= last)   
134.         if (array1[i2] < array1[i3])   
135.              temp[i1++] = array1[i2++];   
136.         else temp[i1++] = array1[i3++];   
137.     while (i2 <= mid)   
138.         temp[i1++] = array1[i2++];   
139.     while (i3 <= last)   
140.         temp[i1++] = array1[i3++];   
141.     for (i1 = 0, i2 = first; i2 <= last; array1[i2++] = temp[i1++]);   
142. }   
143.   
144. template<class T>   
145. void mergesort(T data[], int first, int last) {   
146.     if (first < last) {   
147.         int mid = (first + last) / 2;   
148.         mergesort (data, first, mid);   
149.         mergesort (data, mid+1, last);   
150.         merge (data, first, last);   
151.     }   
152. }   
153.   
154. #include <queue>   
155. #include <stack>   
156.   
157. using namespace std;   
158.   
159. template<class T>   
160. class Queue : public queue<T> {   
161. public:   
162.     T dequeue() {   
163.         T tmp = front();   
164.         queue<T>::pop();   
165.         return tmp;   
166.     }   
167.     void enqueue(const T& el) {   
168.         push(el);   
169.     }   
170. };   
171.   
172. template<class T>   
173. void radixsort(T data[], int n) {   
174.     register int i, j, k, factor;   
175.     const int radix = 10;   
176.     const int digits = 5;   
177.     Queue<T> queues[radix];   
178.     for (i = 0, factor = 1; i < digits; factor *= radix, i++) {   
179.         for (j = 0; j < n; j++)   
180.             queues[(data[j] / factor) % radix].enqueue(data[j]);   
181.         for (j = k = 0; j < radix; j++)   
182.             while (!queues[j].empty())   
183.                  data[k++] = queues[j].dequeue();   
184.     }   
185. }   
186.   
187. template<class T>   
188. void bitRadixsort(T data[], int n) {   
189.     register int i, j, k, mask = 1;   
190.     const int bits = sizeof(T)*8;   
191.     Queue<T> queues[2];   
192.     for (i = 0; i < bits; i++) {   
193.         for (j = 0; j < n; j++)   
194.             queues[data[j] & mask ? 1 : 0].enqueue(data[j]);   
195.         mask <<= 1;   
196.         k = 0;   
197.         while (!queues[0].empty())   
198.             data[k++] = queues[0].dequeue();   
199.         while (!queues[1].empty())   
200.             data[k++] = queues[1].dequeue();   
201.    }   
202. }   
203.   
204. void inline clear(int& q) {   
205.     q = -1;   
206. }   
207. int inline isEmpty(int q) {   
208.     return q == -1;   
209. }   
210.   
211. template<class T>   
212. class RadixSortNode {   
213. public:   
214.     T *arr;   
215.     RadixSortNode *next;   
216. };   
217.   
218. template<class T>   
219. void radixsort2(T data[], int n) {   
220.     register int d, j, k, factor, where;   
221.     const int radix = 10;   
222.     const int digits = 5;   
223.     RadixSortNode<T> n1, n2, *p1, *p2;   
224.     n1.arr = data;   
225.     n2.arr = new T[n];   
226.     for (j = 0; j < n; j++)   
227.         n2.arr[j] = data[j];   
228.     int *queue = new int[n], queueHeads[radix], queueTails[radix];   
229.     p1 = n2.next = &n1;   
230.     p2 = n1.next = &n2;   
231.     for (d = 0, factor = 1; d < digits; factor *= radix, d++) {   
232.         for (j = 0; j < radix; j++)   
233.             clear(queueHeads[j]);   
234.         for (j = 0; j < n; j++) {   
235.             where = (p1->arr[j] / factor) % radix;   
236.             if (isEmpty(queueHeads[where]))   
237.                  queueTails[where] = queueHeads[where] = j;   
238.             else {   
239.                  queue[queueTails[where]] = j;   
240.                  queueTails[where] = j;   
241.             }   
242.         }   
243.         for (j = 0; j < radix; j++)   
244.             if (!(isEmpty(queueHeads[j])))   
245.                  clear(queue[queueTails[j]]);   
246.         for (j = k = 0; j < radix; j++)   
247.             while (!(isEmpty(queueHeads[j]))) {   
248.                  p2->arr[k++] = p1->arr[queueHeads[j]];   
249.                  queueHeads[j] = queue[queueHeads[j]];   
250.             }   
251.         p2 = p2->next;   
252.         p1 = p1->next;   
253.     }   
254.     if (digits % 2 != 0) // if digits is an odd number;   
255.         for (d = 0; d < n; d++)   
256.             data[d] = p1->arr[d];   
257. }   
258.   
259. template<class T>   
260. void bitRadixsort2(T data[], int n) {   
261.     register int d, j, k, where, mask = 1;   
262.     const int radix = 10;   
263.     const int digits = 5;   
264.     const int bits = sizeof(T)*8;   
265.     RadixSortNode<T> n1, n2, *p1, *p2;   
266.     n1.arr = data;   
267.     n2.arr = new T[n];   
268.     for (j = 0; j < n; j++)   
269.         n2.arr[j] = data[j];   
270.     int *queue = new int[n], queueHeads[radix], queueTails[radix];   
271.     p1 = n2.next = &n1;   
272.     p2 = n1.next = &n2;   
273.     for (d = 0; d < bits; d++, mask <<= 1) {   
274.         clear(queueHeads[0]);   
275.         clear(queueHeads[1]);   
276.         for (j = 0; j < n; j++) {   
277.             where = p1->arr[j] & mask ? 1 : 0;   
278.             if (isEmpty(queueHeads[where]))   
279.                  queueTails[where] = queueHeads[where] = j;   
280.             else {   
281.                  queue[queueTails[where]] = j;   
282.                  queueTails[where] = j;   
283.             }   
284.         }   
285.         for (j = 0; j < 2; j++)   
286.             if (!(isEmpty(queueHeads[j])))   
287.                  clear(queue[queueTails[j]]);   
288.         for (j = k = 0; j < 2; j++)   
289.             while (!(isEmpty(queueHeads[j]))) {   
290.                  p2->arr[k++] = p1->arr[queueHeads[j]];   
291.                  queueHeads[j] = queue[queueHeads[j]];   
292.             }   
293.         p2 = p2->next;   
294.         p1 = p1->next;   
295.     }   
296.     if (digits % 2 != 0) // if digits is an odd number;   
297.         for (d = 0; d < n; d++)   
298.             data[d] = p1->arr[d];   
299. }   
300.