久久国产精品久久,国产日韩久久久精品影院首页,久久久久久亚洲精品影院

zlf — Thu, 24 Dec 2020 04:34:00 GMT

10�q�初搭徏的原始的AOSP工程。不知道官网现在�q�能不能下蝲到。从内核到开发调试工��L��所有东襉K��可以�~�译出来�Q�包括：内核、虚拟机、Framework、Java应用、手机模拟器、log工具、调试工兗��开发用的Eclipse插�g、SDK、、NDK�{��?br />链接�Q?/strong>https://gitee.com/zhulf753/repo/tree/master/Android/Ubuntu10.04

Drop here!

zlf 2020-12-24 12:34 发表评论

UCOS2�U�L��到cortex-M0

zlf — Sat, 23 Jun 2018 02:41:00 GMT
     摘要: �l�过别�h在板子上几天几夜的测试，跑了6�?个�Q务同时开�?�?个中断，CPU满负荗��完全没问题�Q�已�l�用在��品上。主要就修改一个文件os_cpu_a.asm和�Q务创建时堆栈初始化代码。花了两天时��_��以前没接触过cortex-m0也没写过汇编�Q�多�q�没接触�q�单片机了）。以下是os_cpu_a.asm。有不少的草�E�代码，应该不媄响阅�ȝ��Q�请自行忽略�?***************************...  阅读全文

zlf 2018-06-23 10:41 发表评论

yuv格式解析

zlf — Tue, 01 Nov 2016 10:01:00 GMT
     摘要: 相关标准描述参考网站：http://www.fourcc.org/ 参考解析工具和囄��参考网站：http://www.sunrayimage.com/examples.html �|�上有很多解析YUV格式的工��P��觉得�q�是sunrayimage的工��h��较全�q�有�C�Z��囄��?只有代码�Q�花半天旉��折腾出来的�?Code highlighting produced by Actipro CodeHig...  阅读全文

zlf 2016-11-01 18:01 发表评论

递归的非递归写法

zlf — Fri, 11 Jan 2008 09:15:00 GMT

#include
#include
#include
using namespace std;
template >
class zlfStack {
public:
typedef unsigned _Ty;
typedef _C::allocator_type allocator_type;
typedef _C::value_type value_type;
typedef _C::size_type size_type;
typedef _C::iterator zlfIterator;
protected:
_C c;
public:
inline
const value_type& zlfTop2(){
  return *(c.end()-2);
}
inline
const value_type& zlfTop3(){
  return *(c.end()-3);
}
inline
void top_3(value_type& x,value_type& y,value_type& b)
{
  b=*(c.end()-1);
  y=*(c.end()-2);
  x=*(c.end()-3);
}
inline
void top_2(value_type& x,value_type& y)
{
y=*(c.end()-2);
x=*(c.end()-3);
}

//zlfStack(){ }
explicit zlfStack(const allocator_type& _Al = allocator_type())
  :c(_Al){}
allocator_type get_allocator() const
{return (c.get_allocator()); }
bool empty() const
{return (c.empty()); }
size_type size() const
{return (c.size()); }
value_type& top()
{return (c.back()); }
const value_type& top() const
{return (c.back()); }
void push(const value_type& _X)
{c.push_back(_X); }
inline
void push_3(const value_type& x,const value_type& y,const value_type& b)
{
  c.push_back(x);
  c.push_back(y);
  c.push_back(b);
}
inline
void pop()
{c.pop_back(); }
};///
enum{B0=0,B1=1,B2=2,B3=3};
int A(unsigned x,unsigned y)
{
static count=0;
if (!x&&!y) {return ++count;return count;}
if (x==0xffff) {count=0;return 0;}
if (x) A(--x,y);
AB1: if(y) A(x,--y);
AB2:
  return count;

}
inline
void clear(){A(0xffff,0);}
zlfStack s;
inline
void push(unsigned x,unsigned y,unsigned b)
{
s.push(x);
s.push(y);
s.push(b);
}
inline
void pop(unsigned& x,unsigned& y,unsigned& b)
{
b=s.top();
s.pop();
// y=s.top();
s.pop();
// x=s.top();
s.pop();
}

int main()
{
unsigned x=1,y=1,b=1,c=0,z=0;
unsigned temp=0;
clock_t t1,t2;
unsigned k=1;
unsigned long sum1=0,sum2=0,time1=0,time2=0;

cout<<"AAAA"< t1=clock();
for (x=1;x<10;x++) {
  for (y=1;y<10;y++) {
   clear();
   k=A(x,y);
   sum1+=k;
   cout<   cout<<"x="<  }
}
t2=clock();
time1=t2-t1;
cout<

if (!x&&!y) return 0;//exit
sum2 = 0;
t1=clock();
for (x=1;x<10;x++) {
  for (y=1;y<10;y++) {// push(x,y,B3);
  s.push_3(x,y,B3);
  c=0;
  b=B0;
  while (!s.empty()) {
   switch(b) {
   case B0:if(x) {//push(--x,y,B1);
    s.push_3(--x,y,B1);
    b=B0;continue;}
   case B1:if(y) {//push(x,--y,B2);
    s.push_3(x,--y,B2);
    b=B0;continue;}
   case B2:if (!x&&!y) c++;
   default:;
   }//switch
  // pop(x,y,b);
   b=s.top();
   s.pop();
   s.pop();
   s.pop();
   if(b==B3) break;//return to main
  // pop(x,y,temp);
  // push(x,y,temp);
  // y=s.zlfTop2();
  // x=s.zlfTop3();
   s.top_2(x,y);
  }//while
  sum2+=c;
// cout<<"c="<  }//y
}//x
t2=clock();
time2=t2-t1;
cout<<"time used :"< cout<<"routines :"< cout< double t;
cout<<"routines: "< t=sum1/time1;
cout< cout<<"routines: "< t=sum2/time2;
cout< return 0;
}

zlf 2008-01-11 17:15 发表评论

各搜索引擎搜索结果的获取

zlf — Thu, 10 Jan 2008 12:50:00 GMT

用http的get�Ҏ��Q�构造要查询的url�Q�get下来�Q�分析结果页面即�?br>首先是构造url�Q�以下是一些示例，主要看清�?号后面的参数所代表的意思即可：
http://www.google.cn/search?num=100&&q=%E5%85%83%E6%90%9C%E7%B4%A2&start=10

http://www.baidu.com/s?wd=%D4%AA%CB%D1%CB%F7&rn=100&pn=10 //�W�二��pn

http://www.yahoo.cn/s?p=%E5%85%83%E6%90%9C%E7%B4%A2&b=10 //�W�二��b

http://search.yahoo.com/search?n=100&p=%E5%85%83%E6%90%9C%E7%B4%A2&b=101

http://cnweb.search.live.com/results.aspx?q=%E5%85%83%E6%90%9C%E7%B4%A2&first=51 //�W�二��first=51

http://p.zhongsou.com/p?w=%D4%AA%CB%D1%CB%F7&b=3 //b=3表示�W�三��?/p>
http://www.soso.com/q?w=%D4%AA%CB%D1%CB%F7&num=20&pg=1 //�W�一��，每页20�?br>
�W�二步是解释搜烦�l�果��面�Q?br>

Google
搜烦�l�果个数的字�W�串前缀�Q�约�?lt;b> //获取个数用字�W�串定位的方�?br>搜烦�l�果开始的标签�Q?lt;div id=res> //也可以用字符串定位的方式�Q�要准确��q��查找标签定位的方�?br> 各个搜烦�l�果的开始标�{�：
//字符串定位的方式

  搜烦�l�果的url在第一�?lt;a target=_blank class=l>标签里头
  搜烦�l�果的标题在的标�{�之�?/p>
  搜烦�l�果的摘要在接下来的
标签里头直到...

  搜烦�l�果的重写的url�?lt;b>...
之后�?lt;span>标签里头�Q�格式�ؓ�Q�url�Q�一个空��|��|�页大小
  搜烦�l�果的网��快照在接下来的的标�{�N��_��属性中有url,标签之间有网��快照文�?br>  接下来还有类似网��늭��Q�都�?lt;a class=fl>标签里头

各个搜烦�l�果的结束标�{�是

......................

相关搜烦的开始标�{�：

在接下来的各�?lt;a>标签之间的内容就是相��x��索的内容
直到标签
��可以结束了

Baidu
搜烦�l�果个数的字�W�串前缀�Q?lt;td align=\"righ�Q�在定位该字�W�串后，直到,卛_��q�个td标签之内含有的字�W�串包含相关�|�页数和用时
搜烦�l�果开始的标签�Q?lt;DIV id=ScriptDiv>
各个搜烦�l�果的开始标�{�：
  搜烦�l�果的url在第一�?lt;a target=_blank class=l>标签里头
  搜烦�l�果的标题在的标�{�之�?�?lt;br>标签�l�束

  搜烦�l�果的摘要以
开始直��C��一�?lt;br>标签

  接下来的一行（
换行�Q�的font标签中有搜烦�l�果url的重写，一个空��|��|�页大小�Q�网��|��?br>  在接下来会有一�?lt;a>标签如百度快照，直到又一�?lt;br>

然后搜烦�l�果的结束标�{?lt;/table>

.........................

��D��条的开始标�{�：

��D��条的内容在开始标�{�之后的
标签之间
相关搜烦在接下来�?lt;div>标签之间的各�?lt;a>标签之内

其他考虑�Q�对于字�W�串的匹配可以利用kmp�Q�注意到匚w��搜烦�l�果各部分的时候所用到的模式字�W�串的最大前�~�字符串最多是一个字�W�，�q�样可以避免求取最大前�~�字符串从而提高效率；如果要精��地匚w��q�需要弄两个函数�Q�一个用来构造标�{�，一个用来读取标�{�之间的文本�?/p>

zlf 2008-01-10 20:50 发表评论

序列化探�?

zlf — Mon, 08 Oct 2007 03:00:00 GMT

序列化探�?/a>

主要��是解释readobject和writeobject函数,应该够了�Q�至于在DOC/VIEW模型�U��用的�?应该很简单的

0---�I�指�?/span>   7FFF---大烦引号标志�Q�即后面的烦引号�?/span>32位的

0X8000---保留以后使用   0XFFFF---新类的定�?/span>

��烦引对象或者类的烦引号:1~~~7FFE,但是�cȝ��最高位�?/span>1

对象的插入：writeobject函数�Q�（全局插入<<函数只是调用了这个函敎ͼ�首先插入�c�M��息，然后是对象信息。每�ơ写入（即一��?/span>writeobject函数的执行流�E�）是下面三�U�的之一�Q?/span>

1           若是未写�q�的�c�dƈ且未被写�q�的对象�Q?/span>

1.1 写入新类标志�Q?/span>0XFFFF       *this << wNewClassTag;

1.2 写入�cȝ��版本��P��写入�c�d��的字�W�串长度�Q?/span>ar << (WORD)m_wSchema << nLen;

1.3 写入�c�d�� ar.Write(m_lpszClassName, nLen*sizeof(char));

1.4 写入对象              ((CObject*)pOb)->Serialize(*this);

2           若是曄��写过的类�q�且未写�q�的对象�Q?/span>

2.1 写入�cȝ��索引�?/span> nClassIndex = (DWORD)(*m_pStoreMap)[(void*)pClassRef]

如果是小索引�c�：则写入类*this << (WORD)(wClassTag | nClassIndex);

如果是大索引�c�：则写入大索引��h��志（7FFF�Q�和32位的�cȝ��引号�Q�最高位�?/span>1�Q?/span>                     *this << wBigObjectTag;

                     *this << (dwBigClassTag | nClassIndex);

2.2   写入对象              ((CObject*)pOb)->Serialize(*this);

3           若是曄��写过的类�q�且曄��写过的对象：

3.1 写入对象的烦引号

       如果是小索引对象�Q�则直接写入索引�?/span>*this << (WORD)nObIndex;

       如果是大索引对象�Q�则写入大烦引号标志�?/span>32位的对象索引��P��最高位�?/span>0�Q?/span>

                     *this << wBigObjectTag;

                     *this << nObIndex;

以上3�U�情�늚�写入都是首先写入一个字�Q�这个字的内容就代表了之后字节即�c�M��息的意义或者可以只是一个对象的索引��P��情况三）�Q�即是新�c�（字节�?/span>0xFFFF�Q�还是已�l�定�q�的��烦引类�Q�烦引号�?/span>0x8001�?xFFFE�Q�又或者是已经定义�q�的大烦引类�?/span>(字节0x7FFF后箋两个字节为烦引号)�?/span>

对于��d��上面文�g格式的信息�ƈ且区分出��要��d��的是�c�还是对象，是烦引还是对象数据，�?/span>readObject�?/span>

首先��d��一个字如果�?/span>0XFFFF则显然对应的是第一�U�情况，此时可以�Ҏ��地读取数据；如果�W�一个字的最高位�?/span>1的话�Q�很昄��此时对应的就是第二种情况�Q�即该字是一个类的烦引号�Q�而且是小索引�c�；如果�?/span>0x7FFF则此时对应的��是�W�三�U�情况大索引号对象或者第二种情况大烦引号�c�；如果最高位不是1则此时对应的也是�W�三�U�情况但是小索引对象�Q�在区分了第一个字以后��可以容易地��d��后面的数据。这��h��ơ的readObject函数的调用都只是提取以往某次writeObject函数写入的数据�?/span>

对象的提�?/span>:ReadObject函数�Q�因为在�?/span>IMPLEMENT_SERIAL里定义的提取操作�W�只是简单地调用了这个函数。首先提取类信息�Q�以便正��地动态生成对象，然后是对象信息�?/span>

PS:m_pStoreMap里即包含了已�l�序列化的类�Q?/span>CRuntimeClass�Q�和对象的指针�?/span>

UINT CArchive::GetObjectSchema()函数只能调用一�ơ，一般该函数在某个类�Q?/span>ar正在序列化的�c�）�?/span>Serialize函数里头调用�Q�它�q�回��d��的类的版本号。以下几行来�?/span>readObject:

              UINT nSchemaSave = m_nObjectSchema;

              m_nObjectSchema = nSchema;

              pOb->Serialize(*this);

              m_nObjectSchema = nSchemaSave;

一般地�Q�也正是�?/span>serialize里头来处理各�U�版本的序列化�?/span>

FAQ:

1�Q?nbsp;��Z��么可以定义全局的插入操作符�Q�而提取操作符却要�Ҏ��个类在宏里头声明�Q?/span>

插入操作的是在已知对象所有信息的情况下的操作�Q�包括对象的�c�d��和状态，�c�M��息的写入使用CruntimeClass非静�?/span>成员函数Store来实现的�Q��?/span>GetCRuntime成员函数又是虚函数所以可以用指向COBJECT的指针来正确地获取，然后正确地调�?/span>STORE函数�Q�而对于提取操作，��要提取出的对象的类型和状态都是未知，提取�c�M��息主要是�?/span>CruntimeClass�?/span>静�?/span>成员LOAD来获取，该成员获得文件中�c�M��息之后通过查找全局的类型链表可以唯一地确定一�?/span>CrutimeClass�c�d��的静态对象，通过该对象的createObject函数可以构造出卛_��提取的对象类型，然后利用动态构造的对象的序列化函数��可以正��地提取出对象，因�ؓ

1�Q?/span>1       在宏定义的提取操作符�?/span>classname参数是无法用COBJECT�c�L��替换�Q�因为如果替换的话则在提取信息过�E�中即��出现错误�Q�比如说提取出的�c�d��Ҏ��׃��是可序列化的但是如果�l�承�?/span>COBJECT的话仍然可以通过错误��查�?/span>

zlf 2007-10-08 11:00 发表评论

zlf — Fri, 05 Oct 2007 07:47:00 GMT

#include
#include
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
template
class AVL_TMP
{
template
class AVL_NODE
{
public:
  AVL_NODE():ln(0),rn(0),depth(0){}
  AVL_NODE( const E& e):data(e),ln(0),rn(0),depth(0){}
  ~AVL_NODE(){ if (ln) delete ln; if (rn) delete rn; }

  bool operator < (E& e){  return data < e; }
  bool operator > (E& e){  return data > e; }
  bool operator == (E& e){ return data == e; }
  bool operator != (E& e){ return data != e; }

  E getdata(){return data;}

  E data;
  int depth;
  AVL_NODE *ln,*rn;
};

public:
typedef E dataType;
typedef AVL_TMP Myt;
typedef AVL_NODE n;
typedef n* npos;
typedef npos iterator;
enum unbalanceType {LL,RR,LR,RL};
AVL_TMP():root(0),size(0),depth(-1){}
~AVL_TMP(){ if(root) delete root; }

iterator begin(){return root;}
bool insert(const E& e);
npos find(const E& e);
npos findpre(const E& e);
bool del(dataType);
bool balance(AVL_TMP::iterator pos){
  if(pos == NULL) throw 0;
  int lh,rh;
  if(pos->ln == NULL ) lh = -1;
  else lh = pos->ln->depth;
  if(pos->rn == NULL ) rh = -1;
  else rh = pos->rn->depth;
  return abs( lh - rh ) < 2 ;
}
virtual void frontOrder(){};
virtual void midOrder(){ };

protected:
void LLr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos);
void LRr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos);
void RRr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos);
void RLr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos);
void updateDepth(AVL_TMP::iterator pos);
bool delAux(E const& e,AVL_TMP::iterator pos = NULL);
iterator findMax(iterator );
iterator findMin(iterator );
bool upTree(int iDepth,iterator itRoot,unsigned long iSize){depth = iDepth;root = itRoot;size = iSize; return true;}
bool upRoutineDepth(vector&);
bool adjust(iterator a,iterator b,iterator c,iterator prePos = NULL);
npos root;
int depth;
unsigned long size;
};
template
bool AVL_TMP::adjust(iterator a,iterator b,iterator c,iterator prePos){
bool b1,b2;
b1 = b == a->ln;
b2 = c == b->ln;
unbalanceType ub;
if(b1&&!b2)   ub = LR;
if(!b1&&b2)   ub = RL;
if(b1&&b2)    ub = LL;
if(!b1&&!b2) ub = RR;
switch(ub) {
  case LL :LLr(a,prePos);
   break;
  case LR :LRr(a, prePos);
   break;
  case RR :RRr(a,prePos);
   break;
  case RL :RLr(a,prePos);
   break;
} //end switch
return true;
}
template
bool AVL_TMP::upRoutineDepth(vector&routine){
//该函��C��要是��\径节点的深度更新�q�且使得那些不��^衡的节点�q��
int size = routine.size();
while (size--) {
  updateDepth(routine[size]);
  if (!balance(routine[size])) {//不��^衡得调整
   iterator cur = routine[size],prePos = NULL;
   if(size-1>=0)
    prePos = routine[size-1];
   //��查当前不�q��节点的哪颗子树的高度更高
   bool bl = cur->ln != NULL;
   bool br = cur->rn != NULL;
   if (!bl) {//肯定有右孩子
    if(cur->rn->ln) RLr(cur,prePos);
    else RRr(cur,prePos);
   }
   else{//有左孩子
    if (!br) {//没右孩子
     if (cur->ln->ln) LLr(cur,prePos);
     else LRr(cur,prePos);
    }
    else{ //有右孩子,此时需要检查左叛_��子的高度�Q�则叛_��树高度至��ؓ1
     //因此左子树高度至��ؓ3�Q�则左子树的节点个数肯定大于4
     if (cur->ln->depth > cur->rn->depth) LLr(cur,prePos);
     else RRr(cur,prePos);
    }
   }
  }
}
return true;
}
template
AVL_TMP::iterator AVL_TMP::findMax(AVL_TMP::iterator pos){//以pos为根的树的最大值的节点
if (!pos) return NULL;
iterator p = pos;
while(p->rn) p = p->rn;
return p;
}
template
AVL_TMP::iterator AVL_TMP::findMin(AVL_TMP::iterator pos){
iterator p = pos;
while (p->ln) p = p->ln;
return p;
}
template
void AVL_TMP::updateDepth(AVL_TMP::iterator pos){
bool b1 = pos->ln == NULL,b2 = pos->rn ==NULL;
switch(b1) {
case true:
  if(b2) pos->depth = 0;
  else pos->depth = pos->rn->depth+1;
  break;
default: //false
  if(b2) pos->depth = pos->ln->depth+1;
  else pos->depth = max(pos->ln->depth , pos->rn->depth )+1;
}
if(pos == root) depth = pos->depth;
}
template
void AVL_TMP::LLr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos){
typename AVL_TMP::iterator t, a = pos, b = t = pos->ln ;
pos->ln = t->rn;
t->rn = pos;
if(root == a) root = b;
if(prePos != NULL)
  if(prePos->ln == a) prePos->ln = b;
  else prePos->rn = b;
updateDepth(a);updateDepth(b);
}
template
void AVL_TMP::LRr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos){
AVL_TMP::iterator a = pos,b = pos ->ln, c = b->rn;
b->rn = c->ln ; a->ln = c->rn;
c->ln = b; c->rn =a;
if(a == root ) root = c ;
if(prePos != NULL)
  if(prePos->ln == a) prePos->ln = c;
  else prePos->rn = c;
updateDepth(a);updateDepth(b);updateDepth(c);
}
template
void AVL_TMP::RRr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos ){
AVL_TMP::iterator a = pos ,t, b = t = pos->rn ;
pos->rn = t->ln;
t->ln = pos;
if(prePos != NULL)
  if(prePos->ln == a) prePos->ln = b;
  else prePos->rn = b;
if(root == a) root = b;
updateDepth(a);updateDepth(b);
}
template
void AVL_TMP::RLr(AVL_TMP::iterator pos,AVL_TMP::iterator prePos){
AVL_TMP::iterator a = pos, b = pos->rn , c = b->ln;
a->rn = c->ln ; b->ln = c->rn;
c->ln = a; c->rn = b;
if(prePos != NULL)
  if(prePos->ln == a) prePos->ln = c;
  else prePos->rn = c;
if( a == root) root = c;
updateDepth(a);updateDepth(b);updateDepth(c);
}
template
bool AVL_TMP::insert(const E& e){
if(root == NULL) {root = new AVL_NODE(e); size++; depth = root->depth;return true;}
bool bUpdateDepth = false;
vector::iterator> routin;
typename AVL_TMP::iterator p = root,pos,prePos;
for (int i = 0 ; i < size ;i++ ) {
  routin.push_back(p);
  if(p->data > e){
   if ( p->ln == NULL ) {
    p->ln = pos = new AVL_NODE(e);
    bUpdateDepth = p->rn == NULL;
    break;
   }
   else { p = p->ln ; continue;}
  }
  if(p->data < e){
   if (p->rn == NULL) {
    p->rn = pos = new AVL_NODE(e) ;
    bUpdateDepth = p->ln == NULL;
    break;
   }
   else { p = p->rn ; continue;}
  }
  return false;   //already exists
}  //insertion finished
size++;
if(size <= 2 ) {
  updateDepth(root);
  return true;
}
if(!bUpdateDepth) return true;   //balance

bool unAdjusted = true;
// check for balance and adjust depth
for (i = routin.size()-1; i >=0 ; i-- ) {
  if(!balance(routin.at(i)))
   if(unAdjusted) { // unbalance! get unbalance type
    if(i-1 >= 0) prePos = routin.at(i-1);
    else prePos = NULL;
    AVL_TMP::iterator a = routin.at(i) , b = routin.at(i+1) , c;
    if(i+2 >= routin.size() ) c = pos;
    else c = routin.at(i+2);
    bool b1,b2;
    b1 = b == a->ln;
    b2 = c == b->ln;
    unbalanceType ub;
    if(b1&&!b2)   ub = LR;
    if(!b1&&b2)   ub = RL;
    if(b1&&b2)    ub = LL;
    if(!b1&&!b2) ub = RR;

    switch(ub) {
     case LL :LLr(routin.at(i),prePos);
      break;
     case LR :LRr(routin.at(i),prePos);
      break;
     case RR :RRr(routin.at(i),prePos);
      break;
     case RL :RLr(routin.at(i),prePos);
      break;
    } //end switch
    unAdjusted = false;
   } //end if
updateDepth(routin.at(i));  //update the depth of the node in the routin
depth = root->depth;
}//end for
return true;
};
template
AVL_TMP::npos AVL_TMP::find(const E& e){//search for position
   npos p=root;
   while (p&&p->data!=e)
    if(e>p->data) p=p->rn;
    else p= p->ln;
   return p;
}
template
AVL_TMP::npos AVL_TMP::findpre(const E& e){//search for parent node position
   npos p,pre;
   p=pre=root;
   while (p&&p->data!=e) {
    pre = p;
    if (e>p->data) p=p->rn;
    else p = p->ln;
   }
   if(p) if(p->data==e) return NULL;//already existed
   return pre;
}
template
bool AVL_TMP::delAux(E const& e,AVL_TMP::iterator pos){
// 1.递归删除节点�Q�直到删除的是叶子节�?nbsp;
// 2. 删除叶子节点,更新树的数据成员
// 3. 更新路径上的节点深度�q�且��查��^衡因�?nbsp;
static vector routine;
iterator p = pos;
bool bUpdate = false;
if(!pos){//�W�一�ơ调�?br>  p = root;
  while (p&&e!=p->data) {//扑ֈ�节点�Q��ƈ且将��L��路径存入表中
   routine.push_back(p);
   if(p->data > e) p = p->ln;
   else p = p->rn;
  }
  if(p == NULL){ //没找�?br>   routine.clear();
   return false;
  }
  else pos = p;
}
if (pos->ln||pos->rn) {//不是叶子节点�Q�则该节�Ҏ��孩子节点�Q�可能是一个或者两�?br>  routine.push_back(pos);//�q�得往下删�?br>  if (pos->ln&&!pos->rn){ //情况一: 只有有左孩子
   //扑ֈ�左子树中的最大值的位置
   iterator max = pos->ln;
   while (max->rn) { routine.push_back(max); max = max->rn;}
   bUpdate = false;
   //伪删�?br>   pos->data = max->data;
   delAux(max->data,max);
  }
  else if (!pos->ln&&pos->rn) { //情况二：只有叛_��?br>   //扑ֈ�叛_��树中的最��?br>   iterator min = pos->rn;
   while (min->ln) { routine.push_back(min); min = min->ln;}
   bUpdate = false;
   //伪删�?br>   pos->data = min->data;
   delAux(min->data,min);
  }
  else //情况三：有俩个孩�?br>  {
   //扑ֈ�左子树中的最大�?br>   iterator max = pos->ln;
   while (max->rn) { routine.push_back(max); max = max->rn;}
   bUpdate = false;
   //伪删�?br>   pos->data = max->data;
   delAux(max->data,max);
  }
}
else
{//是叶子节�?br>  //有三�U�情况，是其父节点的左子树且没有兄弟�Q�是其父节点的右子树且没有兄弟，有兄�?br>  //取得其父节点
  iterator parent = NULL;
  if (routine.size()) //有父节点
   parent = routine[routine.size()-1];
  else{//卌��节点是根节点,无根节点
   delete root;
   routine.clear();
   upTree(-1,NULL,0);
   return true;
  } //完成根节点的删除
  //有父节点
  if (pos == parent->ln&&!parent->rn) {//情况一�Q�是父节点的左孩子且没兄�?br>   //删除节点
   parent->ln = NULL;
   delete pos;
   //需要更新�\径上的节点的深度
   bUpdate = true;
   upRoutineDepth(routine);
   upTree(root->depth,root,size-1);
   routine.clear();
   //改写父节点的孩子指针
  }//完成情况一叶子节点的删�?br>  else{
   if (pos == parent->rn && !parent->ln ) { //情况二：是父节点的右孩子且没兄弟
    parent->rn = NULL;
    delete pos;
    bUpdate = true;
    upRoutineDepth(routine);
    upTree(root->depth,root,size-1);
    routine.clear();
   }//完成情况二叶子节点的删除
   else{//情况三：有兄�?br>    //只需要将节点删除�Q��ƈ清理路径表就可以�?br>    if (pos == parent->ln) parent->ln = NULL;
    else parent->rn = NULL;
    delete pos;
    routine.clear();
   }//完成情况三的叶子节点删除
  }
}
return true;
}

template
bool AVL_TMP::del(dataType e){
return delAux(e);
}

zlf 2007-10-05 15:47 发表评论

zlf — Fri, 14 Sep 2007 06:41:00 GMT

#include
#include
const int QUENS = 7;
int getcol(int q[],int n,const int firstCol)
{//q表示每个皇后的列位置�Q�firstCol是搜索列位置时的起始位置
//n表示正在搜烦�W�n个皇后的列位�|?皇后的名�U�C��0--n�~�号�Q�也是皇后的行号
bool b = true;
int i = firstCol;
for (i = firstCol; i<=QUENS ; i++) {
  for (int j=0; j   if(q[j] == i || (n+q[j]==i+j)||(n+i == j+q[j])){
    b = false;
    break;
   }
  }
  if(j == n)
    return i;
  else if(firstCol > QUENS) return firstCol;
}
if(!b) return QUENS+1;
}
void EQ(int q[],int n){
void disp(int[]);
int col = QUENS+1;
bool b = true;
int firstCol = 0;
while (QUENS >= (col=getcol(q,n,firstCol))){
  if(QUENS == n){
   q[n] = col;
   disp(q);
   return ;
  }
  else{
   q[n] = col;
   firstCol = col +1;
   EQ(q,n+1);
  }
}

}
void disp(int q[])
{//昄��一�U�排�?br> static count = 0;
count++;
cout<<"number "< for (int i=0; i<=QUENS; i++)
  cout< cout<}
void outTofile()
{//�׃��l�果比较多，所以把�l�果重定向输出到文�g里头了，文�g名是EightQuen.txt
int old = _dup(1);
FILE* pf;
pf = fopen("EightQuen.txt","w");
if(!pf) throw 0;
_dup2((fileno(pf)),_fileno(stdout));
int q[8];
EQ(q,0);
fclose(pf);
_dup2(old,_fileno(stdout));

}
void main()
{
outTofile();
}

zlf 2007-09-14 14:41 发表评论