练习题

1，输入两个字符串，从第一个字符串中删除第二个字符串中的所有字符。例如，“They are student.”和“aeiou”,则删除之后的第一个字符串就是“Thy r stdnt.”;
思路：首先必须的遍历第一个字符串，找到第二个字符串中出现的字符；但是如果拿第二个字符串的每一个字符挨个从第一个中找效率太慢，时间复杂度为O(m*n);于是我们可以用哈希表原理:是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度
代码如下：

#include<stdio.h>
#include<iostream>
using namespace std;
bool flag[256] = {false};

void fun(char* str1, const char* str2,int len1,int len2)
{
    if (str1 == NULL&&str2 == NULL)
        return;
    //把str2中的字符标记出来；方便后面遍历str1除去str2的字符
    for (int i = 0; i < len2; ++i)
    {
        int pos = static_cast<int>(str2[i]);
        flag[pos] = true;//true标记str2的字符
    }
    char* fast = str1;//遍历str1中的每个字符
    char* slow = str1;//要指向除去str2中字符后str1的位置
    while (*fast!='\0')
    {
        if (flag[*fast] == false)
        {
            *slow = *fast;
            ++slow;
        }
        ++fast;
    }
    *slow = 0;
}

int main()
{
    char str1[] = "They are studen.";
    const char str2[] = "aeiou";
    fun(str1, str2, sizeof(str1) / sizeof(str1[1]), sizeof(str2) / sizeof(str2[1]));
    cout << str1 << endl;
    system("pause");
    return 0;

2、找出n个数中最小的K个
思路：首先想到的是堆排序；我们如果按照升序排列数组就得建大堆，降序就用小堆。（比如：采用升序排列）

void AdjustDown(int a[], int i, int n)
{
    //建大堆
    int parent = i;
    int child = parent * 2 + 1;
    while (child<n)
    {
        if (child + 1 < n&&a[child + 1] > a[child])
        //child永远是左右中最大的
        {
            child++;
        }
        if (a[parent] < a[child])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = 2 * parent + 1;
        }
        else
            break;
    }
}

void Heapsort(int a[], size_t n,int k)
{
    for (int i = (n - 2) / 2; i >= 0; --i)
    {
        AdjustDown(a, i, n);
    }
    size_t end = n - 1;
    while (end)
    {
        swap(a[0], a[end]);
        AdjustDown(a, 0, end);
        --end;
    }
}

int main()
{
    int k = 5;
    int a[] = { 9, 6, 8, -10, 7, -11, 19, 30, 12, 23, 5 };
    size_t n = sizeof(a) / sizeof(a[1]);
    Heapsort(a, n, k);
    for (int i = 0; i < k; ++i)
    {
        cout << a[i]<<" ";
    }
    cout << endl;
    system("pause");
    return 0;
}
结果：找出最小的5个

3、判断一棵树是否是平衡二叉树
平衡二叉树，即一棵树的左子树与右子树的深度之差不能大于1，并且每一个子节点都是平衡二叉树。
要判断一棵树是否是平衡二叉树，由其定义我们很容易想到通过计算出左右两棵子树的高度及其高度差来进行判断。
首先，判断当前节点是否是平衡二叉树，则需要开始遍历整棵树，求其左右子树的高度。递归判断其左右子树是否为平衡二叉树，又一次需要遍历其子树求其高度。多次求其高度，越接近叶子节点的节点高度被求的次数越多，这种方法很容易理解，但是它的时间复杂度是O(N*N)，这是一种十分低效的算法

//1，计算树的深度

int GetTreeDepth(TreeNode* root)
{
    int dep = 0;
    if (root != NULL)
    {
        int left = GetTreeDepth(root->_left);
        int right = GetTreeDepth(root->_right);
        return left > right ? left + 1 : right + 1;
    }
    return 0;
}
//O(n*n)
bool IsBlance(TreeNode* root)
{
    if (root == NULL)
        return false;
    int left = GetTreeDepth(root->_left);
    int right = GetTreeDepth(root->_right);
    int div = left - right;
    if (div > 1 || div < -1)
        return false;
    return IsBlance(root->_left) && IsBlance(root->_right);
}

O（n）的算法
导致低效的原因是因为多次求了节点的高度，因此，考虑将高度放在参数列表中，在递归的过程中返回给上一层。也就是说，从叶子节点开始判断这棵树是否是平衡二叉树

//O(n)
bool IsBlance(TreeNode* root,int depth)
{
    if (root == NULL)
    {
        depth = 0;
        return true;
    }
    int left = 0;
    if (IsBlance(root->_left, left) == false)
        return false;
    int right = 0;
    if (IsBlance(root->_right, right) == false)
        return false;
    depth = left > right ? left + 1 : right + 1;
    return abs(left - right) < 2;
}

4、判断一棵树是否是完全二叉树：
完全二叉树：叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。

分析】完全二叉树树主要有两点：
1、当一个结点有右孩子，但是没有左孩子，直接返回false
2、当一个节点有左孩子无右孩子，那么接下来要遍历的节点必须是叶子结点。（叶子结点左右孩子为空）。

bool IsCompleteTree(TreeNode* root)
{
    if (root == NULL)
        return true;
    bool res = true;
    queue<TreeNode*> q;
    TreeNode* tmp;
    q.push(root);
    while (q.size>0)
    {
        for (int i = 0; i < q.size(); ++i)
        {
            tmp = q.front();
            q.pop();
            if (tmp->_left == NULL&&tmp->_right != NULL)
            {
                res = false;
                break;
            }
            if (tmp->_left != NULL)
                q.push(tmp->_left);
            if (tmp->_right)
                q.push(tmp->_right)
        }
    }
    return res;
}

5、合并两个有序单链表

//合并两个有序单链表
ListNode* ListMerge(LiseNode* head1, ListNode* head2)
{
    if (head1==NULL)
        return head2;
    if (head2==NULL)
        return head1;
    ListNode* p1 = head1;
    ListNode* p2 = head2;
    ListNode* newhead = NULL;
    //给新链表找头
    if (head1->_date < head2->_date)
    {
        newhead = head1;
        p1 = p1->_next;
    }
    else
    {
        newhead = head2;
        p2 = p2->_next;
    }
    ListNode* p = newhead;
    while (p1 != NULL&&p2 != NULL)
    {
        if (p1->_date > p2->_date)
        {
            p->_next = p2;
            p2 = p2->next;
        }
        else
        {
            p->_next = p1;
            p1 = p1->_next;
        }
        p = p->_next;
    }
    if (p1 == NULL)
        p->_next = p2;
    if (p2 == NULL)
        p->_next = p1;
    return newhead;

}