leetcode中，代码怎样调试，创造本地执行环境

初次接触leetcode，是我在一个招聘站点上看的，这个OJ真有那么厉害吗？

这几天在这个OJ上做了几道题，发现他的几个特点，1、题目不难（相对于ACM来说，我被ACM虐到至今无力），评判没那么苛刻，2、十分基础，从链表、树到动态规划等，都是很基本很经典的内容。相当的靠基本功，3、没有本地调试环境，直接在站点上提交，后台评判系统帮你完毕程序输入、评判输出的功能，4、国内外业内认可。有许多人都刷满了，留下了许多的优秀的演示样例代码。5、支持C++ 11的特性哦，一个autokeyword会让你爽大大的。

所以我认定这个OJ对巩固算法和数据结构的基本功，以及应付面试笔试有非常大作用。决定開始刷题。

初次刷体感到非常不适应，题目网页仅仅须要class Solution，没有输入，也没有输出什么的，调试在哪里？后来我发现，没有条件，那就须要自己创造条件了。

由于网上大部分都是解题提交的思路。不利于新手上路，所以我想写这么一个帖子，希望能对他人有所帮助，所以大牛莫笑呵呵。

好吧。假设有链表题。那么我们自己写main函数，首先去构造链表，然后去排序啦去反向了什么的。假设有树题，那么我们自己写main函数，去构造树，然后调试。

嗯，这里就须要这么几个要素：

1、程序输入的数据，就是用来构造链表、树的内容的数据。一个来源是rand()，使用随机数，还有一个来源就是手动输入了。

在链表题中。因为我们仅仅须要一些内容，来看看排序效果什么的。所以能够通过随机数来产生数据，代码（仅仅写有关的头文件和语句）例如以下：

#include <stdlib.h>
#include <time.h>
int lt = time(NULL);
srand(lt);
int len = rand()%100;
int data = rand() % 100;

如此去产生随机数据

在树题中，比方有题目是推断是否是对称树（symmetric tree），那么我们希望手动输入树的数据为好，将树的节点内容以main函数參数输入给程序，运行时如 ：

./symmetric_tree 123##5

这里的123##5是leetcode中的树的表示，事实上就是依照满二叉树的按层遍历来构造的。123##5构造了例如以下一颗树，当中2的1的左右孩子是2、3，2的左右孩子是##，就是空。2 是一个叶子节点了，3的左孩子是5。右孩子是空，空就不用输入数据了。调试时，我们须要依照这样的方式构造树。

1

2 3

# #
5

2、构造链表，代码例如以下

void addToTail(ListNode **head, int val)
{
	ListNode *node = new ListNode(val);
	if(!*head)
	{
		*head = node;
	}
	else
	{
		ListNode *tmp = *head;
		while(tmp->next)
			tmp = tmp->next;
		tmp->next = node;
	}
}

int main()
{
	int lt = time(NULL);
	srand(lt);
	int len = rand()%20;
	cout << len<<endl;
	if(len < 1)
		return 0;
<span style="white-space:pre">	</span>ListNode *root = NULL;
        for(int i=0; i<len; i++)
                  addToTail(&root, rand()%100)

}

3、构造树

依照 123##5构造二叉树，当中constructTree函数属于按层构造二叉树的方式。

#include <stdio.h>
#include <stdlib.h>
#include <stack>
#include <iostream>
#include <vector>
#include <typeinfo>
#include <exception>
#include <map>
#include <list>
#include <algorithm>
#include <time.h>
using namespace std;

struct TreeNode
{
	int	val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int val):val(val), left(NULL),right(NULL){} ;
};

TreeNode *constructTree(char *dat , int len)
{
	TreeNode *root = NULL;
	int index = 0;
	if(len > 0)
		root = new TreeNode(dat[index] - '0');
	else
		return NULL;

	list<TreeNode *> node;
	node.push_back(root);
	index ++;
	while(index < len)
	{
		if(!node.empty())
		{
			TreeNode *root = node.front();
			if(index < len )
			{
				if(dat[index] != '#')
				{
					root->left = new TreeNode(dat[index] - '0');
					node.push_back(root->left);
				}
				index ++;
			}
			if(index < len )
			{
				if(dat[index] != '#')
				{
					root->right = new TreeNode(dat[index] - '0');
					node.push_back(root->right);
				}
				index ++;
			}
			node.pop_front();
		}
	}

	return root;
}

class Solution {
	public:
		vector<int> inorderTraversal(TreeNode *root) {
			vector<int > tree;
			TreeNode *node = root;
//			traversal(node, tree);
			itera_traversal(node, tree);
			return tree;
		}
		void traversal(TreeNode *node, vector<int> &tree)
		{
			if(!node)
				return;

			traversal(node->left, tree);
			tree.push_back(node->val);
			traversal(node->right, tree);

		}
		void itera_traversal(TreeNode *node, vector<int> &tree)
		{
			stack<TreeNode *> lroot;
			TreeNode *root = node;
			while(root || !lroot.empty())
			{
				while(root)
				{
					lroot.push(root);
					root = root->left;
				}
				if(!lroot.empty())
				{
					root = lroot.top();
					tree.push_back(root->val);
					lroot.pop();
					root = root->right;
				}
			}
		}
};

int main(int argc, char *argv[])
{
	if(argc < 2)
	{
		cout <<"Usage: ./binary_tree_inorder_traversal treelist(1234#5####6)"<<endl;
		exit(1);
	}

	string treeinfo = argv[1];
	if(treeinfo.size() < 1)
	{
		cout <<"tree data invalid"<<endl;
		exit(1);
	}
	int len = treeinfo.size();
	char *dat = new char[len];
	for(int i=0; i<len; i++)
	{
		dat[i] = treeinfo[i];
	}
	for(int i=0; i<len; i++)
		cout << "\t"<<dat[i] ;
	cout << endl;

	TreeNode *root = NULL;
	root = constructTree(dat, len);

	Solution s;
	vector<int > seq = s.inorderTraversal(root);
	for(int i=0; i<seq.size(); i++)
		cout <<"\t"<<seq[i];
	cout << endl;
	cout << endl;

	delete dat;
}

只是这样的123##5的方式有一定缺陷，在某个节点值为15、20，344等的时候，怎么办了。那就仅仅能依照把全部參数都输入给main函数。运行时类似于

./validate_binary_search_tree.o 4 2 6 5 3 1 # 6

#include <stdio.h>
#include <stdlib.h>
#include <stack>
#include <iostream>
#include <vector>
#include <typeinfo>
#include <exception>
#include <map>
#include <list>
#include <algorithm>
#include <time.h>
#include <string.h>
using namespace std;

struct TreeNode
{
	int	val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int val):val(val), left(NULL),right(NULL){} ;
};

TreeNode *constructTree(int *dat , int len)
{
	TreeNode *root = NULL;
	int index = 0;
	if(len > 0)
		root = new TreeNode(dat[index]);
	else
		return NULL;

	list<TreeNode *> node;
	node.push_back(root);
	index ++;
	while(index < len)
	{
		if(!node.empty())
		{
			TreeNode *root = node.front();
			if(index < len )
			{
				if(dat[index] != '#')
				{
					root->left = new TreeNode(dat[index]);
					node.push_back(root->left);
				}
				index ++;
			}
			if(index < len )
			{
				if(dat[index] != '#')
				{
					root->right = new TreeNode(dat[index]);
					node.push_back(root->right);
				}
				index ++;
			}
			node.pop_front();
		}
	}

	return root;
}

void traversal(TreeNode *node)
{
	if(!node)
		return;
	cout <<"\t"<< node->val;
	traversal(node->left);
	traversal(node->right);
}

class Solution {
	public:
		bool isValidBST(TreeNode *root)
		{
			int minmum = 0xffffffff;
			return judge(root, minmum);
		}

		bool judge(TreeNode *root, int &min)
		{
			if(!root)
				return true;
			bool flag = judge(root->left, min);
			if(!flag)
				return false;
			if(root->val < min)
				return false;
			min = root->val;
			return judge(root->right, min);
		}
};

int main(int argc, char *argv[])
{
	if(argc < 2)
	{
		cout <<"Usage: ./binary_tree_inorder_traversal tree_list(4 2 6 5 3 1 # 6) "<<endl;
		exit(1);
	}

	int len = argc -1 ;
	cout << len <<endl;

	int *data = (int *)malloc(sizeof(int) * len);
	memset(data, 0, sizeof(char)*len);
	for(int i=1; i<argc; i++)
	{
		if(*argv[i] != '#')
			data[i-1] = atoi(argv[i]) ;
		else
			data[i-1] = '#';
	}
	for(int i=0; i < len ; i++)
		cout <<"\t"<< data[i] ;
	cout << endl;
	cout << endl;

	TreeNode *tree = NULL;
	tree = constructTree(data, len);

	traversal(tree);
	cout << endl;

	Solution s;
	cout << s.isValidBST(tree) <<endl;
}

这种方法将每一个參数都atoi为整数，那么在构造二叉树函数constructTree中，就须要注意。‘#’的ascii码值是34，小心哦。只是用来測试，勉强可用吧。