数据结构 on ZRJ | 学习笔记

Populating Next Right Pointers in Each Node II

Sat, 20 Jun 2015 11:03:28 +0800

来看这个题，https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/，要求常数空间，想了想，没想到，找了答案，是这样

class Solution {
public:
    void connect(TreeLinkNode *root) {
        if (!root) {
            return;
        }
        TreeLinkNode dummy(-1);
        for (TreeLinkNode *prev = &dummy, *curr = root; curr; curr = curr->next) {
            if (curr->left) {
                prev->next = curr->left;
                prev = prev->next;
            }
            if (curr->right) {
                prev->next = curr->right;
                prev = prev->next;
            }
        }
        connect(dummy.next);
    }
};

脑子里跑了一遍，感觉理解不了啊，想不通的是，5->7 的那个连接是怎么连上去的

1 -> NULL
       /  \
      2 -> 3 -> NULL
     / \    \
    4-> 5 -> 7 -> NULL

如果你看上面的代码可以理解 5->7 的连接，后面的就不用看了，不行的话，看这个，写了一个 debug 代码

#include <stdio.h>
struct TreeLinkNode {
 int val;
 TreeLinkNode *left, *right, *next;
 TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
};
class Solution {
public:
    void connect(TreeLinkNode *root) {
        if (!root) {
            return;
        }
        TreeLinkNode dummy(-1);
        for (TreeLinkNode *prev = &dummy, *curr = root; curr; curr = curr->next) {
            if (curr->left) {
				printf("connecting %p(%d) to %p(%d)\n", prev, prev?prev->val:0, curr->left, curr->left->val);
                prev->next = curr->left;
                prev = prev->next;
            }
			if (curr->right) {
				printf("connecting %p(%d) to %p(%d)\n", prev, prev?prev->val:0, curr->right, curr->right->val);
                prev->next = curr->right;
                prev = prev->next;
            }
        }
        connect(dummy.next);
    }
};
void print(TreeLinkNode* node) {
	printf("%p(%d) left:%p(%d) right:%p(%d) next:%p(%d)\n", node, node->val, 
		node->left, node->left?node->left->val:0, 
		node->right, node->right?node->right->val:0,
		node->next, node->next?node->next->val:0);
}
void inOrder(TreeLinkNode* root) {
	if (!root) {
		return;
	}
	print(root);
	inOrder(root->left);
	inOrder(root->right);
}
int main() {
	TreeLinkNode root(1), two(2), three(3), four(4), five(5), six(6), seven(7);
	root.left = &two;
	root.right = &three;
	two.left = &four;
	two.right = &five;
	three.right = &seven;
	inOrder(&root);
	printf("-----------------------------\n");
	Solution solution;
	solution.connect(&root);
	printf("-----------------------------\n");
	inOrder(&root);
	return 0;
}

看一下输出

0012FF1C(1) left:0012FF04(2) right:0012FEEC(3) next:00000000(0)
0012FF04(2) left:0012FED4(4) right:0012FEBC(5) next:00000000(0)
0012FED4(4) left:00000000(0) right:00000000(0) next:00000000(0)
0012FEBC(5) left:00000000(0) right:00000000(0) next:00000000(0)
0012FEEC(3) left:00000000(0) right:0012FE8C(7) next:00000000(0)
0012FE8C(7) left:00000000(0) right:00000000(0) next:00000000(0)
-----------------------------
connecting 0012FD84(-1) to 0012FF04(2)
connecting 0012FF04(2) to 0012FEEC(3)
connecting 0012FC6C(-1) to 0012FED4(4)
connecting 0012FED4(4) to 0012FEBC(5)
connecting 0012FEBC(5) to 0012FE8C(7)
-----------------------------
0012FF1C(1) left:0012FF04(2) right:0012FEEC(3) next:00000000(0)
0012FF04(2) left:0012FED4(4) right:0012FEBC(5) next:0012FEEC(3)
0012FED4(4) left:00000000(0) right:00000000(0) next:0012FEBC(5)
0012FEBC(5) left:00000000(0) right:00000000(0) next:0012FE8C(7)
0012FEEC(3) left:00000000(0) right:0012FE8C(7) next:00000000(0)
0012FE8C(7) left:00000000(0) right:00000000(0) next:00000000(0)

脑子里再过一遍，应该就能理解了

Linked List Cycle

Mon, 20 Oct 2014 16:24:57 +0800

所谓拳不离手曲不离口，算法和基础不能丢。

话说三藏师徒四人辞别女儿国，再上西行路，今天来到。。。啊呸，扯远了。。

今天来看这个，https://oj.leetcode.com/problems/linked-list-cycle/，题目是这么说的

Given a linked list, determine if it has a cycle in it.

Follow up: Can you solve it without using extra space?

这题原本是简单，他页面上提供了一个在线的编辑器，带语法高亮和自动补全，我三分钟直接在线写完，一次性提交就编译通过同时 Accepted，想想上次刷 OJ 还是很久之前了，如今依然没有手生，还是很开心的，土豪解法如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include <set>
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* curr = head;
        while (curr) {
            if (viewed.find(curr) != viewed.end()) {
                return true;
            }
            viewed.insert(curr);
            curr = curr->next;
        }
        return false;
    }
    std::set<ListNode*> viewed;
};

类和函数是他给好的，我们要做的就是在类里面填空而已。

可以看到，这个解法不论是在时间还是空间上，都是土豪，何止土豪，那是相当土豪。不过，实际项目中，其实这么写是可以的，稳定，不出错，可维护性高。

不过，原题里还有这么一句，Can you solve it without using extra space?，这个很明显就是见功夫的地方了，要抠时间和空间，时间上是没啥可压缩了，至少也要遍历一次，空间上嘛，他要求没有额外空间，怎么搞呢，想了想，想起来之前看书的时候看到这个题，当时说的是，用两个指针，一个每次走一步，一个每次走两步，如果这两个指针遇上了，那么就说明有环，具体写起来，可以这么写：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
            if (slow == fast) {
                return true;
            }
        }
    }
};

又是一次 Accepted，我都怀疑是不是用例太弱了。。

需要注意的是，如果把最后的两个 if 判断对调位置，变成这样

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (slow == fast) {
                return true;
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
        }
    }
};

那就会导致 WA，具体为什么可以想想，不难想出来。

不过，这个题目还有一个变式，要求找出环的入口节点，题目在这里，https://oj.leetcode.com/problems/linked-list-cycle-ii/，这个题的解法很是有技巧，分析思路可以看到这里，http://blog.reetsee.com/archives/187

我们设链表的无环的部分长度为L1，即有L1个节点，注意，这个L1是包括环的入口节点的。然后让环的长度是L2，这个L2也是包括环的入口节点。这个时候，p1和p2的交点如图所示，交点距离环的入口节点为a（从入口节点沿着行走方向走到交点），即在环的入口节点后面的第a个节点，就是交点，我用红色标记出a。

然后我们来考察一下L1，L2，a，以及n（n是走过的步数，不是走过的节点数，p1一步一个节点，p2一步两个节点）的关系。

忘记说一点了，我们可以明确的是，p1在进入环后，走了不到一圈就在交点处和p2重合，為什麼肯定没有走完一圈？因为p1在进入环的时候，p2和p1之间的距离（沿着行走方向）至多为 L2-1，不可能超过L2-1，因为环的大小也才只有L2 。p2追赶p1，最多只需要走L2-1步，因为每走一步，p1和p2的相对距离减小1，那么p1最多只走了L2-1步，就是最多只经过了L2-1个节点，不可能走完一圈。

现在可以列公式了：

L1+a=n #1 //n是p1走过的节点数 L1+k*L2+a=2*n #2 //2*n这个是p2走过的节点数，其中的k表示p2可能在环里面走了k圈，k>=1 由#2式减去#1式，有：

k*L2 = n #3 同时由#1和#3得到：

L1+a = k*L2 #4 接着由#4就得到了如下式：

L1 = k*L2 – a = (k-1)*L2 + (L-a) 得到这条式子就拨得云开见月明啊有木有，因为(L-a)表示的是交点与环入口的距离（从交点沿着行走方向到环入口），然后(k-1)是>=0的，因为p2在环中至少绕了一圈，这样我们就发现：L1的长度 = 环长度的整数倍 + 交点与环入口的距离

也就是说，p1再走L1步就可以达到环的入口。问题是L1不是已知的，没关系，在表头设置一个p3指针，p3每步前进一个节点。让p1和p3同时走，每次走1步，等p3和p1重合了，就是到了环口的位置了。Problem solved~

很自然的，写出下面的代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

但是这样是 WA 的，OJ 很仁慈的把错误说出来了

Input: {1,2}, tail connects to node index 0 Output: tail connects to node index 1 Expected: tail connects to node index 0

也就是说，考虑这种情况：整个链表只有两个节点，并且这两个节点构成一个环，那么上述代码就出错了，打个补丁：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                if (slow == head) {
                    return head;
                }
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

得以 Accepted，而其实，上述的代码，是可以进一步改的，注意到我们外面的那个循环，为了保守起见，是等慢指针遍历到尾，才退出的，其实根本没必要，只要快指针遇到 NULL 了，就可以撤了，如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head);
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                ListNode *p(head);
                while (p != slow) {
                    slow = slow->next;
                    p = p->next;
                }
                return p;
            }
        }
        return NULL;
    }
};

-——————————-

2014-11-21 09:43:45 update

另外的一个思路是，每次前进一个节点，就把这个节点的 next 指针指向 head，这样，如果发现在某个节点被处理之前，就已经指向 head，那么就可以知道有环了，而且这个方法还可以天然的找出环的入口，不需要额外空间，缺点是破坏链表，一次处理之后，链表就被破坏的面目全非了。

这个思路尚未经过实际代码验证。

历史评论

wanax (2015-01-20 14:38:47):

真有闲情逸致….

tr1 的 unorderd_map

Thu, 24 Apr 2014 11:17:15 +0800

#include <tr1/unordered_map>
#include <stdio.h>
#include <string>

int main() {
    typedef std::tr1::unordered_map<std::string, int> HashMap;
    HashMap mapNumber;
    mapNumber["one"] = 1;
    mapNumber["two"] = 2;
    std::tr1::hash<std::string> hashFunc = mapNumber.hash_function();
    for (HashMap::const_iterator it = mapNumber.begin();
            it != mapNumber.end(); it++) {
        printf("%s(hash code: %d) -> %d\n", it->first.c_str(),
                hashFunc(it->first), it->second);
    }
    return 0;
}

two(hash code: 1149015817) -> 2
one(hash code: 566910127) -> 1

如果需要自定义类型，可以看这里，http://hi.baidu.com/wewe39/item/c342d5f48cb25d0ec6dc45a9

稍后做一下和 std::map 的查找效率对比

-————————-

2014-4-24 13:03:39 update

刚刚看了一下效率对比

#include <tr1/unordered_map>
#include <map>
#include <stdio.h>
#include <string>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>

std::map<std::string, int> rbtreeMap;
std::tr1::unordered_map<std::string, int> hashMap;

void printtime() {
    struct timeval tm;
    gettimeofday(&tm, NULL);
    printf("%lu, %lu\n", tm.tv_sec, tm.tv_usec);
}

void initRbtreeMap(int init_count) {
    for (int i = 0; i < init_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        rbtreeMap[str] = r;
    }
    printf("rb tree map size %d\n", rbtreeMap.size());
}

void initHashMap(int init_count) {
    for (int i = 0; i < init_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        hashMap[str] = r;
    }
    printf("hash map size %d\n", hashMap.size());
}

void testRbtreeMap(int init_count, int test_count) {
    int hit = 0, miss = 0;
    for (int i = 0; i < test_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        if (rbtreeMap.find(str) == rbtreeMap.end()) {
            miss++;
        } else {
            hit++;
        }
    }
    printf("rb tree hit count %d miss count %d\n",
            hit, miss);
}

void testHashMap(int init_count, int test_count) {
    int hit = 0, miss = 0;
    for (int i = 0; i < test_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        if (hashMap.find(str) == hashMap.end()) {
            miss++;
        } else {
            hit++;
        }
    }
    printf("hash tree hit count %d miss count %d\n",
            hit, miss);
}

int main() {
    srand(time(NULL));
    int init_count = 500 * 1000;
    printtime();
    initRbtreeMap(init_count);
    printtime();
    initHashMap(init_count);
    printtime();
    int test_count = 10 * 1000 * 1000;
    testRbtreeMap(init_count, test_count);
    printtime();
    testHashMap(init_count, test_count);
    printtime();
    return 0;
}

1398315723, 65363
rb tree map size 316072
1398315724, 33265
hash map size 316202
1398315724, 423226
rb tree hit count 6320750 miss count 3679250
1398315743, 283560
hash tree hit count 6323107 miss count 3676893
1398315748, 386742

练手代码白板

Sun, 02 Mar 2014 17:14:15 +0800

先来一个简单的 list

#include <stdio.h>

class ListNode {
public:
	ListNode(int n) {
		this->n = n;
		this->pNext = NULL;
	}
	int n;
	ListNode* pNext;
};

class List {
public:
	ListNode* pHead;
	List(ListNode* pHead) {
		this->pHead = pHead;
	}
	List* add(ListNode* node) {
		ListNode* pCurr = pHead;
		while (pCurr->pNext) {
			pCurr = pCurr->pNext;
		}	
		pCurr->pNext = node;
		return this;
	}
	List* reverse() {
		ListNode* pCurr = pHead;
		ListNode* pNext = pCurr->pNext;
		pHead->pNext = NULL;
		while (pNext) {
			ListNode* pTmp = pNext->pNext;
			pNext->pNext = pCurr;
			pCurr = pNext;
			pNext = pTmp;
		}
		pHead = pCurr;
		return this;
	}
	List* sort() {
		ListNode* pOldHead = pHead->pNext;		
		ListNode* pNewHead = pHead;
		pNewHead->pNext = NULL;
		while (pOldHead) {
			ListNode *pNewPre = NULL, 
				*pNewCurr = pNewHead, 
				*pTmp = pOldHead->pNext;
			for (; pNewCurr && pNewCurr->n <= pOldHead->n; 
				pNewPre = pNewCurr, pNewCurr = pNewCurr->pNext);
			if (pNewCurr == pNewHead) {
				pOldHead->pNext = pNewHead;
			} else {
				pNewPre->pNext = pOldHead;
				pOldHead->pNext = pNewCurr;
			}
			pOldHead = pTmp;
		}
		pHead = pNewHead;
		return this;
	}
	List* print() {
		ListNode* pCurr = pHead;
		while (pCurr) {
			printf("%d -> ", pCurr->n);
			pCurr = pCurr->pNext;
		}
		printf("NULL\n");
		return this;
	}
	~List() {
		ListNode* pCurr = pHead;
		while (pCurr) {
			ListNode* pNext = pCurr->pNext;
			printf("deleting %d\n", pCurr->n);
			delete pCurr;
			pCurr = pNext;
		}
	}
};

int main() {
	List* l = new List(new ListNode(0));
	l->add(new ListNode(2))
		->add(new ListNode(3))
		->add(new ListNode(1))
		->add(new ListNode(4))
		->add(new ListNode(0))
		->add(new ListNode(5));
	l->print();
	l->sort();
	l->print();
	delete l;
	return 0;
}

几个排序

#include <stdio.h>

void print(int* pArr, int n) {
	while (n--) {
		printf("%d\t", *pArr);
		pArr++;
	}
	printf("\n");
}

inline swap(int* pA, int* pB) {
	int tmp = *pA;
	*pA = *pB;
	*pB = tmp;
}

void bubbleSort(int* pArr, int n) {
	for (int i = 0; i < n; i++) {
		for (int j = 1; j < n - i; j++) {
			if (pArr[j-1] > pArr[j]) {
				swap(&pArr[j-1], &pArr[j]);
			}
		}
	}
}

void selectSort(int* pArr, int n) {
	for (int i = 0; i < n; i++) {
		int min = i;
		for (int j = i; j < n; j++) {
			if (pArr[j] < pArr[min]) {
				swap(&pArr[j], &pArr[min]);
			}
		}
	}
}

void quickSort(int* pArr, int i, int j) {
	int a = i, b = j, p = (i + j) / 2;
	while (a <= b) {
		while (pArr[a] < pArr[p]) {
			a++;
		}
		while (pArr[b] > pArr[p]) {
			b--;
		}
		if (a <= b) {
			swap(&pArr[a], &pArr[b]);
			a++;
			b--;
		}
	}
	if (i < b) {
		quickSort(pArr, i, b);
	}
	if (a < j) {
		quickSort(pArr, a, j);
	}
}

int main() {
	int a[] = {5, 2, 1, 4, 3, 0, 0};
	int len = sizeof(a)/sizeof(int);
	print(a, len);
	//bubbleSort(a, len);
	//selectSort(a, len);
	quickSort(a, 0, len);
	print(a, len);
	return 0;
}

再来，字符集差集

#include <bitset>
#include <vector>

class CCharSubSet {
public:
    char* a;
    char* b;
    std::vector<char> c;
    
    CCharSubSet() {
        a = "abcd";
        b = "bd";
    }
    
    int Sub() {
        std::bitset<256> bitsetA, bitsetB;
        bitsetA.reset();
        bitsetB.reset();
        for (size_t i = 0; i < strlen(a); i++) {
            bitsetA[a[i] + 128] = true;
        }
        for (size_t i = 0; i < strlen(b); i++) {
            bitsetB[b[i] + 128] = true;
        }
        bitsetA ^= bitsetB;
        for (int i = 0; i < 256; i++) {
            if (bitsetA[i]) {
                c.push_back(i - 128);
            }
        }
        for (size_t i = 0; i < c.size(); i++) {
            printf("%c\n", c[i]);
        }
        return 0;
    }
};


int main() {
    CCharSubSet oCharSubSet;
    oCharSubSet.Sub();
    return 0;
}

条件找数

#include <bitset>
#include <set>
#include <vector>
#include <map>

class CNumber {
    static const int MAX = 100000;
    std::vector<int> vecPrimeTable;

    int InitPrimeTable() {
        std::bitset<MAX> isPrime;
        isPrime.set();
        isPrime[0] = isPrime[1] = false;
        for (int i = 2; i*i < MAX; i++) {
            if (isPrime[i]) {
                for (int j = i*i; j < MAX; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        for (int i = 2; i < MAX; i++) {
            if (isPrime[i]) {
                vecPrimeTable.push_back(i);
            }
        }
        return 0;
    }

    std::map<int, int> mapDigitalSum;

    int DigitalSumOf(int n) {
        if (mapDigitalSum[n] == 0) {
            int iTmp = n;
            int iSum = 0;
            while (iTmp) {
                iSum += iTmp % 10;
                iTmp /= 10;
            }
            mapDigitalSum[n] = iSum;
        }
        return mapDigitalSum[n];
    }

    std::set<int> setResult;
    
    int Dfs(int iCurr, int iMulti, int iSum) {
        //printf("%d, %d, %d\n", iCurr, iMulti, iSum);
        if (iMulti > MAX || iMulti < 0) {
            return -1;
        }
        if (DigitalSumOf(iMulti) == iSum) {
            setResult.insert(iMulti);
        }
        for (size_t i = 0; i < vecPrimeTable.size(); i++) {
            if (vecPrimeTable[i] < iCurr) {
                continue;
            }
            if (Dfs(vecPrimeTable[i], iMulti * vecPrimeTable[i],
                iSum + DigitalSumOf(vecPrimeTable[i])) == -1) {
                break;
            } 
        }
        return 0;
    }

    int Print() {
        for (std::set<int>::iterator it = setResult.begin();
                it != setResult.end(); it++) {
            printf("%d\n", *it);
        }
        return 0;
    }
    
public:
    int Run() {
        InitPrimeTable();
        Dfs(vecPrimeTable[0], 1, 0);
        Print();
        return 0;
    }
};

int main() {
    CNumber oNumber;
    oNumber.Run();
    return 0;
}

-————————————

2014-3-7 09:16:05 update 字符集差集还可以这么来写

#include <set>
#include <vector>
#include <algorithm>
#include <string>

class CCharSetDiff {
public:
    std::string Diff(std::string strA, std::string strB) {
        std::set<char> setA(strA.begin(), strA.end());
        std::set<char> setB(strB.begin(), strB.end());
        std::vector<char> vecDiff(256);
        std::set_difference(setA.begin(), setA.end(),
            setB.begin(), setB.end(), vecDiff.begin());
        return std::string(vecDiff.begin(), vecDiff.end());         
    }
};

int main() {
    CCharSetDiff oCharSetDiff;
    printf("%s\n", oCharSetDiff.Diff("abcd", "bd").c_str());
    return 0;
}

历史评论

wanax (2014-03-19 16:44:58):

这是新装了VS2013看着PL忍不住玩一下么

ZRJ (2014-03-19 20:14:43):

我还在用 vs 2005,2013 长啥样

wanax (2014-03-20 09:48:49):

蛮好看的都忍不住要装win8来试下了

allen (2014-06-10 19:54:42):

差集的 +128的写法木有看明白，不加不是照样做出来吗？

ZRJ (2014-06-10 20:30:46):

嗯，一般情况是没问题的，但是注意到 a b 两个变量，是声明为 char* 类型，而不是 unsigned char* 类型，所以 a[i] b[i] 的值可能为负，如果为负，用负值作为下标去索引 bitsetA bitsetB 就可能越界

STL set 的一些实现差异

Wed, 18 Dec 2013 11:32:18 +0800

侯捷大师在 STL 源码剖析中说道，set 的迭代器的值是不可改变的，这个本来很好理解，但是我神奇的在 visual studio 2005 上发现，神奇的事情总是会发生

#include <stdio.h>
#include <map>
#include <string>
#include <set>

int main() {
    std::set<int> setInt;
    setInt.insert(1);
    setInt.insert(2);
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    {
        std::set<int>::iterator it = setInt.begin();
        *it = 4;
        it++;
        *it = 3;
    }
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    return 0;
}

居然顺利的编译通过，而且可以跑，看看输出

1
2
4
3
请按任意键继续. . .

照理说，set 的底下是红黑树的话，这里应该是会违反红黑树的大小排序原则的。。

甚至改成这样

#include <stdio.h>
#include <map>
#include <string>
#include <set>

int main() {
    std::set<int> setInt;
    setInt.insert(1);
    setInt.insert(2);
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    {
        std::set<int>::iterator it = setInt.begin();
        *it = 4;
        it++;
        *it = 4;
    }
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    return 0;
}

也可以。。好吧，set 的原则也被破坏了。。

来看 gcc 4.1 的编译输出

StlContainerTest.cpp:25:2: warning: no newline at end of file
StlContainerTest.cpp: In function 'int main()':
StlContainerTest.cpp:16: error: assignment of read-only location
StlContainerTest.cpp:18: error: assignment of read-only location

这个才是符合预期的嘛，M$ 这样会坑死人啊。。

二级指针删除单向链表

Mon, 04 Feb 2013 23:22:29 +0800

今晚在这里看到一篇文章，http://coolshell.cn/articles/8990.html，原文给的是代码片段，本着动手实践的原则，另外顺便复习一下链表，写了下代码

#include <stdio.h>
#include <stdlib.h>

typedef struct _node {
	int n;
	struct _node *next;
} node;

typedef int (* remove_fn)(node const *n);

node *create_link();
void destory_link(node *head);
void print_link(node *head);
int should_remove(node const *n);
node *remove_if(node *head, remove_fn should_remove);
void remove_if2(node **head, remove_fn should_remove);

int main() {
	node *head = create_link();
	print_link(head);
	//head = remove_if(head, should_remove);
	remove_if2(&head, should_remove);
	print_link(head);
	destory_link(head);
	return 0;
}

node *create_link() {
	node *head = malloc(sizeof(node));
	if (head == NULL) {
		printf("malloc head failed\n");
		return NULL;
	}
	head->n = 0;
	head->next = NULL;

	node *pre = head;
	for (int i=1; i<10; i++) {
		node *cur = malloc(sizeof(node));
		if (cur == NULL) {
			printf("malloc node %d failed\n", i);
			return NULL;
		}
		pre->next = cur;
		cur->n = i;
		cur->next = NULL;
		pre = cur;
	}

	return head;
}

void destory_link(node *head) {
	node *cur = head;
	while (cur) {
		node *next = cur->next;
		free(cur);
		cur = next;
	}
}

void print_link(node *head) {
	node *cur = head;
	while (cur) {
		printf("%d\t", cur->n);
		cur = cur->next;
	}
	printf("\n");
}

int should_remove(node const *n) {
	if (n == NULL) {
		return 0;
	}
	return (n->n)%2 == 0;
}

node *remove_if(node *head, remove_fn should_remove) {
	for (node *pre = NULL, *cur = head; cur;) {
		node * const next = cur->next;
		if (should_remove(cur)) {
			if (pre) {
				pre->next= next;
			} else {
				head = next;
			}
			free(cur);
		} else {
			pre = cur;
		}
		cur = next;
	}
	return head;
}

void remove_if2(node **head, remove_fn should_remove) {
	for (node **cur = head; *cur;) {
		node *entry = *cur;
		if (should_remove(entry)) {
			*cur = entry->next;
			free(entry);
		} else {
			cur = &(entry->next);
		}
	}
}

编译运行一下

zrj@zrj-desktop:~/c$ gcc -g -std=gnu99 link.c && ./a.out
0    1    2    3    4    5    6    7    8    9
1    3    5    7    9

其实道理不复杂，自己多读两遍代码就懂了，不得不承认这种写法确实很巧妙，而且就可读性来说，其实也没有下降多少

出栈次序问题

Mon, 24 Sep 2012 08:14:43 +0800

昨天笔试，见到一个题

一个栈(无穷大)的进栈序列为1,2,3,..n,有多少个不同的出栈序列?

写代码模拟的结果如下

#include <iostream>
#include <stack>
#include <queue>
#include <set>

using namespace std;

set<queue<int>> total;

void print(queue<int> q)
{
	total.insert(q);
	while ( ! q.empty())
	{
		printf("%d ", q.front());
		q.pop();
	}
	printf("n");
}

void push(stack<int> s, int max, int n, queue<int> q)
{
	if (n > max)
	{
		while( ! s.empty())
		{
			q.push(s.top());
			s.pop();
		}
		print(q);
	}
	else
	{
		// 压栈不弹
		s.push(n);
		push(s, max, n+1, q);
		s.pop();

		// 压栈并弹
		s.push(n);
		int size = s.size();
		for (int i=0; i<size; i++)
		{
			q.push(s.top());
			s.pop();
			push(s, max, n+1, q);
		}
	}
}

int main()
{
	int n;
	while (cin>>n && n!=0)
	{
		stack<int> s;
		queue<int> q;
		total.clear();
		push(s, n, 1, q);
		printf("%dn", total.size());
	}
	return 0;
}

输入输出

可以看到上面有重复，下面以 n 为 2 解释一下

n 为 2 的输出有 5 行，5 种过程如下

1. 1 压栈，不弹
2 压栈，不弹
所有数字压栈完毕，依次弹栈，并打印，输出是 2 1
1. 1 压栈，不弹
2 压栈，弹 1 一个数字，放入待打印队列，队列现为 2
所有数字压栈完毕，现在栈为 1，把 1 弹出来，追加到待打印队列，现在队列为 2 1，输出是 2 1
1. 1 压栈，不弹
2 压栈，弹 2 1 两个数字，放入待打印队列，队列现为 2 1
所有数字压栈完毕，现在栈为空，现在队列为 2 1，输出是 2 1
1. 1 压栈，并弹栈，放入待打印队列，队列现为 1
2 压栈，不弹
所有数字压栈完毕，现在栈为 2，把 2 弹出来，追加到待打印队列，现在队列为 1 2，输出是 1 2
1. 1 压栈，并弹，放入待打印队列，队列现为 1
2 压栈，并弹，放入待打印队列，队列现为 1 2
所有数字压栈完毕，现在栈为空，现在队列为 1 2，输出是 1 2

这个东西叫做卡特兰数，卡特兰数的性质可以参考这里，http://peng5047.iteye.com/blog/976822

1.卡特兰数是一种数列，以比利时的数学家欧仁·查理·卡塔兰命名。 2.卡特兰数列：1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012…… 令第n项为h(n)，则： h(0) = 1; h(1) = 1; h(n) = h(0)*h(n-1) + h(1)*h(n-2) + …… + h(n-1)*h(0)，其中n>=2 卡特兰数的另一种形式：h(n) = C(2n,n)/(n + 1)，其中n>=1

百度百科，http://baike.baidu.com/view/2499752.htm，里面也有关于这个的分析，写的挺清楚的，摘录过来

常规分析　　首先，我们设f（n）=序列个数为n的出栈序列种数。同时，我们假定第一个出栈的序数是k。　　第一个出栈的序数k将1~~n的序列分成两个序列，其中一个是1~~k-1，序列个数为k-1，另外一个是k+1~n，序列个数是n-k。　　此时，我们若把k视为确定一个序数，那么根据乘法原理，f（n）的问题就等价于——序列个数为k-1的出栈序列种数乘以序列个数为n - k的出栈序列种数，即选择k这个序数的f（n）=f（k-1）×f（n-k）。而k可以选1到n，所以再根据加法原理，将k取不同值的序列种数相加，得到的总序列种数为：f（n）=f（0）f（n-1）+f（1）f（n-2）+……+f（n-1）f（0）。　　看到此处，再看看卡特兰数的递推式，答案不言而喻，即为f（n）=h（n+1）= C（2n,n）/（n+1）= c（2n,n）-c（2n,n+1）（n=1，2，3，……）。　　最后，令f（0）=1，f（1）=1。　　非常规分析　　对于每一个数来说，必须进栈一次、出栈一次。我们把进栈设为状态‘1’，出栈设为状态‘0’。n个数的所有状态对应n个1和n个0组成的2n位二进制数。由于等待入栈的操作数按照1‥n的顺序排列、入栈的操作数b大于等于出栈的操作数a(a≤b)，因此输出序列的总数目=由左而右扫描由n个1和n个0组成的2n位二进制数，1的累计数不小于0的累计数的方案种数。　　在2n位二进制数中填入n个1的方案数为c(2n,n),不填1的其余n位自动填0。从中减去不符合要求（由左而右扫描，0的累计数大于1的累计数）的方案数即为所求。　　不符合要求的数的特征是由左而右扫描时，必然在某一奇数位2m+1位上首先出现m+1个0的累计数和m个1的累计数，此后的2(n-m)-1位上有n-m个 1和n-m-1个0。如若把后面这2(n-m)-1位上的0和1互换，使之成为n-m个0和n-m-1个1，结果得1个由n+1个0和n-1个1组成的2n位数，即一个不合要求的数对应于一个由n+1个0和n-1个1组成的排列。　　反过来，任何一个由n+1个0和n-1个1组成的2n位二进制数，由于0的个数多2个，2n为偶数，故必在某一个奇数位上出现0的累计数超过1的累计数。同样在后面部分0和1互换，使之成为由n个0和n个1组成的2n位数，即n+1个0和n-1个1组成的2n位数必对应一个不符合要求的数。　　因而不合要求的2n位数与n+1个0，n－1个1组成的排列一一对应。　　显然，不符合要求的方案数为c(2n,n+1)。由此得出输出序列的总数目=c(2n,n)-c(2n,n+1)=c(2n,n)/(n+1)=h(n+1)。

============================================

2012-10-14 23:25:11 update 这个题目在编程之美上也有讨论，在 274 页

生成可重集的排列

Fri, 14 Sep 2012 16:41:26 +0800

刘汝佳在算法竞赛入门经典，http://book.douban.com/subject/4138920/，的 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列很相像，但是写法却巧妙很多

#include <stdio.h>

void quick_sort(int a[], int left, int right)
{
	int i=left, j=right;
	int povit = a[(i+j)/2];
	while (i <= j)
	{
		while (a[i] < povit)
		{
			i++;
		}
		while (a[j] > povit)
		{
			j--;
		}
		if (i <= j)
		{
			int tmp = a[j];
			a[j] = a[i];
			a[i] = tmp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(a, left, j);
	}
	if (i < right)
	{
		quick_sort(a, i, right);
	}
}

void print_permutation(int n, int *p, int *a, int cur)
{
	int i, j;
	if (cur == n)
	{
		for (i=0; i<n; i++)
		{
			printf("%d ", a[i]);
		}
		printf("n");
	}
	else
	{
		for (i=0; i<n; i++)
		{
			if (!i || p[i]!=p[i-1])
			{
				int c1=0, c2=0;
				for (j=0; j<cur; j++)
				{
					if (a[j] == p[i])
					{
						c1++;
					}
				}
				for (j=0; j<n; j++)
				{
					if (p[i] == p[j])
					{
						c2++;
					}
				}
				if (c1 < c2)
				{
					a[cur] = p[i];
					print_permutation(n, p, a, cur+1);
				}
			}
		}
	}
}

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		int *p = new int[n];
		for (int i=0; i<n; i++)
		{
			scanf("%d", &p[i]);
		}
		quick_sort(p, 0, n-1);
		int *a = new int[n];
		print_permutation(n, p, a, 0);
		delete[] p;
		delete[] a;
	}
	return 0;
}

输入输出

需要说明的是，他的这种全排列生成需要数组有序，于是顺便就当作复习了一遍快排了

简单枚举的除法

Fri, 14 Sep 2012 15:16:13 +0800

今天看到一个简单枚举的题目

除法输入正整数n，按从小到大的顺序输出所有形如abcde/fghij=n的表达式，其中a~~j恰好为数字0~~9的一个排列，2<=n<=79. 样例输入： 62 样例输出： 79546/01238=62 94736/01528=62

我是这么搞的

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int n;

void enumerate(char dividend[], int div_index)
{
	if (div_index == 5)
	{
		int divide = atoi(dividend);
		int product = divide * n;
		if (product > 10000 && product <99999)
		{
			char product_str[6];
			sprintf(product_str, "%d", product);
			int map[10] = {0};
			int conflict = 0;
			for (int i=0; i<5; i++)
			{
				if (map[product_str[i]-'0'] == 0)
				{
					map[product_str[i]-'0']++;
				}
				else
				{
					conflict = 1;
					break;
				}
			}
			for (int i=0; i<5; i++)
			{
				if (map[dividend[i]-'0'] == 0)
				{
					map[dividend[i]-'0']++;
				}
				else
				{
					conflict = 1;
					break;
				}
			}
			if ( ! conflict)
			{
				printf("%s / %s = %dn", product_str, dividend, n);
			}
		}
		return;
	}
	for (char ch='0'; ch<='9'; ch++)
	{
		int occupy = 0;
		for (int i=0; i<div_index; i++)
		{
			if (dividend[i] == ch)
			{
				occupy = 1;
				break;
			}
		}
		if ( ! occupy)
		{
			dividend[div_index] = ch;
			enumerate(dividend, div_index+1);
		}
	}
}

int main()
{
	while (scanf("%d", &n) == 1)
	{
		char dividend[6] = {0};
		enumerate(dividend, 0);
	}
	return 0;
}

输入输出

62
79546 / 01283 = 62
94736 / 01528 = 62
7
16758 / 02394 = 7
18459 / 02637 = 7
31689 / 04527 = 7
36918 / 05274 = 7
37926 / 05418 = 7
41832 / 05976 = 7
53298 / 07614 = 7
98532 / 14076 = 7

不过这明显太长了，继续写短。。

参考这里，http://blog.csdn.net/xujinsmile/article/details/7592875，得到如下代码

#include <stdio.h>

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		for (int i=1234; i<=98765; i++)
		{
			if (n*i <= 98765)
			{
				int map[10] = {0};
				int ii=i, ni=n*i;
				for (int j=0; j<5; j++, ii/=10, ni/=10)
				{
					map[ii%10]++;
					map[ni%10]++;
				}
				for (int j=0; j<10; j++)
				{
					if (map[j] != 1)
					{
						break;
					}
					if (j == 9)
					{
						if (i < 10000)
						{
							printf("%d / 0%d = %dn", n*i, i, n);
						}
						else
						{
							printf("%d / %d = %dn", n*i, i, n);
						}
					}
				}
			}
		}
	}
	return 0;
}

输入输出

62
79546 / 01283 = 62
94736 / 01528 = 62
7
16758 / 02394 = 7
18459 / 02637 = 7
31689 / 04527 = 7
36918 / 05274 = 7
37926 / 05418 = 7
41832 / 05976 = 7
53298 / 07614 = 7
98532 / 14076 = 7

栈结构练习

Fri, 14 Sep 2012 11:12:03 +0800

今天从刘汝佳的书上看到一个简单的栈的题目

有n节车厢从A方向驶入车站，按进站顺序编号1～n。现让这些火车按照某种特定的顺序进入B方向的铁轨并驶出车站。为了重组车厢，可以借助中转站C。C是一个可以停放任意多节车厢的车站，但由于末端封顶，驶入C的车厢必须按照相反的顺序驶出C。对于每个车厢，一旦从A移入C，就不能再回到A了；一旦从C移入B，就不能回到C了请编程判断判断：按给定的出站顺序，火车能否出站

用 c++ 的 stl 写的话是这样

#include <cstdio>
#include <stack>

using namespace std;

int main()
{
	int n;
	while (scanf("%d", &n) == 1)
	{
		int *target = new int[n+1];
		for (int i=1; i<=n; i++)
		{
			scanf("%d", &target[i]);
		}
		stack<int> s;
		int a=1, b=1, ok=1;
		while (b < n)
		{
			if (a == target[b])
			{
				a++;
				b++;
			}
			else if ( !s.empty() && s.top()==target[b])
			{
				s.pop();
				b++;
			}
			else if (a < n)
			{
				s.push(a);
				a++;
			}
			else
			{
				ok = 0;
				break;
			}
		}
		delete[] target;
		target = NULL;
		if (ok)
		{
			printf("Yesn");
		}
		else
		{
			printf("Non");
		}
	}
	return 0;
}

输入输出

5
1 2 3 4 5
Yes
5
5 4 1 2 3
No
6
6 5 4 3 2 1
Yes

输出一个字符串的组合

Thu, 13 Sep 2012 18:36:10 +0800

跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归

#include <stdio.h>
#include <string.h>

void combine(char str[], int str_index, char res_total, char result[], int res_index)
{
	if (res_total == res_index)
	{
		for (int i=0; i<res_total; i++)
		{
			printf("%c ", result[i]);
		}
		printf("n");
	}
	else if (str_index==strlen(str))
	{
		return;
	}
	else
	{
		result[res_index] = str[str_index];
		combine(str, str_index+1, res_total, result, res_index+1);
		combine(str, str_index+1, res_total, result, res_index);
	}
}

int main()
{
	char str[100];
	char result[100];
	scanf("%s", str);
	for (int i = 1; i<=strlen(str); i++)
	{
		combine(str, 0, i, result, 0);
	}
	return 0;
}

输入输出

abcd
a
b
c
d
a b
a c
a d
b c
b d
c d
a b c
a b d
a c d
b c d
a b c d

可以发现没有考虑去重的情况，这个应该比较容易，就是预处理扫一遍，如果是 ascii 字符的话，那么把输入的 str 映射要一个位图上就可以了。

二叉树的遍历

Sat, 08 Sep 2012 17:01:31 +0800

参考 http://blog.csdn.net/acdnjjjdjkdckjj/article/details/6237970 写了二叉树的遍历，（基本上就是照抄的，囧），抄的时候感慨，stl 真是个好东西啊，另外，在三种次序遍历的实现上，递归的精巧发挥的淋漓尽致啊，还有就是非递归的遍历，设计真的好巧妙

#include <iostream>
#include <queue>
#include <stack>

using namespace std;

class Tree
{
public:
	char data;
	Tree *left;
	Tree *right;
	void create(Tree *&node);
	void preOrderVisit(Tree *node);
	void inOrderVisit(Tree *node);
	void lastOrderVisit(Tree *node);
	void levelOrderVisit(Tree *node);
	void notRecursionPreOrderVisit(Tree *node);
	void notRecursionInorderVisit(Tree *node);
	void notRecursionLastOrderVisit(Tree *node);
};

void Tree::create(Tree *&node)
{
	char ch;
	cin>>ch;
	if (ch == '0')
	{
		node = NULL;
	}
	else
	{
		node = new Tree();
		node->data = ch;
		create(node->left);
		create(node->right);
	}
}

void Tree::preOrderVisit(Tree *node)
{
	if (node)
	{
		cout<<node->data<<' ';
		preOrderVisit(node->left);
		preOrderVisit(node->right);
	}
}

void Tree::inOrderVisit(Tree *node)
{
	if (node)
	{
		inOrderVisit(node->left);
		cout<<node->data<<' ';
		inOrderVisit(node->right);
	}
}

void Tree::lastOrderVisit(Tree *node)
{
	if (node)
	{
		lastOrderVisit(node->left);
		lastOrderVisit(node->right);
		cout<<node->data<<' ';
	}
}

void Tree::levelOrderVisit(Tree *node)
{
	if ( ! node)
	{
		return;
	}
	queue<Tree *> q;
	q.push(node);
	while ( ! q.empty())
	{
		Tree *tmp = q.front();
		cout<<tmp->data<<' ';
		q.pop();
		if (tmp->left)
		{
			q.push(tmp->left);
		}
		if (tmp->right)
		{
			q.push(tmp->right);
		}
	}
}

void Tree::notRecursionPreOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			cout<<t->data<<' ';
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			t = t->right;
		}
	}
}

void Tree::notRecursionInorderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			cout<<t->data<<' ';
			t = t->right;
		}
	}
}

void Tree::notRecursionLastOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	Tree *pre = NULL;
	while(!s.empty() || t)
	{
		while (t)
		{
			s.push(t);
			t = t->left;
		}
		t = s.top();
		if (t->right==NULL || t->right==pre)
		{
			cout<<t->data<<' ';
			pre = t;
			t = NULL;
			s.pop();
		}
		else
		{
			t = t->right;
		}
	}
}

int main()
{
	Tree *t = NULL;
	t->create(t);
	t->preOrderVisit(t);
	cout<<endl;
	t->inOrderVisit(t);
	cout<<endl;
	t->lastOrderVisit(t);
	cout<<endl;
	t->levelOrderVisit(t);
	cout<<endl;
	t->notRecursionPreOrderVisit(t);
	cout<<endl;
	t->notRecursionInorderVisit(t);
	cout<<endl;
	t->notRecursionLastOrderVisit(t);
	cout<<endl;
	return 0;
}

输入输出

124005003600700
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1
1 2 3 4 5 6 7
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1

链表的反转

Sat, 08 Sep 2012 12:19:13 +0800

今天上午自己写了一个链表的反转

#include <stdio.h>
#include <stdlib.h>

typedef struct _node
{
	int n;
	_node *next;
} node;

int create_link(node **phead)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	*phead = (node *)malloc(sizeof(node));
	if ( ! *phead)
	{
		return 1;
	}
	(*phead)->n = x;
	(*phead)->next = NULL;
	node *now = *phead;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

void print_link(node *head)
{
	node *now = head;
	while (now)
	{
		printf("%d", now->n);
		if (now->next)
		{
			printf(" -> ");
		}
		now = now->next;
	}
	printf("n");
}

void delete_link(node **head)
{
	node *now = *head;
	while (now)
	{
		node *tmp = now->next;
		free(now);
		now = tmp;
	}
	*head = NULL;
}

void reverse_link(node **phead)
{
	node *pre = *phead;
	node *curr = pre->next;
	if ( ! curr)
	{
		// 只有一个节点
		return;
	}
	node *next = curr->next;
	pre->next = NULL;
	while (1)
	{
		curr->next = pre;
		if (next)
		{
			pre = curr;
			curr = next;
			next = next->next;
		}
		else
		{
			break;
		}
	}
	*phead = curr;
}

int main()
{
	node *head = NULL;
	create_link(&head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}

输入输出

input nums, press Ctrl+Z(win) or Ctrl+D(linux) to end
3 1 2 4 0
^Z
3 -> 1 -> 2 -> 4 -> 0
0 -> 4 -> 2 -> 1 -> 3

==================================================

2012-09-08 12:39:03 update 参考这里 http://blog.csdn.net/rerli/article/details/19038，反转函数有更简单的写法

void reverse_link(node **phead)
{
	node *pre = NULL;
	node *curr = *phead;
	node *next = NULL;
	while (curr)
	{
		next = curr->next;
		curr->next = pre;
		pre = curr;
		curr = next;
	}
	*phead = pre;
}

================================================

参考这里，http://blog.csdn.net/rerli/article/details/19039，写了链表的插入排序

void insert_sort(node **phead)
{
	node *head = *phead;
	// 把 head 的下一节点保存起来
	node *first = head->next;
	// 断开 head，使其成为初始的有序链表
	head->next = NULL;
	while (first)
	{
		node *p, *q, *t;
		// 找到插入点
		for (t=first, q=head; q && q->n < t->n; p=q, q=q->next);
		// 把 first 节点从无序链表中断开
		first = first->next;

		if (q == head)
		{
			// 插入在头结点之前
			head = t;
		}
		else
		{
			// p 是 q 的前驱
			p->next = t;
		}
		t->next = q;
	}
	*phead = head;
}

======================================================

2012-09-08 15:02:07 update 相比于传二维指针，可以使用 c++ 的写法，传引用，这样可读性会高很多

int create_link(node *&head)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	head = (node *)malloc(sizeof(node));
	if ( ! head)
	{
		return 1;
	}
	head->n = x;
	head->next = NULL;
	node *now = head;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

调用的时候改成

int main()
{
	node *head = NULL;
	create_link(head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	insert_sort(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}

算法复习之归并排序

Fri, 07 Sep 2012 18:03:29 +0800

今天接到电话面试的时候提到了一个归并排序，之前用的比较少，于是完了之后参照 http://blog.csdn.net/morewindows/article/details/6678165 写了一个归并排序

#include <stdio.h>
#include <stdlib.h>

void merge(int n[], int first, int mid, int last, int temp[])
{
	int i=first, j=mid+1, k=0;
	while (i<=mid && j<=last)
	{
		if (n[i] < n[j])
		{
			temp[k++] = n[i++];
		}
		else
		{
			temp[k++] = n[j++];
		}
	}
	while (i <= mid)
	{
		temp[k++] = n[i++];
	}
	while (j <= last)
	{
		temp[k++] = n[j++];
	}
	for (i=0; i<k; i++)
	{
		n[first+i] = temp[i];
	}
}

void m_sort(int n[], int first, int last, int temp[])
{
	if (first < last)
	{
		int mid = (first + last) / 2;
		m_sort(n, first, mid, temp);
		m_sort(n, mid+1, last, temp);
		merge(n, first, mid, last, temp);
	}
}

int main()
{
	int k;
	scanf("%d", &k);
	int *n = (int *)malloc(k*sizeof(int));
	int *temp = (int *)malloc(k*sizeof(int));
	if (!n || !temp)
	{
		exit(1);
	}
	int i;
	for (i=0; i<k; i++)
	{
		scanf("%d", &n[i]);
	}
	m_sort(n, 0, k-1, temp);
	for (i=0; i<k; i++)
	{
		printf("%d ", n[i]);
	}
	printf("n");
	free(n);
	free(temp);
}

输入输出：

5
3 1 2 4 0
0 1 2 3 4

归并排序的时间复杂度是 O(n*log(n))，数据是稳定的

输出一个字符串的全排列

Thu, 06 Sep 2012 20:44:02 +0800

今天看到 http://blog.csdn.net/morewindows/article/details/7370155 这里提出了一个问题

用C++写一个函数, 如 Foo(const char *str), 打印出 str 的全排列, 如 abc 的全排列: abc, acb, bca, dac, cab, cba

想了想（想了好久啊，好久没有碰数据结构和算法了），觉得可以 dfs，这样来搞：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1000

char str[MAX];
int len;
char tmp[MAX];
char used[MAX];

void arrange(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i = 0;
	for (i=0; i<len; i++)
	{
		if ( ! used[i])
		{
			used[i] = 1;
			tmp[pos] = str[i];
			arrange(pos+1);
			used[i] = 0;
		}
	}
}

int main()
{
	scanf("%s", str);
	len = strlen(str);
	memset(used, 0, sizeof(used));
	memset(tmp, 0, sizeof(tmp));
	arrange(0);
	return 0;
}

结果如下：

但是问题是如果过滤掉重复的呢，最简单的一个想法是，用 stl 搞个 set，找到的结果先不打印出来，统统往 set 里面装，让 set 天然的帮我们过滤，最后用一个循环输出出来，但是，如果自己实现呢，回头看我们之前的代码，我们可以发现，在 dfs 的时候，字符在串中位置是有影响的，也就是说，对于上面的程序来说，abca 和 abac 是不一样的，但是，我们却希望，字符在串中的位置是无关紧要的，自然就想到，如果我们把相同的字符归成一群，这样就能解决问题，也就是说，我们需要把刚刚那两个串预处理一下，把他们都变成，一坨 a，然后一个 b，然后一个 c，于是得到下面的代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1000

typedef struct _letter {
	char ch;
	int count;
} letter;

letter letters[MAX];
int letters_arr_size = 0;

char input[MAX];
int len;
char tmp[MAX];

void preprocess();
void dfs(int pos);

int main()
{
	scanf("%s", input);
	len = strlen(input);
	preprocess();
	dfs(0);
	return 0;
}

void preprocess()
{
	memset(letters, 0, sizeof(letters));
	int i, j, found=0;
	for (i=0; i<len; i++)
	{
		found = 0;
		for (j=0; j<letters_arr_size; j++)
		{
			if (input[i] == letters[j].ch)
			{
				letters[j].count++;
				found = 1;
				break;
			}
		}
		if ( ! found)
		{
			letters[letters_arr_size].ch = input[i];
			letters[letters_arr_size].count = 1;
			letters_arr_size++;
		}
	}
}

void dfs(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i;
	for (i=0; i<letters_arr_size; i++)
	{
		if (letters[i].count > 0)
		{
			letters[i].count--;
			tmp[pos] = letters[i].ch;
			dfs(pos+1);
			letters[i].count++;
		}
	}
}

结果如下

但是至于怎么把这段递归等价的改写成循环，想了很是有一会儿，可惜暂时没有想出来

历史评论

输出一个字符串的组合 | ZRJ (2012-09-13 18:36:14):

[…] 跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归 […]

生成可重集的排列 | ZRJ (2012-09-14 16:41:32):

[…] 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列 […]

算法复习之快速排序

Fri, 10 Aug 2012 17:27:37 +0800

快速排序这个自己想了一会，真的想不出来，还是查了资料，使用 C89 标准函数库有一个非常简单的写法，（维基上的不能跑，自己稍稍改了一下）

#include <stdio.h>
#include <stdlib.h>

static int cmp(int *a, int *b)
{
	return *a-*b;
}

int main()
{
	int arr[10]={5, 3, 7, 4, 1, 9, 8, 6, 2};

	qsort(arr, 10, sizeof(int), (int(*) (const void *,const void *))cmp);

	return 0;
}

而我交到 hdu 的是

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
//	printf("pivot is %dn", pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
		//	printf("swapping arr[%d]:%d and arr[%d]:%dn",
		//		i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		quick_sort(arr, 0, n-1);
		print(arr, n);
	}
	return 0;
}

最后，附上一个 python 的版本，再次体会到 python 的简洁

def qsort(L):
   if not L: return []
   return qsort([x for x in L[1:] if x< L[0]]) + L[0:1] + 
          qsort([x for x in L[1:] if x>=L[0]])

不仅简洁，而且思路非常清晰，易懂，不过 python 这个版本空间复杂度比较高就是了

==============================================================

2012-08-11 00:37:12 update: 上面那个快排，有两个地方想不懂：

在 31 行 while 循环那里，为什么需要小于等于呢，为什么不能去掉等号呢
在 52 和 56 行那里，为什么需要判断 if 呢，那个地方是一个递归终止条件这我知道，问题是，那个 if 在什么情况下会不成立呢，i 从左往右递增，怎么会超过 right 呢，同理 j 也一样啊

==============================================================

2012-08-11 01:01:26 update: 第二个问题看下面这个代码的输出应该就能有体会了，具体我也不知道怎么说

#include <stdio.h>
#define MAX 1005

int total;
int *p_arr;

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	n = total;
	arr = p_arr;
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
	printf("left is %d right is %d pivot is %dn", left, right, pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
			printf("swapping arr[%d]:%d and arr[%d]:%dn",
				i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
			print(arr, 0);
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	else
	{
		printf("left is %d and not smaller than j is %dn", left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
	else
	{
		printf("i is %d and not smaller than right is %dn", i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		p_arr = arr;
		int n = get(arr);
		total = n;
		quick_sort(arr, 0, n-1);
		print(arr, n);
		printf("donen");
	}
	return 0;
}

至于第一个问题嘛，我把等于号删掉了，交到 hdu 上是可以过的，看起来应该是没问题的，但是怎么证明呢

算法复习之冒泡排序与选择排序

Fri, 10 Aug 2012 13:23:29 +0800

基础丢的差不多了，是时候该重新捡起来，不然真的心虚啊，于是就从排序开始，上 poj 找基础的排序题居然没有，悲催，太低级了，最后在 hdu 上找到一个排序题，http://acm.hdu.edu.cn/showproblem.php?pid=1040

忘得差不多也有一个好处，就是可以自己从头再想，这次决定不看任何参考资料，就凭着模糊的印象，慢慢的把算法的思路先理清楚，然后动手写，再手工调，一点点来，这样才能更好的理解，悲催的是，一个冒泡排就搞了一个上午啊

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void sort(int arr[], int n)
{
	int i, j;
	for (i=0; i<n-1; i++)
	{
	//	printf("processing arr[%d]:%dn", i, arr[i]);
		for (j=0; j<n-i-1; j++)
		{
		//	printf("checking for arr[%d]:%d and arr[%d]:%dn",
		//		j, arr[j], j+1, arr[j+1]);
			if (arr[j] > arr[j+1])
			{
			//	printf("swapping arr[%d]:%d and arr[%d]:%dn",
			//		j, arr[j], j+1, arr[j+1]);
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			//	print(arr, n);
			}
		}
	}
//	printf("donen");
	return;
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		sort(arr, n);
		print(arr, n);
	}
	return 0;
}

遇到的问题在于，看高亮的第 32 行，如果把 for 循环的初始条件从 j=0 改成 j=i 就 WA 了，这是为什么呢，有兴趣的可以自己想想

冒泡排序出来了，选择也跟着很快就出来了

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void sort(int arr[], int n)
{
	int i, j;
	for (i=0; i<n-1; i++)
	{
		int min = i;
		for (j=i+1; j<n; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			int temp = arr[i];
			arr[i] = arr[min];
			arr[min] = temp;
		}
	}
	return;
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		sort(arr, n);
		print(arr, n);
	}
	return 0;
}

选择排序是我觉得最自然，最好理解的排序方法，我记得当时大一的时候，刚接触 C ，什么都没学，自己琢磨出来的就是选择，倒是冒泡还费劲理解。。