权重结构的加权排序算法

时间：2015-02-03 14:39:45 阅读：195 评论：0 收藏：0 [点我收藏+]

标签：

权重结构的加权排序算法

开始算法之前，首先介绍一下向量中的排序方式，这里使用的是STL中的std::sort排序方式，具体使用的代码如下：

//定义加权排序的结构
template<typename T>
struct _sortStru 
{
    T _data1;
    T _data2;
    T _data3;
    T _data4;
    int nWeight[4];
    _sortStru()
    {
        memset(this, 0, sizeof(_sortStru));
    }
};

bool _sort_sample(const _sortStru<int> &l,  const _sortStru<int> &r)
{
    return l._data1 < r._data1;
}

int main()
{
    // 初始化一个vector，成员类型为_sortStru<int>
    vector< _sortStru<int> > vec;
    int i = 0;
    for (i = 0; i < MAXNUM; i++)
    {
        _sortStru<int> sort;
        sort._data1 = Random();
        sort._data2 = Random();
        sort._data3 = Random();
        sort._data4 = Random();
        vec.push_back(sort);
    }
    
    // 输出
    for (i = 0; i < MAXNUM; i++)
    {
        _sortStru<int> out;
        out = vec.at(i);
        cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
        cout<<endl;
    }
    cout<<endl;
    
    // 简单排序，最结构体中的第一个成员进行排序
    std::sort(vec.begin(), vec.end(), _sort_sample);
    for (i = 0; i < MAXNUM; i++)
    {
        _sortStru<int> out;
        out = vec.at(i);
        cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
        cout<<endl;
    }
    cout<<endl;
    return 0;
}

　　正面代码段时对vec中的_sortStru<int>成员，按照结构体中第一个成员进行排序。

　下面给出的是对这个的加权排序

　　每一个结构体的成员都有一个自己的权重，结构体的定义如下：

//定义加权排序的结构
template<typename T>
struct _sortStru 
{
    T _data1;
    T _data2;
    T _data3;
    T _data4;
    int nWeight[4];
    _sortStru()
    {
        memset(this, 0, sizeof(_sortStru));
    }
};

　　在这个结构中有四个成员变量，分别任_data1 - _data4，这个四个成员都有自己的权重，比如_data1的权重是30，_data2的权重是20，_data3的权重是40，_data4的权重是10。然后根据这些权重对一组数据进行排序。然后将排序后的结果从大到小排列出来。

　　具体的排序方法是：

　　首先，对这组数据中的每个成员从小到大排序，具体的先对第一个成员进行从小到大排序，排好序后给这些成员添加上自己的位置权重，最小的为0，然后依次增加，循环的给所有的成员都添加上位置权重。

　　然后，对这些具有位置权重的数据进行加权排序。

　　具体代码如下：

  1 #include <iostream>
  2 #include <vector>
  3 #include <assert.h>
  4 #include <algorithm>
  5 #define Random() (rand()%100)
  6 using namespace std;
  7 #define MAXNUM 10
  8 
  9 //定义加权排序的结构
 10 template<typename T>
 11 struct _sortStru 
 12 {
 13     T _data1;
 14     T _data2;
 15     T _data3;
 16     T _data4;
 17     int nWeight[4];
 18     _sortStru()
 19     {
 20         memset(this, 0, sizeof(_sortStru));
 21     }
 22 };
 23 
 24 
 25 bool _sort_sample(const _sortStru<int> &l,  const _sortStru<int> &r)
 26 {
 27     return l._data1 < r._data1;
 28 }
 29 
 30 
 31 class _sort
 32 {
 33 public:
 34     _sort() : pos(0){}
 35     _sort(int nPos) : pos(nPos){}
 36     bool operator()(const _sortStru<int> &l,  const _sortStru<int> &r)
 37     {
 38         switch (pos)
 39         {
 40         case 0:
 41             return l._data1 < r._data1;
 42         case 1:
 43             return l._data2 < r._data2;
 44         case 2:
 45             return l._data3 < r._data3;
 46         case 3:
 47             return l._data4 < r._data4;
 48         default:
 49             return l._data1 < r._data1;
 50         }
 51     }
 52 
 53 private:
 54     int pos;
 55 };
 56 
 57 template<class T>
 58 class Add_Weight
 59 {
 60 public:
 61     Add_Weight(int type, int start) 
 62         : ntype(type), nstart(start), nLastValue(0), nLastWeight(0)
 63     {
 64     }
 65 
 66     void operator()(_sortStru<T> &_F)
 67     {
 68         switch (ntype)
 69         {
 70         case 0: default:
 71             if (_F._data1 == nLastValue)
 72             {
 73                 _F.nWeight[ntype] = nLastWeight;
 74             }
 75             else
 76             {
 77                 _F.nWeight[ntype] = nstart;
 78                 nLastValue = _F._data1;
 79                 nLastWeight = nstart;
 80             }
 81             break;
 82         case 1:
 83             if (_F._data2 == nLastValue)
 84             {
 85                 _F.nWeight[ntype] = nLastWeight;
 86             }
 87             else
 88             {
 89                 _F.nWeight[ntype] = nstart;
 90                 nLastValue = _F._data2;
 91                 nLastWeight = nstart;
 92             }
 93             break;
 94         case 2:
 95             if (_F._data3 == nLastValue)
 96             {
 97                 _F.nWeight[ntype] = nLastWeight;
 98             }
 99             else
100             {
101                 _F.nWeight[ntype] = nstart;
102                 nLastValue = _F._data3;
103                 nLastWeight = nstart;
104             }
105             break;
106         case 3:
107             if (_F._data4 == nLastValue)
108             {
109                 _F.nWeight[ntype] = nLastWeight;
110             }
111             else
112             {
113                 _F.nWeight[ntype] = nstart;
114                 nLastValue = _F._data4;
115                 nLastWeight = nstart;
116             }
117             break;
118         }
119         nstart++;
120     }
121 private:
122     int ntype;
123     int nstart;
124     T nLastValue;
125     int nLastWeight;
126 };
127 
128 
129 
130 // 四个参数的权重类
131 class CWeight
132 {
133 public:
134     CWeight()
135     {
136         weight_1 = 0;
137         weight_1 = 0;
138         weight_1 = 0;
139         weight_1 = 0;
140     };
141 
142     CWeight(int Fir, int Sec, int thi, int Fou)
143         : weight_1(Fir), weight_2(Sec), weight_3(thi), weight_4(Fou)
144     {
145     };
146 
147     void Check()
148     {
149         assert(weight_1 + weight_2 + weight_3 + weight_4 == 100);
150     }
151 
152 public:
153     int weight_1;
154     int weight_2;
155     int weight_3;
156     int weight_4;
157 };
158 
159 template<class T>
160 class Compare_Weight
161 {
162 public:
163     Compare_Weight(CWeight *pF)
164         : pweight(pF)
165     {
166     }
167 
168     bool operator()(const _sortStru<T> &_F, const  _sortStru<T> &_L)
169     {
170         T t1 = _F.nWeight[0] * pweight->weight_1 
171             + _F.nWeight[1] * pweight->weight_2 
172             + _F.nWeight[2] * pweight->weight_3
173             + _F.nWeight[3] * pweight->weight_4;
174 
175         T t2 = _L.nWeight[0] * pweight->weight_1 
176             + _L.nWeight[1] * pweight->weight_2 
177             + _L.nWeight[2] * pweight->weight_3
178             + _L.nWeight[3] * pweight->weight_4;
179 
180         return t1 > t2;
181     }
182 
183 private:
184     CWeight *pweight;
185 };
186 
187 int main()
188 {
189     // 初始化一个vector，成员类型为_sortStru<int>
190     vector< _sortStru<int> > vec;
191     int i = 0;
192     for (i = 0; i < MAXNUM; i++)
193     {
194         _sortStru<int> sort;
195         sort._data1 = Random();
196         sort._data2 = Random();
197         sort._data3 = Random();
198         sort._data4 = Random();
199         vec.push_back(sort);
200     }
201     
202     // 输出
203     for (i = 0; i < MAXNUM; i++)
204     {
205         _sortStru<int> out;
206         out = vec.at(i);
207         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
208         cout<<endl;
209     }
210     cout<<endl;
211     
212     // 简单排序，最结构体中的第一个成员进行排序
213     std::sort(vec.begin(), vec.end(), _sort_sample);
214     for (i = 0; i < MAXNUM; i++)
215     {
216         _sortStru<int> out;
217         out = vec.at(i);
218         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
219         cout<<endl;
220     }
221     cout<<endl;
222 
223     // 简单排序，最结构体中的第N个成员进行排序
224     std::sort(vec.begin(), vec.end(), _sort(2));
225     for (i = 0; i < MAXNUM; i++)
226     {
227         _sortStru<int> out;
228         out = vec.at(i);
229         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
230         cout<<endl;
231     }
232     cout<<endl;
233 
234     // 加权排序
235     for (i = 0; i < 4; i++)
236     {
237         std::sort(vec.begin(), vec.end(), _sort(i));
238         std::for_each(vec.begin(), vec.end(), Add_Weight<int>(i, 0));
239     }
240     CWeight *weight = new CWeight(50, 50, 0, 0);
241     weight->Check();
242     std::sort(vec.begin(), vec.end(), Compare_Weight<int>(weight));
243     for (i = 0; i < MAXNUM; i++)
244     {
245         _sortStru<int> out;
246         out = vec.at(i);
247         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
248         cout<<endl;
249     }
250     cout<<endl;
251     
252     return 0;
253 }

权重结构的加权排序算法

标签：

原文地址：http://www.cnblogs.com/aimenfeifei/p/4269702.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行