排序——排序的工程应用示例

 1 　　 /* 以下六个重载的排序是为了对 Array 对象排序；第一个参数代表外部的数组对象，Array 是父类，则 array 既可以代表静态数组对象，也可以代表动态数组对象，第二个参数意义不变*/
 2     template < typename T>//排序类的成员函数必然是用静态的成员函数通过模板实现的
 3     static void Select(Array<T>& array, bool min2max = true)
 4     {
 5         Select(array.array(), array.length(), min2max); // 将数组类中封装的原生数组的首地址和原生数组的长度拿出来
 6 　　 }
 7 
 8     template < typename T>  // 排序类就能够成功的作用于数组类对象，将数组类对象所代表的那些元素序列进行排序
 9     static void Insert(Array<T>& array, bool min2max = true)
10     {
11         Insert(array.array(), array.length(), min2max);
12 　　 }
13 
14     template < typename T>
15     static void Bubble(Array<T>& array, bool min2max = true)
16     {
17         Bubble(array.array(), array.length(), min2max);
18 　　 }
19 
20     template < typename T>
21     static void Shell(Array<T>& array, bool min2max = true)
22     {
23         Shell(array.array(), array.length(), min2max);
24     }
25 
26     template < typename T>
27     static void Merge(Array<T>& array, bool min2max = true)
28     {
29         Merge(array.array(), array.length(), min2max);
30 　　 }
31 
32     template < typename T>
33     static void Quick(Array<T>& array, bool min2max = true)
34     {
35         Quick(array.array(), array.length(), min2max);
36     }

  1 #include <iostream>
  2 #include <ctime>
  3 #include "Sort.h"
  4 
  5 using namespace std;
  6 using namespace DTLib;
  7 
  8 struct Test : public Object
  9 {
 10     int id;
 11     int data1[1000];
 12 　　 double data2[500];
 13 
 14     bool operator < (const Test& obj)
 15     {
 16         return id < obj.id;
 17 　　 }
 18 
 19     bool operator >= (const Test& obj)
 20     {
 21         return id >= obj.id;
 22 　　 }
 23 
 24     bool operator > (const Test& obj)
 25     {
 26         return id > obj.id;
 27 　　 }
 28 
 29     bool operator <= (const Test& obj)
 30     {
 31         return id <= obj.id;
 32     }
 33 };
 34 
 35 // 实现代理类，有了代理类，才可以有代理对象，如果项目对时间要求不高的话，没必要使用，因为使代码变得复杂了空间换时间的理念
 36 class TestProxy : public Object
 37 {
 38 protected:
 39 　　 Test* m_pTest;  // 指向被代理的对象
 40 
 41 public:
 42     // 代理对象必须像原始的被代理对象一样的可以干同样的事情，原始对象能干的功能，代理对象也要能实现
 43     int id()
 44     {
 45         return m_pTest->id;
 46 　　 }
 47 
 48     int* data1()
 49     {
 50         return m_pTest->data1;
 51 　　 }
 52 
 53     double* data2()
 54     {
 55         return m_pTest->data2;
 56 　　 }
 57 
 58     // 必要的时候能够请出委托者，办护照
 59     Test& test() const
 60     {
 61         return *m_pTest;
 62 　　 }
 63 
 64     // 代理类之间的比较就是原始对象之间的比较
 65     bool operator < (const TestProxy& obj)
 66     {
 67         return test() < obj.test();
 68 　　 }
 69 
 70     bool operator >= (const TestProxy& obj)
 71     {
 72         return test() >=obj.test();
 73 　　 }
 74 
 75     bool operator > (const TestProxy& obj)
 76     {
 77         return test() > obj.test();
 78 　　 }
 79 
 80     bool operator <= (const TestProxy& obj)
 81     {
 82         return test() <= obj.test();
 83 　　 }
 84 
 85     // 重载这个赋值操作符，让其和被代理对象一一映射，不用构造函数
 86     Test& operator = (Test& test)
 87     {
 88         m_pTest = &test;
 89         return test;
 90     }
 91 };
 92 
 93　　  Test t[1000];
 94 　　 TestProxy pt[1000];
 95 
 96 int main()
 97 {
 98     clock_t begin = 0;
 99 　　 clock_t end = 0;
100 
101     for(int i=0; i<1000; i++)
102     {
103         t[i].id = i;
104         pt[i] = t[i];  // 一一映射，pt 里面的元素代理的 t 里面的对象
105 　　 }
106 
107     begin = clock();
108     Sort::Bubble(pt, 1000, false );
109 　　 end = clock();
110 
111 　　 cout << "Time: " << (end - begin) << endl;
112 
113     for(int i=0; i<1000; i++)
114     {
115         cout << t[i].id << " " << pt[i].id() << endl;
116 　　 }
117 
118     return 0;
119 }