后面部分

void *min_malloc(uint_32 size)
{
    void *addr=NULL;
    uint_32 save_free;
 block *blk=NULL;
 block *blk_c=NULL;          /* 暂存block;*/
 block *blk_new=NULL;
 
 if ( memery == NULL) {
  memery = (void *)malloc(size);
  if(memery == NULL || size <= sizeof(block)) {
   printf("memery error/n");
   return addr;
  }
  blk = (block *)memery;
  blk->flag = 0;
  blk->free.pre = &(malloc_header.free);                       /* 首次申请时：将管理空闲的前指向null;*/
  blk->free.next = &(malloc_header.free);
  blk->all.pre = &(malloc_header.all);
  blk->all.next = &(malloc_header.all);
  malloc_header.all.pre = &(blk->all);                                    // 初始节点设置
  malloc_header.all.next = &(blk->all);
  malloc_header.free.pre = &(blk->free);
  malloc_header.free.next = &(blk->free);
  blk->adm_size = size - sizeof(block);
  save_size = size;
  addr = (void *)((uint_32)memery + sizeof(block));
 } else {
   blk  = (block *)((uint_32)(malloc_header.free.next)-offsetof(block,free));           //  将blk 指向头结点free_next 地址；
   while( blk->flag == 1 || blk->adm_size < size) {
     blk_c=blk;         /* 保存当前blk值，便于下一次blk 指向下一地址时可以对当前值操作 */                       
     blk = (block *)((uint_32)(blk->free.next) - offsetof(block,free));
     if(blk == &(malloc_header)) {
      printf("out of memery!/n");
            return addr;
     }
   }
   blk->flag = 1;
   save_free =  blk->adm_size - size;      //compare current blk->adm_size with size ,
            blk_c = blk;
   addr = (void *)((uint_32)blk + sizeof(block));
   blk_new = (block *)((uint_32)blk + size + sizeof(block));   /* 新建的block */
   if(blk_new < ((block *)((uint_32)memery + save_size - sizeof(block)) ) && (save_free > sizeof(block))) {
    blk_new->flag = 0;
    blk_new->adm_size = save_free - sizeof(block);
    blk_c->adm_size = size;     
    blk_new->all.next = blk_c->all.next;   //  the operate of all;change their pointer. 
                  blk_new->all.pre = &(blk_c->all);
        ((block *)((uint_32)(blk_c->all.next) - offsetof(block,all)))->all.pre = &(blk_new->all);
    blk_c->all.next = &(blk_new->all);             
    blk_new->free.pre = blk_c->free.pre;  // the operate to free block;
    blk_new->free.next = blk_c->free.next;
    ((block *)((uint_32)(blk_c->free.pre) - offsetof(block,free)))->free.next = &(blk_new->free);
    ((block *)((uint_32)(blk_c->free.next) - offsetof(block,free)))->free.pre = &(blk_new->free);
    blk_c->free.pre = NULL;
    blk_c->free.next = NULL;  
   } else {
    ((block *)((uint_32)(blk_c->free.pre) - offsetof(block,free)))->free.next = blk_c->free.next;
    ((block *)((uint_32)(blk_c->free.next) - offsetof(block,free)))->free.pre = blk_c->free.pre;
    blk_c->free.pre = NULL;
    blk_c->free.next = NULL;
   }
  }
 return addr;
}

void min_free(void *p )
{
 block *blk = NULL;
 block *blk_c = NULL;
 block *blk_temp = NULL;
 
 if (p > (void *)((uint_32 )memery + save_size) || (p < memery) || (((block *)((uint_32 )memery + save_size))->flag == 0)) {
  printf("unsuccess/n");
 } else {
  blk = (block *)((uint_32)p - sizeof(block));
  blk->flag = 0;  
  blk_c = blk;
  if(( ((block *)((uint_32)(blk->all.next) - offsetof(block,all)))->flag != 0) &&
   (((block *)((uint_32)(blk->all.pre) - offsetof(block,all)))->flag != 0) ) {
   blk->free.pre = &(malloc_header.free);
   blk->free.next = malloc_header.free.next;  
   ((block *)((uint_32)(malloc_header.free.next) - offsetof(block,free)))->free.pre = &(blk->free);
   malloc_header.free.next = &(blk->free);
  }
  else if(( ((block *)((uint_32)(blk->all.next) - offsetof(block,all)))->flag == 0) &&
   (((block *)((uint_32)(blk->all.pre) - offsetof(block,all)))->flag != 0) ) {
          blk = (block *)((uint_32)(blk_c->all.next) - offsetof(block,all));        //  将block 指向下一个节点；   

       /*   表示blk节点消亡；  */
    blk_c->adm_size = blk_c->adm_size + blk->adm_size + sizeof(block);
    blk_c->all.next = blk->all.next;
    ((block *)((uint_32)(blk->all.next)-offsetof(block,all)))->all.pre = &(blk_c->all);    // 将当前block的all_link下一个block的all_pre 指向合并后的block;
    blk->all.pre = NULL;  //
    blk->all.next = NULL;

    /*   将free的block并入下一个节点    */
    blk_c->free.pre =  blk->free.pre;                       
    blk_c->free.next = blk->free.next;
    ((block *)(((uint_32)blk->free.next)-offsetof(block,free)))->free.pre = &(blk_c->free);
    ((block *)((uint_32)(blk->free.pre)-offsetof(block,free)))->free.next = &(blk_c->free);  
   }
         else if(( ((block *)((uint_32)(blk->all.next) - offsetof(block,all)))->flag != 0) &&
    (((block *)((uint_32)(blk->all.pre) - offsetof(block,all)))->flag == 0) ) {
        blk = (block *)((uint_32)(blk_c->all.pre) - offsetof(block,all));         //    将block 指向前一个节点；

                /*   表示blk_c节点消亡；  */
          blk->adm_size = (blk->adm_size + blk_c->adm_size + sizeof(block));
    blk->all.next = blk_c->all.next;         // 将当前block 的all_next 指向blk_c的下一个block节点?    ((block *)((uint_32)(blk_c->all.next) - offsetof(block,all)))->all.pre = &(blk->all);
    ((block *)((uint_32)(blk_c->all.next)-offsetof(block,all)))->all.pre = &(blk->all);
    blk_c->all.next = NULL;
    blk_c->all.pre = NULL;       
   }
              else if((((block *)( (uint_32)(blk->all.next) - offsetof(block,all))) ->flag == 0)&&
    (((block *)((uint_32)(blk->all.pre) - offsetof(block,all)))->flag == 0) ) {      
    blk = (block *)((uint_32)(blk_c->all.pre)-offsetof(block,all));
    blk_temp = (block *)((uint_32)(blk_c->all.next)-offsetof(block,all));
    blk->adm_size = blk->adm_size + blk_c->adm_size + blk_temp->adm_size + sizeof(block) + sizeof(block);

    /*   被合并节点消亡  */   
    blk->all.next = blk_temp->all.next;
    ((block *)((uint_32)(blk_temp->all.next)-offsetof(block,all)))->all.pre = &(blk->all);
    blk_c->all.pre = NULL;
    blk_c->all.next = NULL;
    blk_temp->all.pre = NULL;
    blk_temp->all.next = NULL;

    /*   将被合并的block节点进行删除  */
    ((block *)(((uint_32)blk_temp->free.next)-offsetof(block,free)))->free.pre =
     &(((block *)((uint_32)(blk_temp->free.pre)-offsetof(block,free)))->free); // blk的free的下一个节点的free.pre指向合并的&blk_c->free;
    ((block *)((uint_32)(blk_temp->free.pre)-offsetof(block,free)))->free.next =
     &(((block *)(((uint_32)blk_temp->free.next)-offsetof(block,free)))->free);
   }
   }  
}