小算法

二叉树的一个演示动画：http://www.cs.usfca.edu/~galles/visualization/BST.html

对分查找(O(logN))：

int BinarySearch(const ElementType A[], ElementType X, int N)
{
    int Low, Mid, High;
    
    Low = 0; High = N - 1;
    while (Low <= Higt) {
        Mid = (Low + High) / 2;
        if (A[Mid] < X)
            Low = Mid + 1;
        else if (A[Mid] > X)
            High = MId - 1;
        else
            return Mid;
    }
    return NotFound;
}

欧几里得(求最大公因数):

unsigned int Gcd(unsigned int M, unsigned int N)
{   //if M > N
    unsigned int Rem;
    
    while (N > 0) {
        Rem = M % N;
        M = N;
        N = Rem;
    }
    return M;
}

快速取幂：

long int Pow(long int X, unsigned int N)
{
    if (N == 0)
        return 1;
    if (N == 1)
        return X;
    if (IsEven(N))
        return Pow(X * X, N / 2);
    else
        return Pow(X * X, N / 2) * X;
}

最长子序列和：

int MaxSubsequenceSum(const int A[], int N)
{
    int ThisSum, MaxSum, j;
    
    ThisSum = MaxSum = 0;
    for (int j = 0; j < N; j++) {
        ThisSum += A[j];
        if (ThisSum > MaxSum)
            MaxSum = ThisSum;
        else if (ThisSuhttp://i.cnblogs.com/EditPosts.aspx?opt=1m < 0)
            ThisSum = 0;
    }
    return MaxSum;
}

霍纳法则（秦九韶）多项式求和：

long long HornerRule(const int A[], int N)
{
    long long Poly = 0;
    for (int i = N; i >= 0; i--)
        Poly = X * Poly + A[i];  //A[i] is coefficient
    return Poly;
}

 快排：

#include <cstdio>
#include <iostream>
using namespace std;
void quick_sort(int dat[], int l, int r) {
    int i = l, j =r , mid = dat[r];
    do {
        while (dat[i] < mid) ++i;
        while (dat[j] > mid) --j;
        if (i <= j) {
            swap(dat[i], dat[j]);
            ++i; --j;
        }
    } while (i < j);
    if (l < j) quick_sort(dat, l, j);
    if (i < r) quick_sort(dat, i, r);
}
int main() {
    int dat[10] = {1, 4, 3, 2, 5, 3, 2, 5, 10, 9};
    quick_sort(dat, 0, 9);
    for (int i = 0; i < 10; ++i)
        printf("%d ", dat[i]);
    return 0;
}

 堆排：

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
priority_queue<int> myHeap;
int main() {
    int n = 5, num[5] = {1, 3, 2, 5, 4};
    for (int i = 0; i < n; ++i) {
        myHeap.push(num[i]);
    }
    for (int i = 0; i < n; ++i) {
        printf("%d\n", myHeap.top());
        myHeap.pop();
    }
  return 0;
}

 快速幂的非递归：

long int poww(long int x, long int n)
{
    int result = 1;
    int base = x;
    while (n != 0) {
        if (n&1)
            result *= base;
        base *= base;
        n >>= 1;
    } 
    return result;
}

 

蒜头君有一台神奇的魔法机，它能将输入的序列进行一系列复杂的变换，输出原序列的另一种排列方式。蒜头君十分好奇魔法机的工作原理，终于有一天他尝试着把魔法机拆开研究了。

通过一系列复杂的演算，蒜头君终于发现了魔法机的工作原理：其实魔法机就是一个栈，根据栈先进后出的性质，每次一个数字进栈或将栈顶元素弹出，由此可以产生不同的出栈序列，出栈序列就是原序列的另一种排列啦。

在研究完原理后，蒜头君凭借记忆很快就把魔法机组装好了。现在蒜头君想测试下魔法机在组装完成后是否出现问题。首先他将 1 到 N 这 N 个数字依次输入魔法机里，然后随机写下一组序列 a，现在他想知道能否通过魔法机得到序列 a。聪明的你能帮蒜头君算一算吗？

输入格式：

输入有两行，第一行是一个正整数 N (1 <= N <= 100)，表示输入魔法机序列的长度，第二行是序列 a，共有 N 个整数，表示要得到的目标序列。序列为 1 到 N 的排列，即序列 a 长度为 N，保证序列中的整数都不相同，且整数在区间 [1, N] 内。

输出格式：

输出一行。如果能通过魔法机得到序列 a，则输出“YES”，否则输出“NO”。
样例输入

5
2 1 5 4 3

样例输出

YES


#include<iostream>
#include<string>
#include<cassert>
using namespace std;
template<class Type> class Stack {
private:
    Type *urls;
    int max_size, top_index;
public:
    Stack(int length_input) {
        urls = new Type[length_input];
        max_size = length_input;
        top_index = -1;
    }
    ~Stack() {
        delete[] urls;
    }
    bool push(const Type &element) {
        if (top_index >= max_size - 1) {
            return false;
        }
        top_index++;
        urls[top_index] = element;
        return true;
    }
    bool pop() {
        if (top_index < 0) {
            return false;
        }
        top_index--;
        return true;
    }
    Type top() {
        assert(top_index >= 0);
        return urls[top_index];
    }
    bool empty() {
        if (top_index < 0) {
            return true;
        }
        else {
            return false;
        }
    }
};
int main() {
    int n, a;
    int ans, count = 0;
    cin >> n;
    ans = n;
    Stack<int> stack(n);
    
    int temp[n];
    for (int i = 0; i < n; ++i) {
        cin >> a;
        temp[i] = a;
    }
    
    for (int i = 0; i < n; ++i) {
        stack.push(i+1);
        while (!stack.empty() && stack.top() == temp[count]) {
            stack.pop();
            count++;
        }
    }
    if (count == ans) {
        cout << "YES" << endl;
    }
    else {
        cout << "NO" << endl;
    }
    return 0;
}

 

某天，蒜头君发现计蒜客上的用户名好多都长一样，蒜头君看着差点看晕了。为了区分用户名，蒜头君打算好好地清理清理。他将筛选出用户名一样的用户信息，然后给这些用户发邮件，提醒他们改一改用户名。需要注意的是，蒜头君不分大小写字母，所以他认为两个长度相等，每个字符对应一样的用户名是一样的，例如他认为用户名“jisuanke”和“JiSuanKe”是一样的。

现在蒜头君手里有 N 个用户名，他想知道哪些用户名是重复的。蒜头君按从前往后的顺序依次查看，如果用户名在前面出现过则输出“Yes”，否则输出“No”。现在蒜头君想请你帮他完成这项艰巨的任务，聪明的你能帮他完成吗？

输入格式：

输入第一行是一个正整数 N (1 <= N <= 100000)，表示一共有 N 个用户名。接下来有 N 行，每一行是一个用户名，长度不超过 100，均由大写字母和小写字母组成。

输出格式：

请按照输入顺序输出，如果用户名在前面出现过则输出“Yes”，否则输出“No”，一行输出一个。
样例输入

5
AbC
jisuanke
abc
JiSuanKe
Hello

样例输出

No
No
Yes
Yes
No




#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
using namespace std;
class HashTable {
private:
    string *elem;
    int size;
public:
    HashTable() {
        size = 200005;
        elem = new string[size];
        for (int i = 0; i < size; i++) {
            elem[i] = "#";
        }
    }
    ~HashTable() {
        delete[] elem;
    }
    int hash(string& index) {
        int code = 0;
        for (size_t i = 0; i < index.length(); i++) {
            code = (code * 256 + index[i] + 128) % size;
        }
        return code;
    }
    bool search(string& index, int& pos, int& times) {
        pos = hash(index);
        times = 0;
        while (elem[pos] != "#" && elem[pos] != index) {
            times++;
            if (times < size) {
                pos = (pos + 1) % size;
            } else {
                return false;
            }
        }
        if (elem[pos] == index) {
            return true;
        } else {
            return false;
        }
    }
    int insert(string& index) {
        int pos, times;
        if (search(index, pos, times)) {
            return 2;
        } else if (times < size / 2) {
            elem[pos] = index;
            return 1;
        } else {
            recreate();
            return 0;
        }
    }
    void recreate() {
        string* temp_elem;
        temp_elem = new string[size];
        for (int i = 0; i < size; ++i) {
            temp_elem[i] = elem[i];
        }
        int copy_size = size;
        size *= 2;
        delete[] elem;
        elem = new string[size];
        for (int i = 0; i < size; ++i) {
            elem[i] = "#";
        }
        for (int i = 0; i < copy_size; ++i) {
            if (temp_elem[i] != "#") {
                insert(temp_elem[i]);
            }
        }
        delete[] temp_elem;
    }
};
int main() {
    HashTable hashtable;
    string buffer;
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> buffer;
        transform(buffer.begin(), buffer.end(), buffer.begin(), ::tolower);
        int temp_pos, temp_times;
        if (hashtable.search(buffer, temp_pos, temp_times)) {
            cout << "Yes" << endl;
        } else {
            cout << "No" << endl;
        }
        int ans = hashtable.insert(buffer);
    }
    return 0;
}

 

 

蒜头君最近在学习二叉树，可是心不在焉的他一会儿就学累了，于是他想休息会儿。蒜头君拿出镜子，对着镜子中的自己各种卖萌。蒜头君无意间看见镜子中出现了一棵二叉树，这不是他刚画的那棵二叉树么，在镜子里怎么左右颠倒了呀。

蒜头君觉得好神奇，现在蒜头君又随手画了一棵二叉树，他想知道这棵二叉树在镜子里是长什么样的。为了将问题简单，现在蒜头君告诉你这棵二叉树的先序遍历结果和中序遍历结果，求原始二叉树的后序遍历结果，以及镜子里的二叉树的后序遍历结果。

输入格式：

输入第一行是一个字符串 pre_str，代表原始二叉树的先序遍历结果；输入第二行是一个字符串 in_str，代表二叉树的中序遍历结果。每个字符代表结点的编号，结点的编号互不相同，字符仅由大小写字母组成。保证两个字符串长度相等，长度最大不超过 50，且保证可以通过先序遍历结果和中序遍历结果构造出一棵唯一的二叉树。

输出格式：

输出第一行，输出一个字符串，代表原始二叉树的后序遍历结果；

输出第二行，输出一个字符串，代表镜子里的二叉树的后序遍历结果。
样例输入

abdce
dbaec

样例输出

dbeca
ecdba




#include<iostream>
#include<string>
using namespace std;
class Node {
public:
    int data;
    Node *lchild, *rchild;
    Node(int _data) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }
    void postorder() {
        if (lchild != NULL) {
            lchild->postorder();
        }
        if (rchild != NULL) {
            rchild->postorder();
        }
        printf("%c", data+48);
    }
    void ppostorder() {
        if (rchild != NULL) {
            rchild->ppostorder();
        }
        if (lchild != NULL) {
            lchild->ppostorder();
        }
        printf("%c", data+48);
    }
    Node* build(const string& pre_str, const string& in_str, int len) {
        Node* p = new Node(pre_str[0]-'0');
        int pos = in_str.find(pre_str[0]);
        if (pos > 0) {
            p->lchild = build(pre_str.substr(1, pos), in_str.substr(0, pos), pos);
        }
        if (len - pos - 1 > 0) {
            p->rchild = 
                build(pre_str.substr(pos+1), in_str.substr(pos+1), len-pos-1);
        }
        return p;
    }
};
class BinaryTree {
private:
    Node *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        if (root != NULL) {
            delete root;
        }
    }
    BinaryTree(const string& pre_str, const string& in_str, int len) {
        root = root->build(pre_str, in_str, len);
    }
    void postorder() {
        root->postorder();
    }
    void ppostorder() {
        root->ppostorder();
    }
};
int main() {
    string pre_str, in_str;
    cin >> pre_str >> in_str;
    BinaryTree binarytree(pre_str, in_str, in_str.length());
    binarytree.postorder();
    cout << endl;
    binarytree.ppostorder();
    cout << endl;
    return 0;
}

 

　　

蒜头君刚学会一项新技能——数据结构之二叉排序树。蒜头君想复习下刚学的知识，于是他找来一个序列，从序列第一个数开始，依次插入到二叉排序树里。蒜头君一边回忆刚学的知识，按照左孩子权值小，右孩子权值大的口诀，不一会儿就建立起了一棵二叉排序树。

现在蒜头君想来考考聪明的你：每个结点的左右孩子权值分别是什么？

输入格式：

第一行输入一个正整数 N (1 <= N <= 1000)，代表序列里元素个数。

第二行输入 N 个正整数，代表序列 a 的 N 个元素(0 <= ai <= 10000)。保证序列里的元素值互不相同。

输出格式：

请按格式“a(b, c)”，输出引号之间的内容，a 代表每个结点的权值，b 代表其左孩子结点权值，c 代表右孩子结点权值，如果孩子结点为空，则输出“#”代替。一个结点输出一行，按结点的权值从小到大输出。注意输出“,”后面的空格。
样例输入

5
2 5 3 1 4

样例输出

1(#, #)
2(1, 5)
3(#, 4)
4(#, #)
5(3, #)

#include<iostream>
using namespace std;
class Node {
public:
    int data;
    Node *lchild, *rchild, *father;
    Node(int _data, Node *_father = NULL) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
        father = _father;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }
    void insert(int value) {
        if (value == data) {
            return;
        } else if (value > data) {
            if (rchild == NULL) {
                rchild = new Node(value, this);
            } else {
                rchild->insert(value);
            }
        } else {
            if (lchild == NULL) {
                lchild = new Node(value, this);
            } else {
                lchild->insert(value);
            }
        }
    }
    Node* search(int value) {
        if (data == value) {
            return this;
        } else if (value > data) {
            if (rchild == NULL) {
                return NULL;
            } else {
                return rchild->search(value);
            }
        } else {
            if (lchild == NULL) {
                return NULL;
            } else {
                return lchild->search(value);
            }
        }
    }
    Node* predecessor() {
        Node *temp = lchild;
        while (temp != NULL && temp->rchild != NULL) {
            temp = temp->rchild;
        }
        return temp;
    }
    Node* successor() {
        Node *temp = rchild;
        while (temp != NULL && temp->lchild != NULL) {
            temp = temp->lchild;
        }
        return temp;
    }
    void remove_node(Node *delete_node) {
        Node *temp = NULL;
        if (delete_node->lchild != NULL) {
            temp = delete_node->lchild;
            temp->father = delete_node->father;
            delete_node->lchild = NULL;
        }
        if (delete_node->rchild != NULL) {
            temp = delete_node->rchild;
            temp->father = delete_node->father;
            delete_node->rchild = NULL;
        }
        if (delete_node->father->lchild == delete_node) {
            delete_node->father->lchild = temp;
        } else {
            delete_node->father->rchild = temp;
        }
        delete delete_node;
    }
    bool delete_tree(int value) {
        Node *delete_node, *current_node;
        current_node = search(value);
        if (current_node == NULL) {
            return false;
        }
        if (current_node->lchild != NULL) {
            delete_node = current_node->predecessor();
        }
        else if (current_node->rchild != NULL) {
            delete_node = current_node->successor();
        }
        else {
            delete_node = current_node;
        }
        current_node->data = delete_node->data;
        remove_node(delete_node);
        return true;
    }
    void inorder() {
        if (lchild != NULL) {
            lchild->inorder();
        }
        cout << data << "(";
        if (lchild) {
            cout << lchild->data;
        }
        else {
            cout << "#";
        }
         cout << "," << " ";
        if (rchild) {
            cout << rchild->data;
        }
        else {
            cout << "#";
        }
        cout << ")"<< endl;
        if (rchild != NULL) {
            rchild->inorder();
        }
    }
};
class BinaryTree {
private:
    Node *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        if (root != NULL) {
            delete root;
        }
    }
    void insert(int value) {
        if (root == NULL) {
            root = new Node(value);
        } else {
            root->insert(value);
        }
    }
    bool find(int value) {
        if (root->search(value) == NULL) {
            return false;
        } else {
           return true;
        }
    }
    bool delete_tree(int value) {
        return root->delete_tree(value);
    }
    void inorder() {
        root->inorder();
    }
};
int main() 
{
    BinaryTree binarytree;
    int n, a;
    cin >> n;
    while (n--) {
        cin >> a;
        binarytree.insert(a);
    }
    binarytree.inorder();
    return 0;
}