防止表单重复提交的几种策略

防止表单重复提交的几种策略

表单重复提交是在多用户Web应用中最常见、带来很多麻烦的一个问题。有很多的应用场景都会遇到重复提交问题，比如：

• 点击提交按钮两次。
• 点击刷新按钮。
• 使用浏览器后退按钮重复之前的操作，导致重复提交表单。
• 使用浏览器历史记录重复提交表单。
• 浏览器重复的HTTP请求。

• 几种防止表单重复提交的方法

  　　禁掉提交按钮。表单提交后使用Javascript使提交按钮disable。这种方法防止心急的用户多次点击按钮。但有个问题，如果客户端把Javascript给禁止掉，这种方法就无效了。

  　　我之前的文章曾说过用一些Jquery插件效果不错。

  　　Post/Redirect/Get模式。在提交后执行页面重定向，这就是所谓的Post-Redirect-Get (PRG)模式。简言之，当用户提交了表单后，你去执行一个客户端的重定向，转到提交成功信息页面。

  　　这能避免用户按F5导致的重复提交，而其也不会出现浏览器表单重复提交的警告，也能消除按浏览器前进和后退按导致的同样问题。

  　　在session中存放一个特殊标志。当表单页面被请求时，生成一个特殊的字符标志串，存在session中，同时放在表单的隐藏域里。接受处理表单数据时，检查标识字串是否存在，并立即从session中删除它，然后正常处理数据。

  　　如果发现表单提交里没有有效的标志串，这说明表单已经被提交过了，忽略这次提交。

  　　这使你的web应用有了更高级的XSRF保护。

  　　在数据库里添加约束。在数据库里添加唯一约束或创建唯一索引，防止出现重复数据。这是最有效的防止重复提交数据的方法。

  　　你是如何克服数据重复提交问题的？你遇到过什么重复提交数据的现实例子吗？

  　　英文原文：Prevent Duplicate Form Submission

  二叉树遍历

   

  行文结构

  1. 递归方法
  2. 非递归方法
  3. 微软面试题

  二叉树遍历根据“根节点”遍历时相对的次序分为前序、中序、后序。图示为相对于根节点的次序，左右子树也是一样的规则。

  

                       前序遍历                                             中序遍历                                                后续遍历

  1. 递归方法

  前序遍历

  void PreorderTraversal(BiTree T)
  {
      if(T)
      {
          cout << T->data << endl;
          PreorderTraversal(T->left);
          PreorderTraversal(T->right);
      }
  }

  中序遍历

  void InorderTraversal(BiTree T)
  {
      if(T)
      {
          InorderTraversal(T->left);
          cout << T->data << endl;
          InorderTraversal(T->right);
      }
  }

  后续遍历

  void PostorderTraversal(BiTree T)
  {
      if(T)
      {
          PostorderTraversal(T->left);
          PostorderTraversal(T->right);
          cout << T->data << endl;
      }
  }

  整合参考程序

   

  #include<iostream>
  #include<vector>
  using namespace std;

  typedef struct BiTNode
  {
  int data;
  BiTNode *left;
  BiTNode *right;
  }BiTNode, *BiTree;

  bool SearchBST(BiTree T, int val, BiTree f, BiTree &p)
  {
  if(!T)
  {
  p = f;
  return false;
  }
  else if(val == T->data)
  {
  p = T;
  return true;
  }
  else if(val < T->data)
  SearchBST(T->left, val, T, p);
  else
  SearchBST(T->right, val, T, p);
  }

  bool InsertBST(BiTree &T, int val)
  {
  BiTree p;
  if(!SearchBST(T, val, NULL, p))
  {
  BiTree node = new BiTNode;
  node->data = val;
  node->left = node->right = NULL;
  if(!p)
  T = node;
  else if(val < p->data)
  p->left = node;
  else
  p->right = node;
  return true;
  }
  return false;
  }

  void PreorderTraversal(BiTree T)
  {
  if(T)
  {
  cout << T->data << endl;
  PreorderTraversal(T->left);
  PreorderTraversal(T->right);
  }
  }

  void InorderTraversal(BiTree T)
  {
  if(T)
  {
  InorderTraversal(T->left);
  cout << T->data << endl;
  InorderTraversal(T->right);
  }
  }

  void PostorderTraversal(BiTree T)
  {
  if(T)
  {
  PostorderTraversal(T->left);
  PostorderTraversal(T->right);
  cout << T->data << endl;
  }
  }

  int main()
  {
  int array[] = {5, 1, 0, 45, 10, 3, 8, 5};
  int len_array = sizeof(array) / sizeof(*array);
  BiTree root = NULL;
  for(int i = 0; i< len_array; ++i)
  InsertBST(root, array[i]);
  cout << "PreorderTraversal" << endl;
  PreorderTraversal(root);
  cout << "----------------------" << endl;

  cout << "InorderTraversal" << endl;
  InorderTraversal(root);
  cout << "----------------------" << endl;

  cout << "PostorderTraversal" << endl;
  PostorderTraversal(root);
  cout << "----------------------" << endl;
  }

  结果

  

  2. 非递归方法

  非递归方法借助于栈，“记忆”走过的结点。

  前序遍历

  “根-左孩子-右孩子”，对每一个结点看成是根节点，先输出，后入栈（到时返回访问右孩子），然后访问左孩子。当不能在往左走时，查询栈中的记忆，根据栈顶进入右孩子，重复上边的故事。

  void PreorderTraversal(BiTree T)
  {
      stack<BiTree> s;
      while(T || !s.empty())
      {
          while(T)
          {
              cout << T->data << endl;
              s.push(T);
              T = T->left;
          }
          T = s.top();
          T = T->right;
          s.pop();
      }
  }

  中序遍历

  “左孩子-根-右孩子”，对每一个结点看成是根节点，先入栈（到时返回访问自己和右孩子），然后访问左孩子。当不能在往左走时，查询栈中的记忆，根据栈顶访问自己并且进入右孩子，重复上边的故事。

  void InorderTraversal(BiTree T)
  {
      stack<BiTree> s;
      while(T || !s.empty())
      {
          while(T)
          {
              s.push(T);
              T = T->left;
          }
          T = s.top();
          cout << T->data << endl;
          T = T->right;
          s.pop();
      }
  }

  后续遍历

  “左孩子-右孩子-根”，为了达到这个效果，需要把把按“根-->右孩子-->左孩子”的顺序入栈，因为栈的特征是先进后出，所以访问时顺序相反。对于一个结点只有满足以下两个条件时，才访问，否则按“根-->右孩子-->左孩子”顺序入栈。

  • 左右孩子全为NULL
  • 前边访问的结点正好为当前结点的左孩子或右孩子(访问了左孩子必定已经访问了右孩子)

  void PostorderTraversal(BiTree T)
  {
      stack<BiTree> s;
      BiTree cur = NULL, pre = NULL;
      s.push(T);
      while(!s.empty())
      {
          cur = s.top();
          if((!cur->left && !cur->right) ||
                  (pre != NULL && (pre == cur->left || pre == cur->right)))
          {
              cout << cur->data << endl;
              pre = cur;
              s.pop();
          }
          else
          {
              if(cur->right)
                  s.push(cur->right);
              if(cur->left)    
                  s.push(cur->left);
          }
      }
  }

  整合参考程序

   

  #include<iostream>
  #include<stack>

  using namespace std;

  typedef struct BiTNode
  {
  int data;
  BiTNode *left;
  BiTNode *right;
  }BiTNode, *BiTree;

  bool SearchBST(BiTree T, int val, BiTree f, BiTree &p)
  {
  if(!T)
  {
  p = f;
  return false;
  }
  else if(val == T->data)
  {
  p = T;
  return true;
  }
  else if(val < T->data)
  SearchBST(T->left, val, T, p);
  else
  SearchBST(T->right, val, T, p);
  }

  bool InsertBST(BiTree &T, int val)
  {
  BiTree p;
  if(!SearchBST(T, val, NULL, p))
  {
  BiTree node = new BiTNode;
  node->data = val;
  node->left = node->right = NULL;
  if(!p)
  T = node;
  else if(val < p->data)
  p->left = node;
  else
  p->right = node;
  return true;
  }
  return false;
  }

  void PreorderTraversal(BiTree T)
  {
  stack<BiTree> s;
  while(T || !s.empty())
  {
  while(T)
  {
  cout << T->data << endl;
  s.push(T);
  T = T->left;
  }
  T = s.top();
  T = T->right;
  s.pop();
  }
  }

  void InorderTraversal(BiTree T)
  {
  stack<BiTree> s;
  while(T || !s.empty())
  {
  while(T)
  {
  s.push(T);
  T = T->left;
  }
  T = s.top();
  cout << T->data << endl;
  T = T->right;
  s.pop();
  }
  }

  void PostorderTraversal(BiTree T)
  {
  stack<BiTree> s;
  BiTree cur = NULL, pre = NULL;
  s.push(T);
  while(!s.empty())
  {
  cur = s.top();
  if((!cur->left && !cur->right) ||
  (pre != NULL && (pre == cur->left || pre == cur->right)))
  {
  cout << cur->data << endl;
  pre = cur;
  s.pop();
  }
  else
  {
  if(cur->right)
  s.push(cur->right);
  if(cur->left)
  s.push(cur->left);
  }
  }
  }

  int main()
  {
  int array[] = {5, 1, 0, 45, 10, 3, 8, 5};
  int len_array = sizeof(array) / sizeof(*array);
  BiTree root = NULL;
  for(int i = 0; i< len_array; ++i)
  InsertBST(root, array[i]);
  cout << "PreorderTraversal" << endl;
  PreorderTraversal(root);
  cout << "----------------------" << endl;

  cout << "InorderTraversal" << endl;
  InorderTraversal(root);
  cout << "----------------------" << endl;

  cout << "PostorderTraversal" << endl;
  PostorderTraversal(root);
  cout << "----------------------" << endl;
  }

  结果同递归遍历

  3. 微软面试题

  

  分析：由二叉遍历树变成有序的结构，不用说绝对是中序遍历。中序遍历分为两种方法——递归、非递归。递归不需要额外的空间，非递归需要额外空间（借助与栈）。现在用两种方法实现，其思路都是基本中序遍历的改进。

  方法一（递归方法）

  void BST2BLink(BiTree T, BiTree &pre)  //&地址操作，所有递归使用同一个
  {
      if(T)
      {
          BST2BLink(T->left, pre);
          if(pre)
          {
              pre->right = T;
              T ->left = pre;
          }
          pre = T;
          BST2BLink(T->right, pre);
      }
  }

  执行程序

   

  #include<iostream>
  #include<stack>

  using namespace std;

  typedef struct BiTNode
  {
  int data;
  BiTNode *left;
  BiTNode *right;
  }BiTNode, *BiTree;

  bool SearchBST(BiTree T, int val, BiTree f, BiTree &p)
  {
  if(!T)
  {
  p = f;
  return false;
  }
  else if(val == T->data)
  {
  p = T;
  return true;
  }
  else if(val < T->data)
  SearchBST(T->left, val, T, p);
  else
  SearchBST(T->right, val, T, p);
  }

  bool InsertBST(BiTree &T, int val)
  {
  BiTree p;
  if(!SearchBST(T, val, NULL, p))
  {
  BiTree node = new BiTNode;
  node->data = val;
  node->left = node->right = NULL;
  if(!p)
  T = node;
  else if(val < p->data)
  p->left = node;
  else
  p->right = node;
  return true;
  }
  return false;
  }

  void BST2BLink(BiTree T, BiTree &pre)
  {
  if(T)
  {
  BST2BLink(T->left, pre);
  if(pre)
  {
  pre->right = T;
  T ->left = pre;
  }
  pre = T;
  BST2BLink(T->right, pre);
  }
  }

  int BST2BLink(BiTree &T)
  {
  stack<BiTree> s;
  BiTree cur = T, pre = NULL;
  while(cur || !s.empty())
  {
  while(cur)
  {
  s.push(cur);
  cur = cur->left;
  }

  cur = s.top();
  s.pop();
  cout << cur->data << endl;

  if(!pre)
  T = cur;
  else
  {
  pre->right = cur;
  cur ->left = pre;
  }
  pre = cur;
  cur = cur->right;
  }
  }

  void BLinkTraversal(BiTree root)
  {
  while(root)
  {
  cout << root->data << endl;
  root = root->right;
  }
  }

  int main()
  {
  int array[] = {5, 8, 0, 3, 100, 45};
  int len_array = sizeof(array) / sizeof(*array);
  BiTree root = NULL;
  for(int i = 0; i< len_array; ++i)
  InsertBST(root, array[i]);

  cout << "Recursion" << endl;
  BiTree pre = NULL;
  BST2BLink(root, pre);
  while(root->left)
  root = root->left;
  BLinkTraversal(root);
  /*
  cout << " Not Recursion" << endl;
  BST2BLink(root_copy);
  cout << "----------------------" << endl;
  BLinkTraversal(root);
  */
  }

  方法二（非递归方法）

  int BST2BLink(BiTree &T)
  {
      stack<BiTree> s;
      BiTree cur = T, pre = NULL;
      while(cur || !s.empty())
      {
          while(cur)
          {
              s.push(cur);
              cur = cur->left;
          }
  
          cur = s.top();
          s.pop();
          cout << cur->data << endl;
          if(!pre)
              T = cur;
          else
          {
              pre->right = cur;
              cur ->left = pre;
          }
          pre = cur;
          cur = cur->right;
      }
  }

  执行程序

   

  #include<iostream>
  #include<stack>

  using namespace std;

  typedef struct BiTNode
  {
  int data;
  BiTNode *left;
  BiTNode *right;
  }BiTNode, *BiTree;

  bool SearchBST(BiTree T, int val, BiTree f, BiTree &p)
  {
  if(!T)
  {
  p = f;
  return false;
  }
  else if(val == T->data)
  {
  p = T;
  return true;
  }
  else if(val < T->data)
  SearchBST(T->left, val, T, p);
  else
  SearchBST(T->right, val, T, p);
  }

  bool InsertBST(BiTree &T, int val)
  {
  BiTree p;
  if(!SearchBST(T, val, NULL, p))
  {
  BiTree node = new BiTNode;
  node->data = val;
  node->left = node->right = NULL;
  if(!p)
  T = node;
  else if(val < p->data)
  p->left = node;
  else
  p->right = node;
  return true;
  }
  return false;
  }

  void BST2BLink(BiTree T, BiTree &pre)
  {
  if(T)
  {
  BST2BLink(T->left, pre);
  if(pre)
  {
  pre->right = T;
  T ->left = pre;
  }
  pre = T;
  BST2BLink(T->right, pre);
  }
  }

  int BST2BLink(BiTree &T)
  {
  stack<BiTree> s;
  BiTree cur = T, pre = NULL;
  while(cur || !s.empty())
  {
  while(cur)
  {
  s.push(cur);
  cur = cur->left;
  }

  cur = s.top();
  s.pop();
  // cout << cur->data << endl;

  if(!pre)
  T = cur;
  else
  {
  pre->right = cur;
  cur ->left = pre;
  }
  pre = cur;
  cur = cur->right;
  }
  }

  void BLinkTraversal(BiTree root)
  {
  while(root)
  {
  cout << root->data << endl;
  root = root->right;
  }
  }

  int main()
  {
  int array[] = {5, 8, 0, 3, 100, 45};
  int len_array = sizeof(array) / sizeof(*array);
  BiTree root = NULL;
  for(int i = 0; i< len_array; ++i)
  InsertBST(root, array[i]);
  /*
  cout << "Recursion" << endl;
  BiTree pre = NULL;
  BST2BLink(root, pre);
  while(root->left)
  root = root->left;
  BLinkTraversal(root);
  */
  cout << " Not Recursion" << endl;
  BST2BLink(root);
  cout << "----------------------" << endl;
  BLinkTraversal(root);
  
  }

   

   

  分类: 算法&&数据结构