Chap4: question: 19

19. 二叉树的镜像（递归）

 即：交换所有节点的左右子树。从下往上 或 从上往下 都可以。

#include <iostream>
#include <string>
using namespace std;
struct BTNode
{
	int v;  // default positive Integer.
	BTNode *pLeft;
	BTNode *pRight;
	BTNode(int x) : v(x), pLeft(NULL), pRight(NULL) {}
};
/********************************************************/
/*****        Basic functions          ***********/
BTNode* createBinaryTree(int r)
{
	BTNode *pRoot = new BTNode(r);
	int u, v;
	cin >> u >> v;
	if(u != 0)
		pRoot->pLeft = createBinaryTree(u);
	if(v != 0)
		pRoot->pRight = createBinaryTree(v);
	return pRoot;
}
void release(BTNode *root){
	if(root == NULL) return;
	release(root->pLeft);
	release(root->pRight);
	delete[] root;
	root = NULL;
}
void print(BTNode *root, int level = 1){
	if(root == NULL) { cout << "NULL"; return; };
	string s;
	for(int i = 0; i < level; ++i) s += "   ";
	cout << root->v << endl << s;
	print(root->pLeft, level+1);
	cout << endl << s;
	print(root->pRight, level+1);
}
/******************************************************************/
void mirrorTree(BTNode *root)
{
	if(!root || (!root->pLeft && !root->pRight)) return;
	/*    交换左右子树           */
	BTNode *pTem = root->pLeft; 
	root->pLeft = root->pRight;
	root->pRight = pTem;

	mirrorTree(root->pLeft);
	mirrorTree(root->pRight);
}


int main(){
	int TestTime = 3, k = 1;
	while(k <= TestTime)
	{
		cout << "Test " << k++ << ":" << endl;
		
		cout << "Create a tree: " << endl;
		BTNode *pRoot = createBinaryTree(8);
		print(pRoot);
		cout << endl;

		cout << "The mirror tree: " << endl;
		mirrorTree(pRoot);
		print(pRoot);
		cout << endl;

		release(pRoot);
	}
	return 0;
}

 

 20. 顺时针打印矩阵

#include <stdio.h>

void printMatrix(int (*A)[1], int rows, int columns)
{
    if(rows < 1 || columns < 1) return;
    int r1, r2, c1, c2;
    r1 = c1 = 0, r2 = rows-1, c2 = columns-1;
    while(r1 <= r2 && c1 <= c2) /* 打印结束时， r1 = r2+1, c1 = c2+1; */
    {
        for(int i = c1; i <= c2 && r1 <= r2; ++i)
            printf("%d ", A[r1][i]);
        ++r1;
        for(int i = r1; c1 <= c2 && i <= r2; ++i)
            printf("%d ", A[i][c2]);      /*   要保证 c1 <= c2  */      
        --c2;
        for(int i = c2; i >= c1 && r1 <= r2; --i)
            printf("%d ", A[r2][i]);
        --r2;
        for(int i = r2; i >= r1 && c1 <= c2; --i)
            printf("%d ", A[i][c1]);
        ++c1;
    }
    printf("
");
}
int main()
{
    int test1[3][3] = {{1, 2, 3},
                       {4, 5, 6}, 
                        {7, 8, 9}};
    printMatrix(test1, 3, 3);

    int test2[1][3] = {1, 2, 3};
    printMatrix(test2, 1, 3);

/*  // first set int (*A)[1], then began called below. 
    int test3[3][1] = {{1}, {2}, {3}};
    printMatrix(test3, 3, 1);

    int test4[1][1] = {1};
    printMatrix(test4, 1, 1);
*/
    return 0;
}

      （）

 21. 包含 min  函数的栈

 要求调用 min，pop，push，时间复杂度都是 O(1)。

#include <iostream>
#include <stack>
#include <cassert>
#include <string>
template<typename T> class Stack
{
public:
    void push(T value);
    void pop();
    T min();
private:
    std::stack<T> data;
    std::stack<T> minData;
};
template<typename T> void Stack<T>::push(T value)
{
    data.push(value);
    if(minData.empty() || minData.top() >= value)
        minData.push(value);
    else
        minData.push(minData.top());
}
template<typename T> void Stack<T>::pop()
{
    assert(data.size() > 0 && minData.size() > 0);
    data.pop();
    minData.pop();
}
template<typename T> T Stack<T>::min()
{
    return minData.top();
}

int main()
{
    Stack<char> st;
    std::string numbers;
    while(std::cin >> numbers)
    {
        for(size_t i = 0; i < numbers.length(); ++i) st.push(numbers[i]);
        for(size_t i = 0; i < numbers.length(); ++i)
        {
            std::cout << "st.min(): " << st.min() << std::endl;
            st.pop();
        }
    }
    return 0;
}

22. 根据栈的压入序列，判断一个序列是否是弹出序列。 

#include <iostream>
#include <string>

bool isPopOrder(const std::string pushS, const std::string popS)
{
	size_t outId1 = 0, outId2 = 0, len1 = pushS.length(), len2 = popS.length();
	if(len1 != len2) return false;
	int *stack = new int[len1];
	int tail = 0; // 栈尾 
	while(outId1 < len1 && outId2 < len2)
	{
		while(pushS[outId1] != popS[outId2])
		{
			stack[tail++] = pushS[outId1++]; // 入栈
		}
		outId1++, outId2++;
		while(tail != 0 && popS[outId2] == stack[tail-1])
		{
			++outId2;
			tail--;     // 出栈
		}
	}
	delete[] stack;
	if(tail == 0) return true; // 栈空
	else return false;
}

int main()
{
	std::string numbers;
	std::string popNumbers;
	while(std::cin >> numbers >> popNumbers)
	{
		std::cout << "一个弹出序列?   " ;

		if(isPopOrder(numbers, popNumbers))
			std::cout << "true" << std::endl;
		else std::cout << "false" << std::endl;
	}
	return 0;
}

 

23. 从上往下打印二叉树

 Go:（Chap2: question: 1 - 10—>6. 重建二叉树—>二叉树的各种遍历）Link: http://www.cnblogs.com/liyangguang1988/p/3667443.html

24. 判断序列是否为二叉搜索树的后序遍历（递归）

note: 二叉搜索树和遍历序列一一对应。

例：后序序列 {3，5，4，6，11，13，12, 10, 8} ，可画出一颗二叉搜索树。

#include <iostream> 
/* verify the seq which should be the postOrder of a Binary Search Tree  */
bool postOrderOfBST(int sequence[], int len)
{
    if(sequence == NULL || len == 0) return false;
    bool answer = false;
    int root = sequence[len-1];    /* value of root node */

    int leftLength = 0;
    for(; leftLength < len-1; ++leftLength)
    {
        if(sequence[leftLength] > root) break;
    }
    /*  verify right-subtree, should big than root  */
    for(int i = leftLength + 1; i < len -1; ++i)
    {
        if(sequence[i] < root) return false;
    }

    int rightLength = len - 1 - leftLength;
    bool left = true, right = true;
    if(leftLength > 0)
        bool left = postOrderOfBST(sequence, leftLength);
    if(rightLength)
        bool right = postOrderOfBST(sequence+leftLength, rightLength);
    return (left && right);
}

void printResult(bool v)
{
    std::cout << "Is LRD of a BFS?  " ; 
    if(v)  std::cout << "true" << std::endl;
    else  std::cout << "false" << std::endl; 
}
int main() 
{
    std::cout << "Test 1: ";
    int test1[] = {3, 5, 4, 6, 11, 13, 12, 10, 8};
    printResult(postOrderOfBST(test1, sizeof(test1) / 4)) ;

    std::cout << "Test 2: ";
    int test2[] = {4, 2, 3}; 
    printResult(postOrderOfBST(test2, sizeof(test2) / 4)); 
        
    std::cout << "Test 3: ";
    int test3[] = {1};
    printResult(postOrderOfBST(test3, sizeof(test3) / 4));

    return 0; 
} 

  

 25. 二叉树中和为某一值的路径（递归）

#include <iostream> 
#include <string>
#include <vector>
using namespace std; 
struct BTNode 
{ 
    int v;  // default positive Integer. 
    BTNode *pLeft; 
    BTNode *pRight; 
    BTNode(int x) : v(x), pLeft(NULL), pRight(NULL) {} 
}; 
/********************************************************/
/*****        Basic functions          ***********/
BTNode* createBinaryTree(int r) 
{ 
    BTNode *pRoot = new BTNode(r); 
    int u, v; 
    cin >> u >> v; 
    if(u != 0) 
        pRoot->pLeft = createBinaryTree(u); 
    if(v != 0) 
        pRoot->pRight = createBinaryTree(v); 
    return pRoot; 
} 
void release(BTNode *root){ 
    if(root == NULL) return; 
    release(root->pLeft); 
    release(root->pRight); 
    delete[] root; 
    root = NULL; 
} 
void print(BTNode *root, int level = 1){ 
    if(root == NULL) { cout << "NULL"; return; }; 
    string s; 
    for(int i = 0; i < level; ++i) s += "	"; 
    cout << root->v << endl << s; 
    print(root->pLeft, level+1); 
    cout << endl << s; 
    print(root->pRight, level+1); 
} 
/******************************************************************/
void findPath(BTNode *root, int target, vector<int>& path, int curSum)
{
    if(root == NULL) return;
    curSum += root->v;
    path.push_back(root->v);
    if(!root->pLeft && !root->pRight && (curSum == target))  // root node is a leaf, get a path.
    {
        for(auto it = path.begin(); it != path.end(); ++it)
            cout << *it << " ";
        cout << endl;
    }
    findPath(root->pLeft, target, path, curSum);
    findPath(root->pRight, target, path, curSum);
    path.pop_back();
}

void findPath(BTNode *root, int target)
{
    if(root == NULL) return;
    vector<int> path;
    findPath(root, target, path, 0);
}

int main(){ 
    int TestTime = 3, k = 1; 
    while(k <= TestTime) 
    { 
        int root;
        cout << "Test " << k++ << ":" << endl; 

        cout << "Create a tree: " << endl; 
        cin >> root;
        BTNode *pRoot = createBinaryTree(root); 
        print(pRoot); 
        cout << endl; 

        cout << "target :  22" << endl << "findPath :" << endl; 
        findPath(pRoot, 22);

        release(pRoot); 
    } 
    return 0; 
} 

 26. 复杂链表的复制

#include <stdio.h>
typedef char Elem; 
typedef struct ComplexListNode
{
    Elem e;
    ComplexListNode *next;
    ComplexListNode *sibling;
} ComplexList;
ComplexListNode Node[26] = {0};
/***************************************************************/
ComplexList* creatComplexList()
{
    for(int i = 0; i < 26; ++i)
        Node[i].e = i + 'A';
    char u, v;
    while((scanf("%c%c", &u, &v) == 2) )
    {
        if(u >= 'A' && u <= 'Z' && v >= 'A' && v <= 'Z')
        {
            if(Node[u-'A'].next == NULL)
                Node[u-'A'].next = &Node[v-'A'];
            else if(Node[u-'A'].sibling == NULL)
                Node[u-'A'].sibling = &Node[v-'A'];
        }
        if(getchar() == '
') break;
    }
    return &Node[0];
}

void printComplexList(ComplexList *pHead)
{
    ComplexListNode *p = pHead;
    while(p != NULL)
    {
        printf("%c -> ", p->e);
        p = p->next;
    }
    printf("NULL
");
    p = pHead;
    while(p != NULL)
    {
        if(p->sibling != NULL)
        {
            printf("%c -> ", p->e);
            printf("%c	", p->sibling->e);
        }
        p = p->next;
    }
}
/***************************************************************************/
void cloneNodes(ComplexList *pHead)
{
    ComplexListNode *p = pHead;
    while(p != NULL)
    {
        ComplexListNode *newNode = new ComplexListNode;
        newNode->e = p->e + 32;
        newNode->next = p->next;
        newNode->sibling = NULL;
        p->next = newNode;
        p = newNode->next;
    }
}

void connectSibling(ComplexList *pHead)
{
    ComplexListNode *pPre = pHead, *p;
    while(pPre != NULL && pPre->next != NULL)
    {
        p = pPre->next;
        if(pPre->sibling != NULL)
            p->sibling = pPre->sibling->next;
        pPre = p->next;
    }
}

ComplexList* getClonedComplexList(ComplexList *pHead)
{
    ComplexListNode *pPre = pHead, *newHead = NULL, *p;
    while(pPre != NULL && pPre->next != NULL)
    {
        if(newHead != NULL) 
        {
            p->next = pPre->next;
            p = p->next;
        }
        else 
        {
            newHead = pPre->next;
            p = newHead;
        }
        pPre->next = pPre->next->next;
        pPre = pPre->next;
    }
    return newHead;
}

ComplexList* clone(ComplexList *pHead)
{
    cloneNodes(pHead);
    connectSibling(pHead);
    return getClonedComplexList(pHead);
}

int main()
{
    ComplexList *pHead = creatComplexList();
    printf("original List.
");
    printComplexList(pHead);

    ComplexList *newHead = clone(pHead);
    printf("cloned List.
");
    printComplexList(newHead);

    printf("original List.
");
    printComplexList(pHead);

    return 0;
}

程序说明：对一个结点，若 next 和 sibling 同时为 0，先保存 next 指针。
样例输入：AB AC BC BE CD DE DB(回车换行)

 

 27.二叉搜索树生成有序双向链表

#include <iostream> 
#include <string> 
using namespace std; 
typedef struct BTNode 
{ 
    int v;     // In this code, default positive Integer. 
    BTNode *pLeft; 
    BTNode *pRight; 
    BTNode(int x) : v(x), pLeft(NULL), pRight(NULL) {} 
} DbList; 
/********************************************************/
/*****        Basic functions  for binary tree     ***********/
BTNode* createBinaryTree() // input a preOrder sequence, 0 denote empty node.
{ 
    BTNode *pRoot = NULL;
    int r;
    cin >> r;
    if(r != 0)         // equal to if(!r) return;
    {
        pRoot = new BTNode(r);
        pRoot->pLeft = createBinaryTree();
        pRoot->pRight = createBinaryTree();

    }
    return pRoot;
} 

void printBinaryTree(BTNode *root, int level = 1){ 
    if(root == NULL) { cout << "NULL"; return; }; 
    string s; 
    for(int i = 0; i < level; ++i) s += "   "; 
    cout << root->v << endl << s; 
    printBinaryTree(root->pLeft, level+1); 
    cout << endl << s; 
    printBinaryTree(root->pRight, level+1); 
} 

// void releaseBinaryTree(BTNode *root){ 
//     if(root == NULL) return; 
//     releaseBinaryTree(root->pLeft); 
//     releaseBinaryTree(root->pRight); 
//     delete[] root; 
//     root = NULL; 
// } 
/******************************************************************/
/****************** basic function for double linked list. *******/
void printDbList(DbList *pHead)
{
    if(pHead == NULL) return;
    DbList *p = pHead;
    cout << "Print from left to right:" << endl;
    while(p->pRight != NULL) { cout << p->v << " "; p = p->pRight;}
    cout << p->v << endl;

    cout << "Print from left to right:" << endl;
    while(p != NULL) { printf("%-3d", p->v); p = p->pLeft;}
    cout << endl;
}
void releaseDbList(DbList *pHead)
{
    if(pHead == NULL) return;
    releaseDbList(pHead->pRight);
    delete[] pHead;
}
/******************************************************************/
/*****   binary search tree translate to double linked list    ******/
void convert(BTNode *root, BTNode **tail)
{
    if(root == NULL) return;

    if(root->pLeft != NULL)
        convert(root->pLeft, tail);
    root->pLeft = *tail;
    if(*tail) 
        (*tail)->pRight = root; 
    *tail = root; 
    
    if(root->pRight != NULL)
        convert(root->pRight, tail);
};

BTNode* treeToDList(BTNode *root)
{
    if(root == NULL) return NULL;
    BTNode *tail = NULL;
    convert(root, &tail);
    BTNode *pHead = tail;
    while(pHead != NULL && pHead->pLeft != NULL)
        pHead = pHead->pLeft;
    return pHead;
}

int main(){ 
    int TestTime = 3, k = 1; 
    while(k <= TestTime) 
    { 
        cout << "Test " << k++ << ":" << endl; 

        cout << "Create a tree: " << endl; 
        BTNode *pRoot = createBinaryTree(); 
        printBinaryTree(pRoot); 
        cout << endl; 

        DbList *DbListHead = treeToDList(pRoot); // pRoot translate to Double linked list.

        printDbList(DbListHead); 
        cout << endl; 

        releaseDbList(DbListHead); 
    } 
    return 0; 
}

note: 按先序输入，0表示结束。
样例输入：

a. 10 6 4 0 0 8 0 0 14 12 0 0 16 00

b. 0 (生成空树)

c. 1

d. 2 1 0 0 3 0 0

 28.字符串的全排列

Go：  ( 3. 字符的排列组合 )

 相关例题：八皇后问题（可扩展为 n 皇后问题）

 题目：8 x 8国际象棋上，摆8 个皇后，求她们任两个不同行、不同列且不在同一对角线上的摆法个数。

#include <stdio.h>
int solutionNumber = 0;

void print(int data[], int length)
{
	for(int i = 0; i < length; ++i)
		printf("(%d, %d)  ", i+1, data[i]+1);
	printf("
");
}
bool judge(int data[], int length)
{
	for(int i = 0; i < length; ++i)
	{
		for(int j = i +1; j < length; ++j)
		{
			if((j - i) == (data[j] - data[i]) || (j - i) == data[i] - data[j])
				return false; // not the solution
		}

	}
	return true;
}
void swap(int &a, int &b) // do not forget the reference.
{
	int tem = a;
	a = b;
	b = tem;
}

void permutation(int data[], int length, int begin)
{
	if(begin == length-1)
	{
		if(judge(data, length))
		{
		//	print(data, length);
			++solutionNumber;
		}
		return;
	}
	for(int start = begin; start < length; ++start)
	{
		swap(data[start], data[begin]);
		permutation(data, length, begin+1);
		swap(data[start], data[begin]);
	}
}

int main()
{
	int columnIndex[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};  /* 不在同行同列  */
	permutation(columnIndex, 8, 0);              /*  判断是否可以不在同一对角线  */
	printf("Number of Solution: %d
", solutionNumber);
	return 0;
}