N queens

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

class Solution {public:  bool isValid(vector<string>& board, int n,int x, int y){int i =0, j =0;for(i=0; i < x; ++ i){if(board[i][y] == 'Q')//只可能是x之前的行，在同一列有相同的元素return false;}for(i = 0; i < n; ++ i)for(j = 0; j < n; ++j){if( (i != x)&& (j != y) && board[i][j] == 'Q' && (((x-i) == (y-j)) || ((x-i) == (j-y))))//对角线，左边或者是右边return false;}        return true;}void dfsBoards(vector<vector<string> >& results,vector<string>& board,  int n, int id){int i = 0;if(id == n){results.push_back(board);return;}for(i = 0; i < n; ++ i){board[id][i] = 'Q';//在每id行插入元素Qif(isValid(board,n,id,i)){dfsBoards(results,board,n,id+1);}board[id][i] = '.';}}vector<vector<string> > solveNQueens(int n) {vector<vector<string> > results;//存放最终多个方案vector<string> board;//其中一个方案string row = "";int i = 0;if(n == 0) return results;if(n == 1) {board.push_back( "Q");results.push_back(board);return results;}for(i = 0; i < n; ++ i)row.push_back('.') ;for(i = 0; i < n; ++ i)board.push_back(row);dfsBoards(results,board,n,0);return results;}};

Convert Sorted Array to Binary Search Tree

/** * Definition for binary tree * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    TreeNode* sortedArrayToBSTR(vector<int>& num, int start,int end){if(start > end)return NULL;int mid = (start+end)/2;TreeNode* r = new TreeNode(num[mid]);r->left = sortedArrayToBSTR(num, start, mid-1);r->right = sortedArrayToBSTR(num, mid+1, end);return r;}TreeNode *sortedArrayToBST(vector<int> &num){TreeNode* root = sortedArrayToBSTR(num,0, num.size()-1);return root;}};

Balanced Binary Tree

 

这个方法要自顶往下，节点是否平衡会先计算子树，然后判断，接着再次判断子树是否平衡，重复计算，不高效

/** * Definition for binary tree * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:int TreeDepth(TreeNode* node){       if(node == NULL)        return 0;        int hleft = TreeDepth(node->left);    int hright = TreeDepth(node->right);        return hleft>hright?(hleft+1):(hright+1);}bool isBalanced (TreeNode* root){    if(root == NULL)        return true;    int left = TreeDepth(root->left);    int right = TreeDepth(root->right);        int dif = left - right;    if(dif>1 || dif<-1)        return false;    return isBalanced(root->left)&&isBalanced(root->right);}};

还有一种，键指offerP207，就是后序遍历，保证左右子树都是平衡的再去判断自身的平衡性，避免了重复计算

/** * Definition for binary tree * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:bool isBalanced(TreeNode* node, int *dep){       if(node == NULL)    {        *dep = 0;        return true;    }    int left=0;    int right = 0;    if(isBalanced(node->left,&left) && isBalanced(node->right,&right))    {        int dif = left -right;        if(dif<=1 && dif>=-1)        {            *dep = 1+(left>right?left:right);//优先级的问题，我写的是（left>right）？left:right,应该是？优先级太低            return true;        }    }    return false;}bool isBalanced (TreeNode* root){    int dep = 0;    return isBalanced(root,&dep);}};

Swap Nodes in Pairs

 

struct ListNode{int val;ListNode *next;ListNode(int x):val(x),next(NULL){}};ListNode* swapPairs(ListNode* head){if(head == NULL || head->next == NULL)return head;ListNode* p = head;ListNode* q = head->next;p->next = q->next;q->next = p;head = q;while(p->next != NULL && p->next->next != NULL){//p记录的是pair的前一个节点，所以是移动两步q = p->next->next;//pair间交换p->next->next = q->next;q->next = p->next;//pair与前一个节点p连接p->next = q;//移动两步，p指向下一个pair的前一个p = p->next->next;}return head;}