權重結構的加權排序算法

開始算法之前，首先介紹一下向量中的排序方式，這里使用的是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 }

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 算法 | A*算法和權重A* 算法數據結構排序算法之選擇排序推薦算法之加權采樣文章排序權重數據結構與算法之PHP排序算法（歸並排序）數據結構於算法——排序算法-希爾排序數據結構與算法——排序算法-冒泡排序算法與數據結構基礎 - 排序(Sort) 數據結構排序算法（代碼實現）數據結構與算法之堆與堆排序