快速排序法

// vos_test.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "vos.h"

#define TABLE_MID_MACHINE_NAME     "midmachine"
#define TABLE_MIDMACH_COLNAME_ID   "id"
#define TABLE_MIDMACH_COLNAME_IP   "ip"
#define TABLE_MIDMACH_ACTIVE_FLAG  "activeflag"
#define TABLE_MIDMACH_COLNAME_MACH "name"

#define APP_NULL VOS_NULL
#define app_u32 vos_u32
#define app_void vos_void

typedef struct
{
 app_u32 ulcommandid;  //命令字ID
 app_u32 ulseq;        //序号，规则每个命令字都对应一批序号，从0开始，即对每个命令下到对应pid进行时序控制
 app_u32 uldstpid;     //目标PID
} st_oamreg_map;

STATIC st_oamreg_map* g_stoamregmap = APP_NULL;
STATIC app_u32 g_maxoamregnum = 100;

#define MAKE_CMDSEQ(STOBJ) ((STOBJ.ulcommandid << 8) | STOBJ.ulseq)

//快速排序法
void Qsort(st_oamreg_map a[], int low, int high)
{
 if (low >= high)
 {
  return;
 }

 int first = low;
 int last = high;
 int keyvalue = 0;
 int lastvalue = 0;
 int firstvalue = 0;

 st_oamreg_map key;
 memset(&key, 0, sizeof(st_oamreg_map));
 memcpy(&key, &a[first], sizeof(st_oamreg_map));
 keyvalue = MAKE_CMDSEQ(key);

 while (first < last)
 {
  while ((first < last) && ((lastvalue = MAKE_CMDSEQ(a[last])) >= keyvalue)) --last;

  memcpy(&a[first], &a[last], sizeof(st_oamreg_map));

  while ((first < last) && ((firstvalue = MAKE_CMDSEQ(a[first])) <= keyvalue)) ++first;

  memcpy(&a[last], &a[first], sizeof(st_oamreg_map));
 }

 memcpy(&a[first], &key, sizeof(st_oamreg_map));

 Qsort(a, low, first-1);
 Qsort(a, first+1, high);
}
static app_void app_oam_initoamregmap()
{
 app_u32 ullen = 0;
 app_u32 ulrunrslt = VOS_OK;

 ullen = sizeof(st_oamreg_map) * g_maxoamregnum;
 g_stoamregmap = (st_oamreg_map *)malloc(ullen);
 memset(g_stoamregmap, 0, ullen);
 return;
}
STATIC app_u32 app_oam_register(st_oamreg_map stcmdmap)
{
 app_u32 ulindex = 0;

 for (ulindex = 0; ulindex < g_maxoamregnum; ulindex++)
 {
  if (((stcmdmap.ulcommandid == g_stoamregmap[ulindex].ulcommandid)
   && (stcmdmap.uldstpid == g_stoamregmap[ulindex].uldstpid))
   || ((stcmdmap.ulcommandid == g_stoamregmap[ulindex].ulcommandid)
   && (stcmdmap.ulseq == g_stoamregmap[ulindex].ulseq)))
  {
   vos_syslog(-1, vos_log_type_running,
    "[Error] ulcommandid(0x%x) ulseq(%d) uldstpid(0x%x) repeat %s(%d)\r\n",
    stcmdmap.ulcommandid, (int)stcmdmap.ulseq, stcmdmap.uldstpid,
    vos_filterpathforfile((vos_u8*)__FILE__), __LINE__);
   return -1;
  }

  if ((0 == g_stoamregmap[ulindex].ulcommandid)
   && (0 == g_stoamregmap[ulindex].uldstpid)
   && (0 == g_stoamregmap[ulindex].ulseq))
  {
   g_stoamregmap[ulindex].ulcommandid = stcmdmap.ulcommandid;
   g_stoamregmap[ulindex].ulseq = stcmdmap.ulseq;
   g_stoamregmap[ulindex].uldstpid = stcmdmap.uldstpid;
   return VOS_OK;
  }
 }

 return -1;
}

STATIC app_u32 app_oam_multi_register(st_oamreg_map *pstcmdmap, app_u32 ulnum)
{
 app_u32 ulresult = VOS_OK;
 app_u32 ulindex = 0;

 for (ulindex = 0; ulindex < ulnum; ulindex++)
 {
  ulresult = app_oam_register(pstcmdmap[ulindex]);
  if (VOS_OK != ulresult)
  {
   return ulresult;
  }
 }

 //!!!这里可以进行2级排序操作，但本注册功能只在本模块使用，因此简单处理，不进行排序操作了
 //!!!维护该模块的同事需要特别注意，注册时务必保证排序正确
 //!!!先按照命令排序，然后序号排序(要求从小到大) 
 Qsort(g_stoamregmap, 0, ulnum-1);
 
 return ulresult;
}

int _tmain(int argc, _TCHAR* argv[])
{
 app_u32 ulrunrslt = VOS_OK;
 vos_u32 ulindex = 0;

 //初始化oam注册映射
 app_oam_initoamregmap();

 //!!!注意以下数组注册必须保证顺序，否则执行中时序将会出错!!!
 //!!!顺序为: 先按命令字，再按序号(从0开始，必须从小到大)!!!
 static const st_oamreg_map s_oamreg[] =
 {
  //暂停
  {0x8011, 23, 333},
  {0x8011, 0, 111},
  {0x8003, 0, 777},

  //恢复
  {0x8001, 0, 444},
  {0x8001, 1, 555},
  {0x8003, 2, 999},
  {0x8001, 2, 666},

  //停止  
  {0x8003, 1, 888},  
  {0x8003, 3, 1000},
  {0x8003, 4, 2000},
  {0x8003, 5, 3000},
  {0x8011, 1, 222},
 };

 ulrunrslt = app_oam_multi_register((st_oamreg_map*)s_oamreg, sizeof(s_oamreg)/sizeof(s_oamreg[0]));
 if (VOS_OK != ulrunrslt)
 {
  return ulrunrslt;
 }

 for (ulindex = 0; ulindex < g_maxoamregnum; ulindex++)
 {
  printf("0x%x 0x%x %d \n", g_stoamregmap[ulindex].ulcommandid,
   g_stoamregmap[ulindex].ulseq, g_stoamregmap[ulindex].uldstpid);
 }

 return VOS_OK;

}