树这个数据结构内容真的很多，上一节所讲的二叉堆，其实就是一颗二叉树，这次讲的左偏树（又叫“左翼堆”），也是树。

二叉堆是个很不错的数据结构，因为它非常便于理解，而且仅仅用了一个数组，不会造成额外空间的浪费，但它有个缺点，那就是很难合并两个二叉堆，对于“合并”，“拆分”这种操作，我觉得最方面的还是依靠指针，改变一下指针的值就可以实现，要是涉及到元素的移动，那就复杂一些了。

左偏树跟二叉堆比起来，就是一棵真正意义上的树了，具有左右指针，所以空间开销上稍微大一点，但却带来了便于合并的便利。BTW：写了很多很多的程序之后，我发觉“空间换时间”始终是个应该考虑的编程方法。:)

左偏左偏，给人感觉就是左子树的比重比较大了，事实上也差不多，可以这么理解：左边分量重，那一直往右，就一定能最快地找到可以插入元素的节点了。所以可以这样下个定义：左偏树就是对其任意子树而言，往右到插入点的距离（下面简称为“距离”）始终小于等于往左到插入点的距离，当然了，和二叉堆一样，父节点的值要小于左右子节点的值。

如果节点本身不满，可插入，那距离就为0，再把空节点的距离记为-1，这样我们就得出：父节点的距离 = 右子节点距离 + 1，因为右子节点的距离始终是小于等于左子节点距离的。我把距离的值用蓝色字体标在上图中了。

左偏树并一定平衡，甚至它可以很不平衡，因为它其实也不需要平衡，它只需要像二叉堆那样的功能，再加上合并方便，现在来看左偏树的合并算法，如图：

这种算法其实很适合用递归来做，但我还是用了一个循环，其实也差不多。对于左偏树来说，这个合并操作是最重要最基本的了。为什么？你看哦：Enqueue，我能不能看作是这个左偏树的root和一个单节点树的合并？而Dequeue，我能不能看作是把root节点取出来，然后合并root的左右子树？事实上就是这样的，我提供的代码就是这样干的。

Conclusion：左偏树比同二叉堆的优点就是方便合并，缺点是编程复杂度略高（也高不去哪），占用空间稍大（其实也大不去哪）。附上代码，老样子了，单个文件，直接调试的代码，零依赖零配置，一看就懂，代码虽然不算完美，但作为演示和学习，是足够了。

#include <stdio.h>

// TreeNode
//////////////////////////////////////////////////////////////////////////
struct TreeNode 
{
    TreeNode(int iVal)
    {
        m_iData = iVal;
        m_iDistance = 0;
        m_pLeft = 0;
        m_pRight = 0;
    }

    ~TreeNode()
    {

    }

    void SwapLeftRight()
    {
        TreeNode *pTmp = m_pLeft;
        m_pLeft = m_pRight;
        m_pRight = pTmp;
    }

    void UpdateDistance()
    {
        m_iDistance = GetRightDistance()+1;
    }

    int GetLeftDistance()
    {
        return m_pLeft!=0?m_pLeft->m_iDistance:-1;
    }

    int GetRightDistance()
    {
        return m_pRight!=0?m_pRight->m_iDistance:-1;
    }

    int m_iData;
    int m_iDistance;
    TreeNode* m_pLeft;
    TreeNode* m_pRight;
};

// Stack
//////////////////////////////////////////////////////////////////////////
class Stack
{
public:
    Stack(int iAmount = 10);
    ~Stack();
    
    //return 1 means succeeded, 0 means failed.
    int Pop(TreeNode* & val);
    int Push(TreeNode* val);
    int Top(TreeNode* & val);
    
    //iterator
    int GetTop(TreeNode* &val);
    int GetNext(TreeNode* &val);
private:
    TreeNode** m_pData;
    int m_iCount;
    int m_iAmount;
    
    //iterator
    int m_iCurr;
};

Stack::Stack(int iAmount)
{
    m_pData = new TreeNode*[iAmount];
    m_iCount = 0;
    m_iAmount = iAmount;
    m_iCurr = 0;
}

Stack::~Stack()
{
    delete m_pData;
}

int Stack::Pop(TreeNode* & val)
{
    if(m_iCount>0)
    {
        --m_iCount;
        val = m_pData[m_iCount];
        return 1;
    }
    return 0;
}

int Stack::Push(TreeNode* val)
{
    if(m_iCount<m_iAmount)
    {
        m_pData[m_iCount] = val;
        ++m_iCount;
        return 1;
    }
    return 0;
}

int Stack::Top(TreeNode* & val)
{
    if(m_iCount>0 && m_iCount<=m_iAmount)
    {
        val = m_pData[m_iCount-1];
        return 1;
    }
    return 0;
}

int Stack::GetTop(TreeNode* &val)
{
    if(m_iCount>0 && m_iCount<=m_iAmount)
    {
        val = m_pData[m_iCount-1];
        m_iCurr = m_iCount - 1;
        return 1;
    }
    return 0;
}

int Stack::GetNext(TreeNode* &val)
{
    if((m_iCurr-1)<(m_iCount-1) && (m_iCurr-1)>=0)
    {
        --m_iCurr;
        val = m_pData[m_iCurr];
        return 1;
    }
    return 0;
}

// LeftistTree
//////////////////////////////////////////////////////////////////////////
class LeftistTree
{
public:
    LeftistTree();
    ~LeftistTree();

    //return 0 means failed.
    int Dequeue(int& iVal);
    int Enqueue(int iVal);

    //returns the merged root.
    TreeNode* Merge(TreeNode *pT1, TreeNode *pT2);

    TreeNode* GetRoot();
#ifdef _DEBUG
    void Print(TreeNode* pNode);
#endif

protected:
    TreeNode *m_pRoot;
};

LeftistTree::LeftistTree()
{
    m_pRoot = NULL;
}

LeftistTree::~LeftistTree()
{
    Stack st(40); //2^40 must be enough.
    
    //Postorder traverse the tree to release all nodes.
    TreeNode *pNode = m_pRoot;
    TreeNode *pTemp;
    if(pNode==0)
        return;
    
    while (1)
    {
        if(pNode->m_pLeft!=0)
        {
            st.Push(pNode);
            pTemp = pNode;
            pNode = pNode->m_pLeft;
            pTemp->m_pLeft = 0;
            continue;
        }
        
        if(pNode->m_pRight!=0)
        {
            st.Push(pNode);
            pTemp = pNode;
            pNode = pNode->m_pRight;
            pTemp->m_pRight = 0;
            continue;
        }
        
        delete pNode;
        
        if(0==st.Pop(pNode))
            break;
    }
}

int LeftistTree::Dequeue(int& iVal)
{
    if(m_pRoot==0)
        return 0;

    iVal = m_pRoot->m_iData;
    TreeNode *pTmp = m_pRoot;
    m_pRoot = Merge(m_pRoot->m_pLeft, m_pRoot->m_pRight);
    delete pTmp;
    return 1;
}

int LeftistTree::Enqueue(int iVal)
{
    TreeNode *pNew = new TreeNode(iVal);
    m_pRoot = Merge(m_pRoot, pNew);
    return 1;
}

TreeNode* LeftistTree::Merge(TreeNode *pT1, TreeNode *pT2)
{
    if(pT1==0 && pT2==0)
        return 0;
    else if(pT1==0) //pT2!=0
        return pT2;
    else if(pT2==0) //pT1!=0
        return pT1;

    if(pT1->m_iData > pT2->m_iData)
        return Merge(pT2, pT1);

    Stack st(40);
    
    TreeNode* pInsPos = pT1;
    TreeNode* pToIns = pT2;
    TreeNode* pTmp;
    
    st.Push(pInsPos);

    //Find a node available for insert.
    while(1)
    {
        if(pInsPos->m_pRight!=NULL)
        {
            if(pToIns->m_iData < pInsPos->m_pRight->m_iData)
            {
                pTmp = pInsPos->m_pRight;
                pInsPos->m_pRight = pToIns;
                pToIns = pTmp;
                st.Push(pInsPos);
                pInsPos = pInsPos->m_pRight;
            }
            else
            {
                st.Push(pInsPos);
                pInsPos = pInsPos->m_pRight;
            }
        }
        else
        {
            st.Push(pInsPos);
            //Insert
            pInsPos->m_pRight = pToIns;
            break;
        }
    }

    TreeNode* pNode;
    //Try to update the relative distance and make the tree be still the leftist tree.
    while (0!=st.Pop(pNode))
    {
        if(pNode->GetLeftDistance() < pNode->GetRightDistance())
            pNode->SwapLeftRight();
        pNode->UpdateDistance();
    }

    return pT1;
}

TreeNode* LeftistTree::GetRoot()
{
    return m_pRoot;
}

#ifdef _DEBUG
void LeftistTree::Print(TreeNode* pNode)
{
    if(pNode!=NULL)
    {
        if(pNode->m_pLeft!=NULL && pNode->m_pRight!=NULL)
        {
            printf("%d[%d]->(%d, %d)\n", pNode->m_iData, pNode->m_iDistance, pNode->m_pLeft->m_iData, pNode->m_pRight->m_iData);
            Print(pNode->m_pLeft);
            Print(pNode->m_pRight);
        }
        else if(pNode->m_pLeft!=NULL)
        {
            printf("%d[%d]->(%d, x)\n", pNode->m_iData, pNode->m_iDistance, pNode->m_pLeft->m_iData);
            Print(pNode->m_pLeft);
        }
        else if(pNode->m_pRight!=NULL)
        {
            printf("%d[%d]->(x, %d)\n", pNode->m_iData, pNode->m_iDistance, pNode->m_pRight->m_iData);
            Print(pNode->m_pRight);
        }
    }
}
#endif

int main(int argc, char* argv[])
{
    LeftistTree tree;
    tree.Enqueue(9);
    tree.Enqueue(4);
    tree.Enqueue(2);
    tree.Enqueue(1);
    tree.Enqueue(3);
    tree.Enqueue(8);

#ifdef _DEBUG
    tree.Print(tree.GetRoot());
#endif

    int iVal;
    tree.Dequeue(iVal);
    printf("\nDequeue value is %d\n", iVal);
    tree.Dequeue(iVal);
    printf("Dequeue value is %d\n", iVal);

#ifdef _DEBUG
    tree.Print(tree.GetRoot());
#endif

    return 0;
}

经历了上一篇实现AVL树的繁琐，这篇就显得非常easy了。

首先说说数据结构概念——堆（Heap），其实也没什么大不了，简单地说就是一种有序队列而已，普通的队列是先入先出，而二叉堆是：最小先出。

这不是很简单么？如果这个队列是用数组实现的话那用打擂台的方式从头到尾找一遍，把最小的拿出来不就行了？行啊，可是出队的操作是很频繁的，而每次都得打一遍擂台，那就低效了，打擂台的时间复杂度为Ο(n)，那如何不用从头到尾fetch一遍就出队呢？二叉堆能比较好地解决这个问题，不过之前先介绍一些概念。

完全树（Complete Tree）：从下图中看出，在第n层深度被填满之前，不会开始填第n+1层深度，还有一定是从左往右填满。

再来一棵完全三叉树：

这样有什么好处呢？好处就是能方便地把指针省略掉，用一个简单的数组来表示一棵树，如图：

那么下面介绍二叉堆：二叉堆是一种完全二叉树，其任意子树的左右节点（如果有的话）的键值一定比根节点大，上图其实就是一个二叉堆。

你一定发觉了，最小的一个元素就是数组第一个元素，那么二叉堆这种有序队列如何入队呢？看图：

假设要在这个二叉堆里入队一个单元，键值为2，那只需在数组末尾加入这个元素，然后尽可能把这个元素往上挪，直到挪不动，经过了这种复杂度为Ο(logn)的操作，二叉堆还是二叉堆。

那如何出队呢？也不难，看图：

出队一定是出数组的第一个元素，这么来第一个元素以前的位置就成了空位，我们需要把这个空位挪至叶子节点，然后把数组最后一个元素插入这个空位，把这个“空位”尽量往上挪。这种操作的复杂度也是Ο(logn)，比Ο(n)强多了吧？

尝试自己写写代码看，当然了，我也写（这个得动动手啦，比AVL容易多了）：

树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂：

当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？

树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图：

面试的时候我们经常被考到的是一种叫“二叉树”的结构，二叉树当然也是树的一种了，它的特点是除了叶以外的节点都有两个子，图：

由此我们还可以推出“三叉树”：

当然还有“四叉树”，“五叉树”，“六叉树”……但太难画了，节点太多，略过。

九、树的遍历（Traversal）

值得再提一下的是二叉树，因为它确实比较特别，节点有两个子，这两个子是有左右之分的，颠倒一下左右，就是不一样的二叉树了，所以左右是不能随便颠倒的。

在第三篇讲到“队”的时候，提及到了广度优先遍历（Breadth-first traversal），除了广度优先遍历之外，还有深度优先遍历（Depth-first Traversal），深度优先遍历又可分为：前序遍历（Preorder Traversal），后序遍历（Postorder Traversal）和中序遍历（Inorder Traversal），其中中序遍历只有对二叉树才有意义，下图解释这几种遍历：

好了，又到代码阶段，写点代码。我看过许多数据结构的教材，二叉树遍历都是必不可少的内容，而且我知道的全部都是用递归实现的，现在，我要求你不用递归，实现对二叉树的中序遍历。怎么办？我给个提示：广度优先遍历时候我们用了队，中序遍历，我们使用*栈*。看看能不能写出来，我也来写：

数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为“链表的数组”，如图：

左边很明显是个数组，数组的每个成员包括一个指针，指向一个链表的头，当然这个链表可能为空，也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去，也是根据这些特征，找到正确的链表，再从链表中找出这个元素。

元素特征转变为数组下标的方法就是散列法。散列法当然不止一种，我下面列出三种比较常用的。

1，除法散列法
最直观的一种，上图使用的就是这种散列法，公式：
index = value % 16
学过汇编的都知道，求模数其实是通过一个除法运算得到的，所以叫“除法散列法”。

2，平方散列法
求index是非常频繁的操作，而乘法的运算要比除法来得省时（对现在的CPU来说，估计我们感觉不出来），所以我们考虑把除法换成乘法和一个位移操作。公式：
index = (value * value) >> 28
如果数值分配比较均匀的话这种方法能得到不错的结果，但我上面画的那个图的各个元素的值算出来的index都是0——非常失败。也许你还有个问题，value如果很大，value * value不会溢出吗？答案是会的，但我们这个乘法不关心溢出，因为我们根本不是为了获取相乘结果，而是为了获取index。

3，斐波那契（Fibonacci）散列法

平方散列法的缺点是显而易见的，所以我们能不能找出一个理想的乘数，而不是拿value本身当作乘数呢？答案是肯定的。

1，对于16位整数而言，这个乘数是40503
2，对于32位整数而言，这个乘数是2654435769
3，对于64位整数而言，这个乘数是11400714819323198485

这几个“理想乘数”是如何得出来的呢？这跟一个法则有关，叫黄金分割法则，而描述黄金分割法则的最经典表达式无疑就是著名的斐波那契数列，如果你还有兴趣，就到网上查找一下“斐波那契数列”等关键字，我数学水平有限，不知道怎么描述清楚为什么，另外斐波那契数列的值居然和太阳系八大行星的轨道半径的比例出奇吻合，很神奇，对么？

对我们常见的32位整数而言，公式：
index = (value * 2654435769) >> 28

如果用这种斐波那契散列法的话，那我上面的图就变成这样了：

看起来不错，以后就用斐波那契散列法吧。

不过我们要注意了，前面提到的都是针对整数的散列法，那如果不是整数呢？下面给出一些参考算法，我把其它类型的数据转变为32位整数，之后的处理前面已经说了。

1，浮点数的散列法

2，字符串的散列法

方法就提供那么多，遇到别的情况，比如说Unicode字符串，随机应变吧！

下面我给出了一段demo代码，来演示二分查找法比顺序查找快多少，代码为了方便起见，初始化有序表的时候填入的数字都是均匀的，而事实上数字可以不均匀。你可以调整一下代码中TABLE_SIZE的值，从500，调到5000，再调到10000，再调到30000……你会发觉两者差距越来越明显。我在第一篇的地方提到二分查找法的复杂度为Ο(logn)，而顺序查找的复杂度为Ο(n)，当n越来越大时候，Ο(logn)的优势也就越来越明显，当然了，前提是“有序”，才可用二分查找法。

这篇文章是不是太简单了点？OK，下一篇技术含量要高一点了。

前一篇讲了栈（Stack），队和栈其实只有一个差别，栈是先进后出，队是先进先出，如图：

从图中可以看出，队有两个常用的方法，Enqueue和Dequeue，顾名思义，就是进队和出队了。队和栈一样，既可以用数组实现，也可以用链表实现，我还是偏向于用数组，我的实现示意图如下：

队有啥用呢？一个最常用的用途就是“buffer”，即缓冲区，比如有一批从网络来的数据，处理需要挺长的时间，而数据抵达的间隔并不均匀，有时快，有时慢，先来的先处理，后来的后处理，于是你创建了一个队，用来缓存这些数据，出队一笔，处理一笔，直到队列为空。当然队的作用远不止于此，下面的例子也是一个很经典的例子，希望读者能举一反三。

例子：使用队对树进行广度优先遍历。

广度优先区别于深度优先，即优先遍历最靠近根节点的各个节点：

我们的算法是：
1，根节点入队
2，出队一个节点，算一次遍历，直到队列为空
3，将刚出队的节点的子节点入队
4，转到2

队列的状况如下图：

树的遍历一般习惯使用递归，理论上所有的递归都可以转变为迭代，如何实现这个转变？队就是其中一种有效的办法，OK，下面我给出上述例题的代码以及注释。

栈最大特点是先进后出，如图：

可以看出，栈有几个最常见的方法，或者说必备的方法，Push，Pop和Top，即进栈，出栈和取最顶元素。从代码上看，栈如何实现呢？用数组好还是用单向链表好呢？其实都可以，我下面的例子是用数组实现的。

说了那么多，栈有什么用呢？下面就举一个最经典的例题——逆波兰表达式（RPN，Reversed Polish Notation）的求解。

什么是逆波兰表达式？我们表述一个算式通常是这样：X+Y，即：“操作数1 操作符 操作数2”，当然也有比较特别的，比如“sqrt(N)”，sqrt是操作符，N是操作数，而逆波兰表达式则很统一，先操作数，后操作符，为什么叫“逆波兰表达式”？因为有一个波兰人发明了波兰表达式，而逆的波兰表达式就叫“逆波兰表达式”了。看下图就能很好理解了：

所有的算式都可以用逆波兰表达式写出来，只是我这里的举例是为了方便起见，限制在整数的四则运算里。

那假如现在我们有一个逆波兰表达式，那我们如何求出它的值呢？这里我们的“栈”就要派上用场了，由于操作数在操作符前面，所以我们按顺序遍历这个表达式，遇到操作数的时候进栈，遇到操作符时候让操作数出栈并运算，然后把运算结果进栈。过程如下图所示：

遇到第一个操作符，“+”的时候，由于需要两个操作数，所以出栈两次，4和3出栈，执行加法运算，结果是7，7进栈……依此类推。

下面我给出参考代码，我的代码使用很简单，复制，粘贴到一个cpp文件中，编译此cpp文件即可，没别的依赖。

（未完待续……）

另外，我们大多数人是做应用的，不是做研究的，所以我们只需要知道2+3=5，而不需要知道a+b=c。所以我就不深入理论，再说自己也没那个能力。

好，接下去我就用最一般的例子，最通俗易懂的图，算法和尽量少的文字，描述某作者需要长篇大论方可完成教材。

一、大圈表示法

面试时候如果让你写一个算法，要求复杂度为Ο(n)，你明白是什么意思吗？说起数据结构，就先提一下这个表示法吧，后面会用到。

“Ο”，其实不是英文的“O”，它是个希腊字母，发音大概是“欧麦克隆”，所以我们一般说“圈”而不是跟英文的O一样的发音。简单地说，大圈表示法是一种用于表示算法复杂度数量级的方法。要精确描述这个表示法，很难，不过我们不需要懂那么精确，只要八九不离十就可以了。下面我列个表，复杂度从低到高，大家就知道其意义：

另外还有个叫指数复杂度，这里不提，因为见得实在太少，“指数级递增”本身就是一个很夸张的形容词，我们也要避免这种复杂度的出现。还需要说明的一点是大圈表示法是时间递增数量级的表示方法，注意“递增”两个字，所以并不是说复杂度为Ο(1)的算法消耗的时间一定比复杂度为Ο(n)的算法少。

如果你还是不太明白大圈表示法，不用担心，继续往下看，会慢慢明白的。

二、动态数组（Dynamic Array）
接下去介绍最最基本的两种数据结构，即动态数组和单向链表，其它数据结构其实都可以通过这两者衍生出来。BTW：如果算法太简单，我就不列出代码，只稍微描述一下。

 
这就是一个最基本的动态数组，pData记录了数组第一个元素的位置，Unit Size记录了每个元素的大小，（这样可以方便地找到第N个元素了）Unit Number记录了元素的数目。

获取数组中第N个元素，是很简单的，无需多说。

但已知某位置，要插入一个元素，就稍微有点难，因为要挪动一些元素，如图：

删除元素跟这个也类似，也是需要挪一挪后面的元素，只不过是往前挪。

数组的大小不能很方便地调整，需要几个步骤，如下图所示：

代码我就不写了，大概就是new，memcpy，delete这几个步骤。

三、单向链表（Singly-linked List）

数据库三范式
1、数据集合分成多张表而不只是一张大表，分成的每张表都有主键；主键
2、找出仅仅依赖于主键的列，将其存储在另一个表中；仅依赖的列抽出
3、从一个表中删除不依赖于主键的列。不依赖的列抽出
缺点：降低性能。

建立数据库
很难吧？很难！不难吧？不难。仅仅告诉你最简单情况：
create database PAYMENTS;

建立表
create table bills(name char(30), amount number, account_id number);
create table empname(id number not null, ename char(30));
create table newtable as select * from oldtable;

改变表：增加列
alter table emp add new_col_name char(20);

改变表：修改列
alter table emp modify new_col_name char(21);

改变表：改列名(Oracle 9i Release 2才能用)
alter table emp rename column new_col_name to old_col_name;

改变表：删除列
alter table emp drop column old_col_name;

删除表
drop table tablename;

删除数据库
drop database databasename;

主键、非空、唯一约束
主键primary key
非空not null
唯一unique 除了排序，和primary key功能一致
create table emp
    (emp_id char(9) primary key,
    emp_name varchar2(40) not null,
    phone number(10) null unique);

外键约束foreign key
create table emp_pay
    (emp_id char(9) not null,
    position varchar2(15) not null,
    pay_rate number(4,2) not null);
alter table emp_pay add constraint emp_id_fk foreign key(emp_id) 
references emp(emp_id);

校验约束check
create table emp
    (emp_id char(9) not null primary key,
    emp_name varchar2(40) not null,
    emp_rate number(4,2) not null,
    zip number(5) not null);
alter table emp add constraint chk_zip check(emp_zip = '46234');
alter table emp add constraint chk_zip check(emp_zip in ('47634', '13451'));
alter table emp add constraint chk_zip check(emp_rate < 12.5);
emp_rate为校验约束名。

删除约束
alter table emp drop constraint emp_no_constraint;
emp_no_constraint为约束名。

更新记录
update collection set worth = 555, price = 666 where itemid = 1110;

删除记录
delete from collection where itemid = 1113;

事务处理
……
commit;
……
rollback;
……
savepoint save_it;
……
rollback to savepoint save_it;

日期时间
掌握两个函数就可以了。
to_char(empdate, 'YYYY/MM/DD HH24:MI:SS');
将date转变成字符串：“2004/11/12 16:30:02”
to_date('1981/11/12 00:03:16', 'YYYY/MM/DD HH24:MI:SS');
将字符串“1981/11/12 00:03:16”转变成日期类型。
还有要注意的事项，在中文Oracle中，'26-JAN-03'并不被认为是合法的日期，
'26-1月-03'才是合法的，真别扭，也蛮郁闷的。

建立视图
create view debts as select * from bills;

删除视图
drop view debts;

建立索引
create index empno_index on emp(empno);

删除索引
drop index empno_index;

创建用户
create user jguogang identified by mypassword;

授予用户角色
grant connect to jguogang;
grant resource to jguogang;
grant dba to jguogang;

删除用户的角色
revoke resource from jguogang;

给予系统特权
grant alter any type to public;
其中“alter any type”为一种系统特权，将被授予全部用户。
grant drop any trigger to jguogang;
将系统特权“drop any trigger”授予用户“jguogang”。
grant create user to connect;
将系统特权“create user”授予角色“connect”。
收回系统特权
revoke alter any type from public;
给予对象特权
grant select on emp to jack;
授予用户“jack”：对“emp”的“select”对象特权。
grant select, update(salary) on emp to jill;
授予用户“jill”：对“emp”的“select”、“salary”列的“update”对象特权。
收回对象特权
revoke select on emp from jack;

字典
字典：我是谁
select * from user_users;
字典：我们是谁
select * from all_users;
字典：我能干什么
select * from user_sys_privs;
字典：我充当什么角色
select * from user_role_privs;
字典：我拥有什么表、视图和“SEQUENCE”
select * from user_catalog;
字典：我可访问什么表、视图和“SEQUENCE”（多）
select * from all_catalog;
字典：我拥有什么对象
select * from user_object;
字典：我可访问什么对象（多）
select * from all_catalog;
……关于字典，暂时就介绍那么点了。

注释
表的注释
comment on table emp is 'Employee';
列的注释
comment on column emp.ename is '名字';
列出所有包含注释的表
select * from user_tab_comments where comments is not null;
系统时间取得
select sysdate from dual;

20050906笔记
查看未提交的事务
select * from v$transaction;
select * from v$locked_object;
通过locked_object视图获知被锁定的对象的ID（object_id）
那么通过下面的语句能获知到底哪个对象被锁定
select * from sys.all_objects t where object_id = ###;
alter system kill session 30;

修改用户密码相关
select username,password from dba_users;
alter user aaa identified by aaaspwd;

在32位系统中，指针其实是个32位的无符号整型，要正常输出指针的值，正确做法是把它转换为一个无符号32位整形数输出（有符号的可能导致输出不正确），如果转换为一个16位的，或者8位的，那将丢失数据，当然了，前面这段代码不会出现任何error和warning，你知道你在干什么即可。刚说了，我们除了旧式转换还可以用reinterpret_cast，于是上面的代码可以这样写：

也是没有任何问题的，运行效果一样，那我们能不能把指针转换为浮点型呢？这样：

不行，你试试看就知道了，你会得到这样的编译错误：

error C2440: 'reinterpret_cast' : cannot convert from 'class CIndepend *' to 'float'
        There is no context in which this conversion is possible
error C2440: 'reinterpret_cast' : cannot convert from 'class CIndepend *' to 'double'
        There is no context in which this conversion is possible

其实将指针转换为浮点数这种做法就很怪异嘛，你不觉得吗？这样有什么用啊？不过你一定要这样干的话也不是没有办法，看代码：

加个小小的“&”符号就可以了，C++会不顾一切地把pIndepend这个变量当作一个float和double，把指针的值“理解”为float和double，当然，这样获得的浮点数的值是没什么实际意义的，因为指针的值是32位无符号整型，而浮点数有它自己特定的格式，这么一转换就牛头不对马嘴。你还可以这样写：

效果一样，得到的也是无意义的值。

2、常规类型=>指针

就是反过来罗，可能不说大家都能猜到结果了。把常规类型转换为指针有什么用呢？可能有点用，比如我们在某些特殊的场合要求一个指针指向一个特别的地址，这时候我们可以直接给指针赋个值，当然了，这个值应该是整型：

这样是没问题的，那浮点数呢？——又来了，浮点数转换为指针？这怎么算啊？显然这是不行的，如果真的需要“转换”，那就先把浮点数转换为整型，然后再赋值给指针吧。这个时候，dynamic_cast和static_cast都是不行的。

3、基本类型转换

比如int转换为float，char转变为short，很多时候我们都“默认”了这种转换，即使没有显式指定用旧式转换还是static_cast。在这种类型的转换中，旧式转换和static_cast的表现非常地类似：

而dynamic_cast还是不可行，那……reinterpret_cast呢？不妨试试看：

一编译，就出下面的错误：

error C2440: 'reinterpret_cast' : cannot convert from 'double' to 'char'
        Conversion is a valid standard conversion, which can be performed implicitly or by use of static_cast, C-style cast or function-style cast
error C2440: 'reinterpret_cast' : cannot convert from 'double' to 'short'
        Conversion is a valid standard conversion, which can be performed implicitly or by use of static_cast, C-style cast or function-style cast
error C2440: 'reinterpret_cast' : cannot convert from 'double' to 'int'
        Conversion is a valid standard conversion, which can be performed implicitly or by use of static_cast, C-style cast or function-style cast

说这是个有效标准转换，请使用static_cast或者C风格的旧式转换。reinterpret_cast不是号称最宽松的转换么？怎么不行了？你一定要它行也是没问题的，和前面的那样，加个“&”符号：

但结果并不是你想要的结果，因为这样reinterpret_cast会不管三七二十一，直接把dVal的东西当作是一个char，short和int，很明显，double是有一定的格式的，将double直接“理解”为char，short或者int一定会有问题。

4、class的转换

上一节说的是基本类型，那对于类呢？一个类直接转换为另一个类，这看起来确实有些荒谬，不过强大而灵活的C++却偏偏允许了这种行为。看代码：

居然编译过去了，运行貌似也没什么问题，当然转换过程和前面的差不多，就是把oBase理解为一个CIndepend对象，这个赋值运算执行“位拷贝”，这种方式的转换在实际中是碰不到的，起码我想不出有什么理由使用它。这种情况下，其它的转换方式都是不可行的。

5、class=>指针 or 指针=>class

这种行为更怪异，class直接理解为指针？这其实是不可行的，跟前面提到的浮点数转换为指针一样，如果实在需要，就把class转变为整型，然后整型转换为指针：

可这……这啥意思呢？哈哈，别问我。反过来，指针转换为class恐怕也令人费解：

能担当起这种怪异的工作的，唯reinterpret_cast是也，这样会产生什么后果呢？指针是个32位无符号整型，将它强制理解为一个CIndepend，然后作位拷贝，理所当然，oIndepend的值会被改变，而且还有访问越界的风险，导致内容混乱甚至程序崩溃。

6、指针之间的转换

前面一直没提起的一种转换就是dynamic_cast，因为它是最为严格的一种转换，它只能完成指针到指针的转换，而且还有限制。看这个：

编译出错了：

error C2683: dynamic_cast : 'CDerived' is not a polymorphic type
        D:\work\CastTest\CastTest.cpp(13) : see declaration of 'CDerived'

因为CDerived和CIndepend没有继承关系，把dynamic_cast换成static_cast还是不行的，会出另外一个错：

error C2440: 'static_cast' : cannot convert from 'class CDerived *' to 'class CIndepend *'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

编译器说这是没有关系的两个指针，应该用reinterpret_cast或者C风格的旧式转换，再看：

基类指针转换为子类指针，行不行呢？出错，错误跟刚才的一样，记住，dynamic_cast仅仅可以把子类指针转换为基类指针，别的都不行！上面这段代码如果不用dynamic_cast，而是用static_cast，就能编译通过，static_cast的要求来得比较宽松。

OK，到这里为止，大家都知道什么时候用什么转换是可以的了，问题是C++为什么搞出怎么多转换出来呢？我想很大程度上是兼顾了安全性和灵活性，要想安全，class指针的转换就使用dynamic_cast；一般情况下我们认为，static_cast也是安全的；C风格的旧式转换则灵活一些，它允许任意类型指针之间的转换；而reinterpret_cast就更加了，什么乱七八糟都可以。那从功能强弱上排个序，我想从强到弱应该是：reinterpret_cast，旧式转换，static_cast，dynamic_cast。

Oh，还有一种转换，差点忘了，就是const_cast，不过这种转换比较特别，可以独立开来，它的功能就是去除一个变量的const属性，也就是说，允许修改常量的值，哈哈，修改常量的值？既然要修改常量的值，那为什么还要声明它为常量？——这也是C++灵活的一个体现。不过const_cast其实有个问题，有时候它并不能真正改变一个常量的值，关于这个，在我的另一篇博文中有讲述，此文还在csdn.net，晚些时候移过来，我再给个链接。