久久亚洲欧洲国产综合,国产精品99久久精品,久久人人超碰精品CAOPOREN

C��加 — Thu, 09 Aug 2012 08:56:00 GMT

一步一步写二叉查找�?/strong>

作者：C��加更新旉��Q?/span>2012-8-9

二叉查找树（BST�Q�是二叉树的一个重要的应用�Q�它在二叉树的基��上加上了�q�样的一个性质�Q�对于树中的每一个节�Ҏ(gu��)��_��如果有左儿子的话�Q�它的左儿子的��g��定小于它本��n的��|��如果有右儿子的话�Q�它的右儿子的��g��定大于它本��n的倹{�?/span>

二叉查找树的操作一般有插入、删除和查找�Q�这几个操作的��^均时间复杂度都�ؓO(logn)�Q�插入和查找操作很简单，删除操作会复杂一点，除此之外�Q�因��Z��叉树的中序遍历是一个有序序列，我就额外加上了一个中序遍历操作�?/span>

二叉查找树的应用不是很多�Q�因为它最坏的时候跟�U�性表差不多，大部分会应用到它的升�U�版�Q��^衡二叉树和红黑树�Q�这两棵树都能把旉��复杂度稳定在O(logn)左右。虽然不会用刎ͼ�但是二叉查找树是一定要学好的，毕竟它是�q��二叉树和�U�黑树的基础�?/span>

接下来一步一步写一个二叉查找树模板�?a href="/Files/cxiaojia/bst.zip">完整代码下蝲

�W�一步：节点信息

二叉查找树的节点和二叉树的节点大部分是一��L��Q�不同的是，二叉查找树多了一个值出现的�ơ数。如�?/span>1昄��了二叉查找树的节点信息�?br />

代码如下�Q?/span>

//二叉查找树节点信�?/span>
template<class T>
class TreeNode
{
    public:
        TreeNode():lson(NULL),rson(NULL),freq(1){}//初始�?/span>
        T data;//�?/span>
        unsigned int freq;//频率
        TreeNode* lson;//指向左儿子的坐标
        TreeNode* rson;//指向叛_��子的坐标
};

�W�二步：二叉查找树类的声�?/span>

代码如下�Q?/span>

//二叉查找树类的属性和�Ҏ(gu��)��声明
template<class T>
class BST
{
    private:
        TreeNode* root;//根节�?/span>
        void insertpri(TreeNode* &node,T x);//插入
        TreeNode* findpri(TreeNode* node,T x);//查找
        void insubtree(TreeNode* node);//中序遍历
        void Deletepri(TreeNode* &node,T x);//删除
    public:
        BST():root(NULL){}
        void insert(T x);//插入接口
        TreeNode* find(T x);//查找接口
        void Delete(T x);//删除接口
        void traversal();//遍历接口

};

�W�三步：插入

�Ҏ(gu��)��二叉查找树的性质�Q�插入一个节点的时候，如果根节点�ؓ�I�，��此节点作�ؓ根节点，如果根节点不为空�Q�就要先和根节点比较�Q�如果比根节点的值小�Q�就插入到根节点的左子树中，如果比根节点的值大��插入到根节点的叛_��树中�Q�如此递归下去�Q�找到插入的位置。重复节点的插入用值域中的freq标记。如�?/span>2是一个插入的�q�程�?/span>

二叉查找树的旉��复杂度要看这��|��的�Ş态，如果比较接近一一��完全二叉树�Q�那么时间复杂度�?/span>O(logn)左右�Q�如果遇到如�?/span>3�q�样的二叉树的话�Q�那么时间复杂度��׃��恢复到线性的O(n)了�?/span>

�q��二叉树会很好的解军_��?/span>3�q�种情况�?/span>

插入函数的代码如下：

//插入
template<class T>
void BST::insertpri(TreeNode* &node,T x)
{
    if(node==NULL)//如果节点为空,��在此节点处加入x信息
    {
        node=new TreeNode();
        node->data=x;
        return;
    }
    if(node->data>x)//如果x��于节点的�?��q��l�在节点的左子树中插入x
    {
        insertpri(node->lson,x);
    }
    else if(node->data//如果x大于节点的�?��q��l�在节点的右子树中插入x
    {
        insertpri(node->rson,x);
    }
    else ++(node->freq);//如果相等,��把频率�?
}
//插入接口
template<class T>
void BST::insert(T x)
{
    insertpri(root,x);
}

�W�四步：查找

查找的功能和插入差不多一��P��按照插入那样的方式递归下去�Q�如果找��C��Q�就�q�回�q�个节点的地址�Q�如果没有找刎ͼ��p��?/span>NULL�?/span>

代码如下�Q?/span>

//查找
template<class T>
TreeNode* BST::findpri(TreeNode* node,T x)
{
    if(node==NULL)//如果节点为空说明没找�?�q�回NULL
    {
        return NULL;
    }
    if(node->data>x)//如果x��于节点的�?��q��l�在节点的左子树中查找x
    {
        return findpri(node->lson,x);
    }
    else if(node->data//如果x大于节点的�?��q��l�在节点的左子树中查找x
    {
        return findpri(node->rson,x);
    }
    else return node;//如果相等,��找��C��此节�?/span>
}
//查找接口
template<class T>
TreeNode* BST::find(T x)
{
    return findpri(root,x);
}

�W�五步：删除

删除会麻烦一点，如果是叶子节点的话，直接删除��可以了。如果只有一个孩子的话，��p��它的父亲指向它的儿子�Q�然后删除这个节炏V��图4昄��了一��初始树�?/span>4节点被删除后的结果。先用一个��时指针指�?/span>4节点�Q�再�?/span>4节点的地址指向它的孩子�Q�这个时�?/span>2节点的右儿子��变成了3节点�Q�最后删除��时节�Ҏ(gu��)��向的�I�间�Q�也��是4节点�?/span>

删除有两个儿子的节点会比较复杂一些。一般的删除�{�略是用其右子树最��的数据代替该节点的数据�q��归的删除掉叛_��树中最��数据的节点。因为右子树中数据最��的节点肯定没有左儿子，所以删除的时候容易一些。图5昄��了一��初始树�?/span>2节点被删除后的结果。首先在2节点的右子树中找到最��的节点3�Q�然后把3的数据赋值给2节点�Q�这个时�?/span>2节点的数据变�?/span>3�Q�然后的工作��是删除叛_��树中�?/span>3节点了，采用递归删除�?/span>

我们发现�?/span>2节点叛_��树的查找�q�行了两遍，�W�一遍找到最��节点�ƈ赋��|��W�二遍删除这个最��的节点�Q�这��L��效率�q�不是很高。你能不能写出只查找一�ơ就可以实现赋值和删除两个功能的函数呢�Q?/span>

如果删除的次��C��是很多的话，有一�U�删除的�Ҏ(gu��)��会比较快一点，名字叫懒惰删除法�Q�当一个元素要被删除时�Q�它仍留在树中，只是多了一个删除的标记。这�U�方法的优点是删除那一步的旉��开销��可以避免了�Q�如果重新插入删除的节点的话�Q�插入时也避免了分配�I�间的时间开销。缺�Ҏ(gu��)��树的深度会增加，查找的时间复杂度会增加，插入的时间可能会增加�?/span>

删除函数代码如下�Q?/span>

//删除
template<class T>
void BST::Deletepri(TreeNode* &node,T x)
{
    if(node==NULL) return ;//没有扑ֈ�值是x的节�?/span>
    if(x < node->data)
    Deletepri(node->lson,x);//如果x��于节点的�?��q��l�在节点的左子树中删除x
    else if(x > node->data)
    Deletepri(node->rson,x);//如果x大于节点的�?��q��l�在节点的右子树中删除x
    else//如果相等,此节点就是要删除的节�?/span>
    {
        if(node->lson&&node->rson)//此节�Ҏ(gu��)��两个儿子
        {
            TreeNode* temp=node->rson;//temp指向节点的右儿子
            while(temp->lson!=NULL) temp=temp->lson;//扑ֈ�叛_��树中值最��的节点
            //把右子树中最��节点的��D��值给本节�?/span>
            node->data=temp->data;
            node->freq=temp->freq;
            Deletepri(node->rson,temp->data);//删除叛_��树中最��值的节点
        }
        else//此节�Ҏ(gu��)��1个或0个儿�?/span>
        {
            TreeNode* temp=node;
            if(node->lson==NULL)//有右儿子或者没有儿�?/span>
            node=node->rson;
            else if(node->rson==NULL)//有左儿子
            node=node->lson;
            delete(temp);
        }
    }
    return;
}
//删除接口
template<class T>
void BST::Delete(T x)
{
    Deletepri(root,x);
}

�W�六步：中序遍历

遍历的方法和二叉树的�Ҏ(gu��)��一��P��写这个方法的目的呢，是输��个二叉查找树的有序序列�?/span>

代码如下�Q?/span>

//中序遍历函数
template<class T>
void BST::insubtree(TreeNode* node)
{
    if(node==NULL) return;
    insubtree(node->lson);//先遍历左子树
    cout<data<<" ";//输出根节�?/span>
    insubtree(node->rson);//再遍历右子树
}
//中序遍历接口
template<class T>
void BST::traversal()
{
    insubtree(root);
}

到此�Q�整个代码就完成了，代码中肯定有很多不完善的地方��h��出，我会加以完善�Q�谢谢�?/span>



对于二叉查找树不�E�_��的时间复杂度的解��x��案有不少�Q��^衡二叉树、��展树和红黑树都可以解册��个问题，但效果是不一��L��?/span>

C��加 2012-08-09 16:56 发表评论

C��加 — Mon, 06 Aug 2012 03:26:00 GMT

基本数据�l�构�Q�二叉树�Q�binary tree�Q?/span>

作者：C��加更新旉��Q?/span>2012-8-6

二叉树首先是一��|��Q�每个节炚w��不能有多于两个的儿子�Q�也��是树的度不能超�q?。二叉树的两个儿子分别称�?#8220;左儿�?#8221;�?#8220;叛_��?#8221;�Q�次序不能颠倒。如�?是一个简单的二叉树�?br />

二叉树的�U�类

一�U�是满二叉树�Q�除了最后一层的叶子节点外，每一层的节点都必��L��两个儿子节点。如�?是一个满二叉树�?br />

另一�U�是完全二叉树，一��二叉树��L��最后一层后剩下的节点组成的树�ؓ满二叉树�Q�最后一层的节点从左到右�q�箋�Q�没有空出的节点�Q�这��L��树称为完全二叉树。如�?是一��完全二叉树�?br />

二叉树的实现

因�ؓ一��|��有最多只有两个儿子，所以我们可以用指针直接指向他们。一个节点包括��|��data�Q�、指向左儿子的指针（lson�Q�和指向叛_��子的指针�Q�rson�Q��?/span>

struct treenode
{
int data;
struct treenode* lson;
struct treenode* rson;

}

二叉树的插入,删除,查找和链表差不多,不同的是需要指定是左儿子还是右儿子�?/span>

二叉树的数组实现也很��单，假如说根节点在arr[0]�q�个位置�Q�那么它的左儿子��在arr[2*0+1]�Q�也��是arr[1]�q�个位置�Q�它的右儿子在arr[2*0+2] �Q�也��是arr[2]�q�个位置。对于下标�ؓi的节�Ҏ(gu��)��_��它的左儿子的下标�?*i+1�Q�右儿子的下标�ؓ2*i+2�?/span>

二叉树的遍历

二叉树的遍历有三�U�，分别为先序遍历，中序遍历和后序遍历。这三种遍历方式是根据根节点的读取顺序来分的�Q?/span>

先序遍历�Q�就是最先读取根节点�Q�然后再��d��左子树（按照同样的方法读取子树上的节点）�Q�最后读取右子树�Q?/span>

中序遍历�Q�就是第二个��d��根节点，最先要��d��的是左子树，然后根节点，最后右子树�Q?/span>

后序遍历�Q�就是最后一个读取根节点�Q�最先读取的是左子树�Q�第二个��d��叛_��树，最后读取根节点�?/span>

先序遍历的递归实现代码�Q?/span>

void insubtree�Q?span style="color: #0000FF; ">struct treenode* tree�Q?br />{
       If(tree==NULL) return;
       cout<data;
    insubtree(tree->lson);
insubtree(tree->rson);
}

C��加 2012-08-06 11:26 发表评论

C��加 — Fri, 03 Aug 2012 01:18:00 GMT

基本数据�l�构�Q�树�Q�tree�Q?/span>

作者：C��加更新旉��Q?/span>2012-8-3

无论是链表，栈还是队列，它们都是�U�性结构的�Q�每个节点的左边最多一个节点，双��也最多一个节点，对于大量的输入数据，�U�性表的访问时间太慢，不宜使用。这里我要说一�U�非�U�性的数据�l�构�Q�其大部分操作的�q�行旉��q�_��为O(logn)�?/span>

我们涉及到的�q�种数据�l�构叫做树。在计算机科学中�Q�树是非常有用的抽象概念。我们�Ş象的��L��q�C��|��Q�一个家族的老祖可能有两个儿子，�q�两个儿子一个有一个儿子，一个有三个儿子�Q�像�q�样发展下去的一个族谱，��是一个树�Q�如�?所�C��?/span>

��像一��늜�正的树一��P��我们把老祖�U�Cؓ树根,两个字儿是分叉开的两个树枝，�q�两��|��枝可以��l�向下分成N个树枝，循环下去�Q�一直到长出叶子为止�?/span>

我们把老祖或者树根称为根�Q�root�Q�节点，老祖的儿子称为子节点�Q�每个儿子作为根节点又可以�Ş成一��|��Q�我们把�q�样的树�U�Cؓ根节点的子树�?/span>

树的标准定义�Q?/span>

树（tree�Q�是包含n�Q�n>0�Q�个节点的有�I�集合，其中�Q?/span>

　　�Q?�Q�每个元素称��点（node�Q�；

　　�Q?�Q�有一个特定的节点被称为根节点或树根（root�Q��?/span>

�Q?�Q�除根节点之外的其余数据元素被分为m�Q�m≥0�Q�个互不�怺�的结合T1�Q�T2�Q?#8230;…Tm-1�Q�其中每一个集合Ti�Q?<=i<=m�Q�本�w�也是一��|��Q�被�U�C��原树的子树（subtree�Q��?/span>

树具有以下特点：

�Q?�Q?span style="font-size: 7pt; line-height: normal; font-family: 'Times New Roman'; ">    每个节点有零个或多个子节炏V�?/span>

�Q?�Q?span style="font-size: 7pt; line-height: normal; font-family: 'Times New Roman'; ">    每个子节点只有一个父节点�?/span>

�Q?�Q?span style="font-size: 7pt; line-height: normal; font-family: 'Times New Roman'; ">    没有父节点的节点�U�Cؓ根节炏V�?/span>

关于树的一些术�?/span>

节点的度�Q�一个节点含有的子树的个数称��节点的度�Q?/span>

叶节�Ҏ(gu��)��l�端节点�Q�度为零的节点称为叶节点�Q?/span>

非终端节�Ҏ(gu��)��分支节点�Q�度不�ؓ零的节点�Q?/span>

双亲节点或父节点�Q�若一个结点含有子节点�Q�则�q�个节点�U�Cؓ其子节点的父节点�Q?/span>

孩子节点或子节点�Q�一个节点含有的子树的根节点�U�Cؓ该节点的子节点；

兄弟节点�Q�具有相同父节点的节点互�U�Cؓ兄弟节点�Q?/span>

树的高度或深度：定义一��|��的根�l�点层次�?�Q�其他节点的层次是其父结点层�ơ加1。一��|��中所有结点的层次的最大值称��|��的深度。节点的层次�Q�从根开始定义�v�Q�根为第1层，根的子结点�ؓ�W?层，以此�c�L��Q?/span>

树的度：一��|��中，最大的节点的度�U�Cؓ树的度；

节点的祖先：从根到该节点所�l�分支上的所有节点；

子孙�Q�以某节点�ؓ根的子树中�Q一节点都称��节点的子孙�?/span>

��林�Q�由m�Q�m>=0�Q�棵互不�怺�的树的集合称为森林；

树的实现

节点的代码如�?

struct treenode
{
       int data;
       struct treenode *fistchild;//�W�一个儿�?/span>
struct treenode *nextsibling;//下一个兄�?/span>
}

树的应用

大部分操作系�l�的目录�l�构��是采用树结构�?/span>

树的�U�类有很多，树所扩展出来的很多数据结构都有着很大的作用，比如说红黑树�Q�B树，后缀树等�{�，�q�将在日后写到�?/span>

C��加 2012-08-03 09:18 发表评论

C��加 — Thu, 02 Aug 2012 07:00:00 GMT

基本数据�l�构�Q�队列（queue�Q?/span>

作者：C��加更新旉��Q?/span>2012-8-2

像栈一��P��队列�Q�queue�Q�也是一�U�线性表�Q�它的特性是先进先出�Q�插入在一端，删除在另一端。就像排队一��P��刚来的�h入队�Q�push�Q�要排在队尾(rear)�Q�每�ơ出�?pop)的都是队�?front)的�h。如�?�Q�描�q�C��一个队列模型�?/span>

和栈一��P��队列也有数组实现和链表实��C��U�，两种实现都能�l�出快速的O(1)�q�行旉��Q�区别在于链表实现指针域要占用空��_��频繁的new和delete会消耗不��的旉��开销�Q�数�l�实现唯一的缺�Ҏ(gu��)��建立时要��定�I�间大小�?/span>

假如一个队列最多只能站10个�h�Q�当占满10个�h后，�W?1个�h��׃��能入队，�q�种情况成�ؓ溢出。而如果第一个�h出队了，剩下�?个�h依然�q�在原来的位�|�，队列里空��Z��一个位�|�，但第11个�h�q�是不能入队�Q�这�U�情冉|��为假溢出。克服假溢出有效的办法是使用循环队列�?/span>

循环队列��是把队��֒�队首�q�接��h��Q��Ş成一个环�Q�队��下一个位�|�就是队首，�q�样可以有效的防止假溢出现象�Q�但队列的实际容量已然固定�?/span>

队列的实�?/span>

队列的数�l�实现和栈差不多�Q�不同的是，栈用top做下标，队列用front和rear作�ؓ下标�?/span>

我更改了单链表的模板来实��C��个简单的队列。代码仅供学习，不��之处�q�请指明�Q�我会对不��之处�q�行修改和更新�?/span>

代码如下�Q?br />
template<class T>
class queueNode
{
    public:
    queueNode():next(NULL){}
    T data;//�?/span>
    queueNode* next;//指向下一个节点的指针
};
template<class T>
class myqueue
{
    private:
    unsigned int queuelength;
    queueNode* node;//临时节点
    queueNode* rear;//队尾
    queueNode* front;//队首
    public:
        myqueue();//初始�?/span>
        unsigned int length();//队列元素的个�?/span>
        void push(T x);//入队
        bool isEmpty();//判断队列是否为空
        void pop();//出队
        T getHead();//获得队首元素

};
template<class T>
myqueue::myqueue()
{
    node=NULL;
    rear=NULL;
    front=NULL;
    queuelength=0;
}
template<class T>
inline unsigned int myqueue::length(){return queuelength;}

template<class T>
void  myqueue::push(T x)
{
    node=new queueNode();//甌��一个新的节�?/span>
    node->data=x;//新节点赋��gؓx
    if(rear==NULL)//如果没有��节点则队列为空,node既�ؓ队首,又是队尾
    {
        front=node;
        rear=node;
    }
    else//如果队列非空
    {
        rear->next=node;//node既�ؓ��节点的下一个节�?/span>
        rear=node;//node变成了尾节点,把尾节点赋��gؓnode
    }
    ++queuelength;//元素个数+1
}
template<class T>
bool  myqueue::isEmpty()
{
    return queuelength==0;
}
template<class T>
void  myqueue::pop()
{
    if(queuelength==0) return;
    node=front;
    front=front->next;
    delete(node);
    --queuelength;
}
template<class T>
T  myqueue::getHead()
{
    return front->data;
}

队列的应�?br />

打印机处理作业采用的��是队列�l�构�Q�它们会按照提交的顺序排列�v来。STL也给��Z��一个强大的队列�Q�我们直接可以去用它�?/span>

队列相关问题

如何用两个栈模拟一个队列，如果用两个队列模拟一个栈�Q?/span>

C��加 2012-08-02 15:00 发表评论

C��加 — Wed, 01 Aug 2012 08:51:00 GMT

基本数据�l�构�Q�栈�Q�stack�Q?/span>

作者：C��加更新旉��Q?/span>2012-8-1

栈（stack�Q�是限制插入和删除只能在一个位�|�上�q�行的线性表�Q�该位置在表的末端，叫做栈顶。添加元素只能在��节点后��d��Q�删除元素只能删除尾节点�Q�查看节点也只能查看��节炏V��添加、删除、查看依�ơ�ؓ入栈�Q�push�Q�、出栈（pop�Q�、栈��节点（top�Q�。�Ş象的��_��栈是一个先�q�后出（LIFO�Q�表�Q�先�q�去的节点要�{�到后边�q�去的节点出来才能出来�?/span>

如图1�Q�是一个栈的�Ş象图�Q�top指针指向的是栈顶节点�Q�所以我们可以通过top讉K��?节点�Q�但�?�?节点�׃��先于2�q�入�q�个表，所以是不可见的。如果把0节点当做头节点，2节点当做��节点，那么栈限制了讉K��权限�Q�只可以讉K��节炏V�?/span>

如图2�Q�当��d��一个节�?的时候，只能在栈��节点，也就是尾节点后添加，�q�样3节点变成了栈��Ӟ��2节点变成了不可见节点�Q�访问的时候只能访问到3节点。入栈时限制了插入地址�Q�只能在栈顶��d��节点�?/span>

当我们执行出栈的命��o�Ӟ��?的栈��元素是3节点�Q�删除的时候只能允许删除栈��的元素�Q�这样子3节点被删除，top指向删除后的栈顶2节点�Q�如�?所�C��?/span>

栈有两种是实现结构，一�U�是��序存储�l�构�Q�也��是利用数组实现�Q�一�U�是铑ּ�存储�l�构�Q�可以用单链表实现。数�l�实现栈很简单，用一个下标标记top来表�C�栈��Ӟ��top==-1�Ӟ��栈空�Q�top==0�Ӟ��表示栈里只有一个元素，通过讉K��top��Z��标的数组元素卛_��。出栈top自减�Q�入栈top自加��O(ji��n)K了�?/span>

单链表实现栈要比单链表的实现��单点。我们通过在表的尾端插入来实现push�Q�通过删除��节�Ҏ(gu��)��实现pop�Q�获取尾节点的元素来表示top。我修改了链表那一章的单链表代码，把头节点当做栈顶节点�Q�实��C��一个简单的栈模板，仅供学习所用。代码会不定时更新�?a href="/Files/cxiaojia/stack.rar">代码下蝲

代码如下�Q?br />

template<class T>
class stackNode
{
    public:
    stackNode():next(NULL){}
    T data;//�?/span>
    stackNode* next;//指向下一个节点的指针
};
template<class T>
class mystack
{
    private:
    unsigned int stacklength;
    stackNode* node;//临时节点
    stackNode* headnode;//��?/span>
    public:
        mystack();//初始�?/span>
        unsigned int length();//栈元素的个数
        void push(T x);//入栈
        bool isEmpty();//判断栈是否�ؓ�I?/span>
        void pop();//出栈
        T top();//获得栈顶元素
        void clear();//清空�?/span>

};
template<class T>
mystack::mystack()
{
    node=NULL;
    headnode=NULL;
    stacklength=0;
}
template<class T>
inline unsigned int mystack::length(){return stacklength;}
template<class T>
void  mystack::push(T x)
{
    node=new stackNode();
    node->data=x;
    node->next=headnode;//把node变成头节�?/span>
    headnode=node;
    ++stacklength;
}
template<class T>
bool  mystack::isEmpty()
{
    return stacklength==0;
}
template<class T>
void  mystack::pop()
{
    if(isEmpty()) return;
    node=headnode;
    headnode=headnode->next;//头节点变成它的下一个节�?/span>
    delete(node);//删除头节�?/span>
    --stacklength;
}
template<class T>
T  mystack::top()
{
    if(!isEmpty())
    return headnode->data;
}
template<class T>
void  mystack::clear()
{
    while(headnode!=NULL)
    {
        node=headnode;
        headnode=headnode->next;
        delete(node);
    }
    node=NULL;
    headnode=NULL;
    stacklength=0;
}
很清楚，除了clear函数外，所有的�Ҏ(gu��)��的时间复杂度都是O(1)。这�U�实现方式的�~�点在于�?span lang="EN-US">new�?span lang="EN-US">delete的调用的开销是昂�늚��Q�所以采用数�l�的方式实现会更好一炏V�?br />

栈的应用

使用栈的时候一般不用自己重新去写，因�ؓSTL�l�我们实��C��一个很安全的栈�Q�可以放心去使用�?/span>也可以用数组模拟一个，很简单�?/span>

�~�译器调用函数就用了栈结构，当第一个函数还没执行完毕，调用�W�二个函数的时候，�~�译器就会把�W�一个函数压栈，�W�二个函数调用完毕的时候，��׃��取栈��函敎ͼ�也就是第一个函数��l�执行�?span lang="EN-US">

�q��W�号 http://acm.nyist.net/JudgeOnline/problem.php?pid=2

中缀转后�~� http://acm.nyist.net/JudgeOnline/problem.php?pid=467

后缀试求�?http://acm.nyist.net/JudgeOnline/problem.php?pid=35

poj 3250 http://acm.pku.edu.cn/JudgeOnline/problem?id=3250

poj 1363 http://acm.pku.edu.cn/JudgeOnline/problem?id=1363

poj 1208 http://acm.pku.edu.cn/JudgeOnline/problem?id=1208

poj 1686 http://acm.pku.edu.cn/JudgeOnline/problem?id=1686

poj 3250 http://acm.pku.edu.cn/JudgeOnline/problem?id=2045

hdu 1022 http://acm.hdu.edu.cn/showproblem.php?pid=1022

C��加 2012-08-01 16:51 发表评论

C��加 — Tue, 31 Jul 2012 09:41:00 GMT

基本数据�l�构�Q�链表（list�Q?/strong>

作者：C��加更新旉��Q?/span>2012-7-31

谈到链表之前�Q�先说一下线性表。线性表是最基本、最��单、也是最常用的一�U?/span>数据�l�构。线性表中数据元素之间的关系是一对一的关�p�，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表有两�U�存储方式，一�U�是��序存储�l�构�Q�另一�U�是铑ּ�存储�l�构�?/span>

��序存储�l�构��是两个盔R��的元素在内存中也是相�?c��)��。这�U�存储方式的优点是查询的旉��复杂度�ؓO(1)�Q�通过首地址和偏�U�量��可以直接访问到某元素，关于查找的适配��法很多�Q�最快可以达到O(logn)。缺�Ҏ(gu��)��插入和删除的旉��复杂度最坏能辑ֈ�O(n)�Q�如果你在第一个位�|�插入一个元素，你需要把数组的每一个元素向后移动一位，如果你在�W�一个位�|�删除一个元素，你需要把数组的每一个元素向前移动一位。还有一个缺点，��是当你不确定元素的数量�Ӟ��你开的数�l�必��M��证能够放下元素最大数量，遗憾的是如果实际数量比最大数量少很多�Ӟ��你开的数�l�没有用到的内存��只能浪�Ҏ(gu��)��了�?/span>

我们常用的数�l�就是一�U�典型的��序存储�l�构�Q�如�?�?/span>

铑ּ�存储�l�构��是两个盔R��的元素在内存中可能不是相�?c��)��Q�每一个元素都有一个指针域�Q�指针域一般是存储着��C��一个元素的指针。这�U�存储方式的优点是插入和删除的时间复杂度为O(1)�Q�不会浪费太多内存，��d��元素的时候才会申请内存，删除元素会释攑ֆ�存，。缺�Ҏ(gu��)��讉K��的时间复杂度最坏�ؓO(n)�Q�关于查扄��法很少�Q�一般只能遍历，�q�样旉��复杂度也是线性（O(n)�Q�的�?频繁的申请和释放内存也会消耗时间�?/span>

��序表的�Ҏ(gu��)��是随机��d��Q�也��是讉K��一个元素的旉��复杂度是O(1)�Q�链式表的特性是插入和删除的旉��复杂度�ؓO(1)。要�Ҏ(gu��)��实际情况去选取适合自己的存储结构�?/span>

链表��是铑ּ�存储的线性表。根据指针域的不同，链表分�ؓ单向链表、双向链表、��@环链表等�{��?/span>

一�?单向链表�Q�slist�Q?/span>

链表中最��单的一�U�是单向链表�Q�每个元素包含两个域�Q�值域和指针域�Q�我们把�q�样的元素称之�ؓ节点。每个节点的指针域内有一个指针，指向下一个节点，而最后一个节点则指向一个空倹{��如�?��是一个单向链表�?/span>

一个单向链表的节点被分成两个部分。第一个部分保存或者显�C�关于节点的信息�Q�第二个部分存储下一个节点的地址。单向链表只可向一个方向遍历�?/span>

我写了一个简单的C++版单向链表类模板�Q�就用这�D�代码讲解一下一个具体的单向链表该怎么写（代码仅供学习�Q�，当然首先你要具备C++基础知识和简单的模板元编�E��?br />完整代码

首先我们要写一个节点类�Q�链表中的每一个节点就是一个节点类的对象。如�?�?br />

代码如下�Q?/span>

template<class T>
class slistNode
{
    public:
    slistNode(){next=NULL;}//初始�?/span>
    T data;//�?/span>
    slistNode* next;//指向下一个节点的指针
};
�W�二步，写单链表�cȝ��声明�Q�包括属性和�Ҏ(gu��)��?/span>

代码如下�Q?/span>

template<class T>
class myslist
{
    private:
    unsigned int listlength;
    slistNode* node;//临时节点
    slistNode* lastnode;//头结�?/span>
    slistNode* headnode;//��节�?/span>
    public:
        myslist();//初始�?/span>
        unsigned int length();//链表元素的个�?/span>
        void add(T x);//表尾��d��元素
        void traversal();//遍历整个链表�q�打�?/span>
        bool isEmpty();//判断链表是否为空
        slistNode* find(T x);//查找�W�一个��gؓx的节�?�q�回节点的地址,找不到返回NULL
        void Delete(T x);//删除�W�一个��gؓx的节�?/span>
        void insert(T x,slistNode* p);//在p节点后插入��gؓx的节�?/span>
        void insertHead(T x);//在链表的头部插入节点
};

�W�三步，写构造函敎ͼ�初始化链表类的属性�?/span>

代码如下�Q?/span>
template<class T>
myslist::myslist()
{
    node=NULL;
    lastnode=NULL;
    headnode=NULL;
    listlength=0;
}
�W�四步，实现add()�Ҏ(gu��)��?/span>

代码如下�Q?/span>
template<class T>
void  myslist::add(T x)
{
    node=new slistNode();//甌��一个新的节�?/span>
    node->data=x;//新节点赋��gؓx
    if(lastnode==NULL)//如果没有��节点则链表为空,node既�ؓ头结�?又是��节�?/span>
    {
        headnode=node;
        lastnode=node;
    }
    else//如果链表非空
    {
        lastnode->next=node;//node既�ؓ��节点的下一个节�?/span>
        lastnode=node;//node变成了尾节点,把尾节点赋��gؓnode
    }
    ++listlength;//元素个数+1
}
�W�五步，实现traversal()函数�Q�遍历�ƈ输出节点信息�?/span>

代码如下�Q?br />
template<class T>
void  myslist::traversal()
{
    node=headnode;//用��时节�Ҏ(gu��)��向头�l�点
    while(node!=NULL)//遍历链表�q�输�?/span>
    {
        cout<data<        node=node->next;
    }
    cout<}
�W�六步，实现isEmpty()函数�Q�判断链表是否�ؓ�I�，�q�回真�ؓ�I�，假则不空�?/span>

代码如下�Q?/span>
template<class T>
bool  myslist::isEmpty()
{
    return listlength==0;
}
�W�七步，实现find()函数�?/span>

代码如下�Q?br />
template<class T>
slistNode* myslist::find(T x)
{
    node=headnode;//用��时节�Ҏ(gu��)��向头�l�点
    while(node!=NULL&&node->data!=x)//遍历链表,遇到值相同的节点跛_��
    {
        node=node->next;
    }
    return node;//�q�回扑ֈ�的节点的地址,如果没有扑ֈ�则返回NULL
}
�W�八步，实现delete()函数�Q�删除第一个��gؓx的节点，如图4�?/span>

代码如下�Q?br />
template<class T>
void  myslist::Delete(T x)
{
    slistNode* temp=headnode;//甌��一个��时节�Ҏ(gu��)��向头节点
    if(temp==NULL) return;//如果头节点�ؓ�I?则该链表无元�?直接�q�回
    if(temp->data==x)//如果头节点的��gؓ要删除的�?则删除投节点
    {
        headnode=temp->next;//把头节点指向头节点的下一个节�?/span>
        if(temp->next==NULL) lastnode=NULL;//如果链表中只有一个节�?删除之后��没有节点了,把尾节点�|��ؓ�I?/span>
        delete(temp);//删除头节�?/span>
        return;
    }
    while(temp->next!=NULL&&temp->next->data!=x)//遍历链表扑ֈ��W�一个��g��x相等的节�?temp表示�q�个节点的上一个节�?/span>
    {
        temp=temp->next;
    }
    if(temp->next==NULL) return;//如果没有扑ֈ�则返�?/span>
    if(temp->next==lastnode)//如果扑ֈ�的时候尾节点
    {
        lastnode=temp;//把尾节点指向他的上一个节�?/span>
        delete(temp->next);//删除��节�?/span>
        temp->next=NULL;
    }
    else//如果不是��节�?如图4
    {
        node=temp->next;//用��时节点node指向要删除的节点
        temp->next=node->next;//要删除的节点的上一个节�Ҏ(gu��)��向要删除节点的下一个节�?/span>
        delete(node);//删除节点
        node=NULL;
    }
}
�W�九(ji��)步，实现insert()�?span lang="EN-US">insertHead()函数�Q�在p节点后插入��gؓx的节炏V��如�?span lang="EN-US">5�?span lang="EN-US">

代码如下�Q?/span>
template<class T>
void  myslist::insert(T x,slistNode* p)
{
    if(p==NULL) return;
    node=new slistNode();//甌��一个新的空�?/span>
    node->data=x;//如图5
    node->next=p->next;
    p->next=node;
    if(node->next==NULL)//如果node为尾节点
    lastnode=node;
}
template<class T>
void  myslist::insertHead(T x)
{
    node=new slistNode();
    node->data=x;
    node->next=headnode;
    headnode=node;
}

最�l�，我们完成一个简单的单向链表。此单向链表代码�q�有很多待完善的地方�Q�以后会修改代码�q�不定时更新�?/span>

二�?双向链表

双向链表的指针域有两个指针，每个数据�l�点分别指向直接后��和直接前驱。单向链表只能从表头开始向后遍历，而双向链表不但可以从前向后遍历，也可以从后向前遍历。除了双向遍历的优点�Q�双向链表的删除的时间复杂度会降为O�Q?�Q�，因�ؓ直接通过目的指针��可以找到前��p��点，单向链表得从表头开始遍历寻扑։��p��炏V��缺�Ҏ(gu��)��每个节点多了一个指针的�I�间开销。如�?��是一个双向链表�?/span>

三�?循环链表

循环链表��是让链表的最后一个节�Ҏ(gu��)��向第一个节点，�q�样��Ş成了一个圆环，可以循环遍历。单向��@环链表可以单向��@环遍历，双向循环链表的头节点的指针也要指向最后一个节点，�q�样的可以双向��@环遍历。如�?��是一个双向��@环链表�?/span>

四�?链表相关问题

1、如何判断一个单链表有环

2、如何判断一个环的入口点在哪�?/span>

3、如何知道环的长�?/span>

4、如何知道两个单链表�Q�无环）是否�怺�

5、如果两个单链表�Q�无环）�怺��Q�如何知道它们相交的�W�一个节�Ҏ(gu��)��什�?/span>

6、如何知道两个单链表�Q�有环）是否�怺�

7、如果两个单链表�Q�有环）�怺��Q�如何知道它们相交的�W�一个节�Ҏ(gu��)��什�?/span>

�{�案

C��加 2012-07-31 17:41 发表评论

C��加 — Wed, 18 Apr 2012 12:18:00 GMT

hash_map�Q�顾名思义�Q�就是利�?/span>hash_set存储�l�构的写map映照容器�Q�普通的map用的是红黑树存储�l�构写的。元素的��索时间对比，hash_set�q�似�?/span>O(1)�Q�红黑树�?/span>O(logn)�?/span>Hash_map的空间开销要比map 的空间开销大，��其是我用数�l�模拟指针写�?/span>hash_map�?/span>

所以，如果有必要采取映��结构的时候，能用hash_map��别�?/span>map�?/span>

需要注意的是，hash_map遍历出来的元素不是有序的�?/span>

Hash_map和普�?/span>hash_set相比的话�Q?/span>hash_map�?/span>hash_set多了一�?/span>value表，也就是映��表�?/span>

下面�?/span>hash_map的模板，�?/span>hash_set的模板差不多�?br />
template<class KeyType,int MaxHash>
struct HashFunction
{
    int operator()(const KeyType& key)
    {
        int h=key%MaxHash;
        if (h<0) h+=MaxHash;
        return h;
    }
};

template<class KeyType,class ValueType,int KeyContain,int MaxHash,class HashFun=HashFunction >
class HashMap
{
public:
    HashMap():hashfun(){Clear();}
    ValueType& operator[](const KeyType& key)
    {
        int h=hashfun(key);
        int pos=head[h];
        for(;pos!=0;pos=next[pos])
        {
            if(keys[pos]==key)
                return values[pos];
        }
        next[++top]=head[h];
        head[h]=top;
        keys[top]=key;
        values[top]=ValueType();//初始�?/span>
        ++sz;
        return values[top];
    }
    void Clear()
    {
        memset(head,0,sizeof(head));
        memset(next,0,(top+1)*sizeof(int));
        top=0;
        sz=0;
    }
    unsigned int size() const {return sz;}

private:
    unsigned int sz;
    HashFun hashfun;
    int head[MaxHash];
    int next[KeyContain];
    KeyType keys[KeyContain];
    ValueType values[KeyContain];
    int top;
};

C��加 2012-04-18 20:18 发表评论

区间某个数出现的�ơ数

C��加 — Mon, 26 Mar 2012 04:55:00 GMT

�l�你一串数字，让你求出某个子串中某个数字出现的�ơ数�?/span>

用邻接表储存每个数出现的位置�Q�然后对��L��表进行二分查找，扑և�区间�?/span>

C��加 2012-03-26 12:55 发表评论

优秀博客推荐�Q�各�U�数据结构与��法知识入门�l�典�Q�不断更�?

C��加 — Wed, 16 Nov 2011 07:58:00 GMT

作者：C��加更新旉��Q?/span>2012-8-16
�Ƣ迎自荐�?span style="color: red; ">推荐链接。请于留�a�处告知�?br />
基本��法
贪心��法�Q?a title="贪心��法" target="_blank">贪心��法作者：独酌途R��
贪心��法�_�讲作者：3522021224
递归和分治：递归与分�ȝ��?/a> 作者：zhoudaxia

图论
囄��遍历�Q�DFS和BFS�Q�：  囄��遍历作者：jefferent
最��生成树�Q�Prim��法和Kruskal��法�Q�：贪心��法--最��生成树作者：独酌途R��
Dijkstra��法�Q?nbsp;最短�\径之Dijkstra��法详细讲解作者：�l�岩
最短�\径算�?#8212;Dijkstra(�q�杰斯特�?��法分析与实�?C/C++) 作者：tankywoo
Bellman-Ford��法�Q?a title="最短�\径算�?#8212;Bellman-Ford(贝尔�?��特)��法分析与实�?C/C++)" target="_blank">最短�\径算�?#8212;Bellman-Ford(贝尔�?��特)��法分析与实�?C/C++) 作者：tankywoo
Floyd-Warshall��法�Q?a title="最短�\径算�?#8212;Floyd(弗洛伊�d)��法分析与实�?C/C++)">最短�\径算�?#8212;Floyd(弗洛伊�d)��法分析与实�?C/C++) 作者：tankywoo
Johnson��法�Q?a title="Johnson ��法">Johnson ��法作者：huliang82
A*��法�Q?/span>A*��法详解作者：愚�h有节
拓扑排序�Q?a title="拓扑排序">拓扑排序作者：
midgard

  如何�ȝ��?拓扑排序��法作者：张善�?/strong>
关键路径�Q?a title="关键路径" target="_blank">关键路径作者：navorse
�Ƨ拉路：�Ƨ拉路问�?/a> 作者：MaiK
差分�U�束�Q?a title="差分�U�束�pȝ��">差分�U�束�pȝ�� 作者：fuliang
二分图最大匹配：二分囑֌�配�ȝ�� 作者：北极天南�?br /> 二分囑֌�配算法�ȝ�� 作者：z7m8v6
�|�络��：�|�络��基�� 作者：chhaj523

数据�l�构
链表:基本数据�l�构�Q�链表（list�Q?/span> 作�?C��加
�? 基本数据�l�构�Q�栈�Q�stack�Q?/a> 作�?C��加
队列:基本数据�l�构�Q�队列（queue�Q?/a> 作�?C��加
�?基本数据�l�构�Q�树�Q�tree�Q?/a> 作�?C��加
二叉�?C��加
二叉查找�?一步一步写二叉查找�?/a>  作�?C��加
�q�查集：�q�查�?-学习详解作者：yx_th000
哈希表：猎�h�?/span>
二分查找�Q?a title="查找�Q�二�Q�：二分查找">查找�Q�二�Q�：二分查找作者：xiaosuo
哈夫曼树�Q?/span>哈夫曼树作者：angle
�q��二叉树： �q��二叉树（解惑�Q?/a> 作者：Never
树状数组�Q?a target="_blank">树状数组�ȝ�� 作者：熊猫yingcai
�U�段树： �U�段树�ȝ�� 作者：星星
归�ƈ排序求逆序敎ͼ�kahn

动态规划（DP�Q?/span>
��单动态规划：brokencode
背包问题�Q�《背包九(ji��)讌Ӏ?br />

数学
遗传��法�Q?nbsp;遗传��法入门作者：heaad
�Ҏ(gu��)��原理�Q?a href="http://www.shnenglu.com/vici/archive/2011/09/05/155103.html" title="�Ҏ(gu��)��原理�Q�翻译）" target="_blank">�Ҏ(gu��)��原理�Q�翻译）作者：vici
母函敎ͼ�母函数入门小�l?/a> 作者：zhangxiang0125
�U�九(ji��)韶算法：simonezhlx
高斯消元法：
�Ƨ几里得定理�Q�GCD�Q�：
扩展�Ƨ几里得定理�Q?/span>
中国剩余定理�Q?/span>
概率问题�Q?/span>

计算几何
几何公式�Q?br />��L��化：什么是��L��化？作者：matrix67
扫描�U�算法：
叉积和点�U�：
凸包�Q?br />

C��加 2011-11-16 15:58 发表评论

C��加 — Tue, 20 Sep 2011 10:11:00 GMT
     摘要: 从《严书》上看到了KMP��法�Q�看了一遍没懂，但觉得挺��奇的，��p��费了几天旉��深入的理解。算法的原理其实不难�Q�难的就是那个��y妙的next数组�Q�这个next数组很吸引我�Q�我的大部分旉��也都是花费在�q�个数组上面的。这个next数组是KMP里面一个很关键的地方，对于在数据结构书上看�q�一遍整个算法流�E�的人，能够把next数组搞明白，整个KMP��法的整体思想��差不多理解了。然后在一些细节上面深入思考一下，��可...  阅读全文

C��加 2011-09-20 18:11 发表评论

久久亚洲欧洲国产综合,国产精品99久久精品,久久人人超碰精品CAOPOREN

区间某个数出现的�ơ数

优秀博客推荐�Q�各�U�数据结构与���法知识入门�l�典�Q�不断更�?

优秀博客推荐�Q�各�U�数据结构与��法知识入门�l�典�Q�不断更�?