C++实现二叉树，运用模板，界面友好，操作方便 运行流畅

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量145 收藏
点赞数
文章标签： 数据结构与算法 c/c++
原文链接：http://www.cnblogs.com/zpcdbky/p/4109716.html
版权 
//.h文件 

#ifndef TREE_H
 #define TREE_H 

#include<iostream>
 #include<iomanip>
 using namespace std;
 template<typename T>
 struct Node            //树结点
{
  T data;
  Node<T> *left, *right;
  Node(const T& item);
 }; 

template<typename T>
 Node<T>::Node(const T& item)   //树结点初始化
{
  data = item;
  left = NULL;
  right = NULL;
 } 

template<typename T>          //队列结点
struct QNode
 {
  Node<T>* pdata;
  QNode<T>* next;
  QNode( Node<T>* &pd,  QNode* tp);
 }; 

template<typename T>           //队列结点初始化
QNode<T>::QNode( Node<T>* &pd,  QNode* tp)   
 {
  pdata = pd;
  next = tp;
 } 

template<typename T>            //放删除元素的队列结点
struct DQNode
 {
  T d_data;
  DQNode<T>* dnext;
  DQNode(const T& ditem, DQNode<T>* dp);
 }; 

template<typename T>                                 //放删除元素的队列结点初始化
DQNode<T>::DQNode(const T& ditem, DQNode<T>* dp)
 {
  d_data = ditem;
  dnext = dp;
 } 

template<typename T>           //二叉树类
class Tree
 {
 private:
  Node<T>* root;
  QNode<T>* head, *tail;
  DQNode<T>*dhead, *dtail;
  int size;//记录二叉树结点长度
 int qsize;//记录队列长度
 int dsize;//记录DQNode队列长度
public:
  Tree();
  ~Tree();
  void Operate();
 private:
  Node<T>* Creat(Node<T>* &rt);
  void Destory(Node<T>* t);
  void Del(Node<T>* t);
  void FiRoTra(Node<T>* rt ,int& ct);
  void MiRoTra(Node<T>* rt, int& ct);
  void LaRoTra(Node<T>* rt, int& ct);
  void LeveTra(Node<T>* rt, int& ct);
  void Addq( Node<T>* &pt);
  Node<T>* Outq();
  void AddDq(const T& tdata);
  void Delq();
  void Deld();
  void ShowAll(QNode<T>* header);
  void D_ShowAll(DQNode<T>* dheader);
  Node<T>* GetFather(Node<T>* t, Node<T>* p);
  void Search(Node<T>* t, const T& item, bool& sign);
 }; 

template<typename T>           //类构造函数
Tree<T>::Tree()
 {
  root = NULL;
  head = NULL;
  tail = NULL;
  dhead = NULL;
  dtail = NULL;
  size = 0;
  qsize = 0;
  dsize = 0;
 } 

template<typename T>          //类析构函数
Tree<T>::~Tree()
 {
  Destory(root);
 } 

template<typename T>          //入队一个元素
void Tree<T>::Addq( Node<T>* &pnode)
 {
  if (!head){ head = tail = new QNode<T>(pnode,NULL); qsize = 1; }
  else
  {
   tail->next = new QNode<T>(pnode, NULL);
   tail = tail->next;
   qsize++;
  }
 } 

template<typename T>          //出队一个元素
Node<T>* Tree<T>::Outq()
 {
  Node<T>* p;
  QNode<T>* item;
  p = head->pdata;
  item = head;
  head = head->next;
  delete item;
  qsize--;
  return p;
 } 

template<typename T>            //DQNode入队一个元素
void Tree<T>:: AddDq(const T& tdata)
 {
  if (!dhead){ dhead = dtail = new DQNode<T>(tdata, NULL); dsize = 1; }
  else
  {
   dtail->dnext = new DQNode<T>(tdata, NULL);
   dtail = dtail->dnext;
   dsize++;
  }
 } 

template<typename T>           //清空队列
void Tree<T>::Delq()
 {
   while (head)
  {
   QNode<T>* temp;
   temp = head; head = head->next; delete temp;
  }
 } 

template<typename T>           //清空DQNode队列
void Tree<T>::Deld()
 {
   while (dhead)
  {
   DQNode<T>* dtemp;
   dtemp = dhead; dhead = dhead->dnext; delete dtemp;
  }
 } 

template<typename T>               //输出队列内全部元素
void Tree<T>::ShowAll(QNode<T>* header)
 {
  QNode<T>* p = header;
  for (int i = 1; i <= qsize;i++)
  {
   cout << p->pdata << "  ";
   if (i % 5 == 0 )cout << endl;
   p = p->next;
  }
  cout << endl;
 } 

template<typename T>               //输出DQNode队列内全部元素
void Tree<T>::D_ShowAll(DQNode<T>* dheader)
 {
  DQNode<T>* dp = dheader;
  for (int i = 1; i <= dsize; i++)
  {
   cout << setiosflags(ios::left);
   cout<<setw(10) << dp->d_data;
   if (i % 5 == 0 )cout << endl;
   dp = dp->dnext;
  }
  cout << endl;
 } 

template<typename T>                         //得到某结点（以地址为关键值）的父结点的地址
Node<T>* Tree<T>::GetFather(Node<T>* t, Node<T>* p)
 {
  Node<T>* q;
  if (t == NULL)return NULL;
  if (t->left == p || t->right == p)return t;
  q = GetFather(t->left, p);
  if (q!= NULL)return q;
  else return GetFather(t->right, p);
 } 

template<typename T>             //在树中删除以某结点为根的树
void Tree<T>::Del(Node<T>* t)
 {
  if (t != NULL)
  {
   Del(t->left);
   Del(t->right);
   AddDq(t->data);
   delete t;
   size--;
  }
 } 

template<typename T>           //创建二叉树
Node<T>* Tree<T>::Creat(Node<T>* &rt)
 {
  int choice; bool flag;
  if (size > 0)
  {
   cout << "是否继续创建子树？是请按1，否请按0：" << endl;
    cin >> choice; 
    flag = true;
  }
  if (size == 0)
  {
   cout << "请输入根结点数据;" << endl;
   T data; cin >> data;
   rt = new Node<T>(data);
   if (!rt){ cout << "根结点创建失败！" << endl; return NULL; }
   size++;
      flag = false;
   cout << "根结点创建成功！" << endl;
   cout << "目前树中共有结点" << size << "个。" << endl;
  }
  if (flag)
  {
   if (choice == 0)return 0;
   else
   {
    cout << "请输入子结点数据;" << endl;
    T data; cin >> data;
    rt = new Node<T>(data);
    if (!rt){ cout << "子结点创建失败！" << endl; return NULL; }
    size++;
    cout << "子结点创建成功！" << endl;
    cout << "目前树中共有结点" << size << "个。" << endl;
   }
  }
  Creat(rt->left);
  Creat(rt->right);
  return root;
 } 

template<typename T>              //先根递归遍历 FiRoTra是first root traversal的缩写
void Tree<T>::FiRoTra(Node<T>* rt ,int& ct)
 {
  if (rt)
  {
   cout << setiosflags(ios::left);
   cout<<setw(10) << rt->data;
   ct++; 
   if (ct % 5 == 0)
    cout << endl;
   FiRoTra(rt->left,ct);
   FiRoTra(rt->right,ct);
  }
 } 

template<typename T>              //中根递归遍历 MiRoTra是middle root traversal的缩写
void Tree<T>::MiRoTra(Node<T>* rt, int& ct)
 {
  if (rt)
  {
   MiRoTra(rt->left, ct);
   cout << setiosflags(ios::left);
   cout <<setw(10)<< rt->data ;
   ct++;
   if (ct % 5 == 0)
    cout << endl;
   MiRoTra(rt->right, ct);
  }
 } 

template<typename T>              //后根递归遍历 LaRoTra是last root traversal的缩写
void Tree<T>::LaRoTra(Node<T>* rt, int& ct)
 {
  if (rt)
  {
   LaRoTra(rt->left, ct);
   LaRoTra(rt->right, ct);
   cout << setiosflags(ios::left);
   cout<<setw(10) << rt->data ;
   ct++;
   if (ct % 5 == 0)
    cout << endl; 
  }
 } 

template<typename T>              //层次遍历 LeveTra是level traversal的缩写
void Tree<T>::LeveTra(Node<T>* rt, int& ct)
 {
  Addq(rt);
  Node<T>* lt;
  while (qsize>0)
  {
   lt=Outq();
   ct++;
   cout << setiosflags(ios::left);
   cout <<setw(10)<< lt->data ;
   if (ct % 5 == 0)
    cout << endl;
   if (lt->left != NULL)Addq(lt->left);
   if (lt->right != NULL)Addq(lt->right);
  }
 } 

template<typename T>            //搜索数据域为某值的结点
void Tree<T>::Search(Node<T>* t, const T& item, bool& sign)
 {
  if (t)
  {
   Search(t->left, item, sign);
   Search(t->right, item, sign);
   if (t->data == item){sign = true; Addq(t);}
  }
 } 

template<typename T>           //销毁二叉树
void Tree<T>::Destory(Node<T>* t)
 {
   if (t!=NULL)
  {
   Destory(t->left);
   Destory(t->right);
   delete t;
   size--;
  }
 } 

//封装操作
template <typename T>
 void Tree<T>::Operate()
 {
  bool flager = true;
  while (flager)
  {
   cout << "请您选择操作（输入操作前的数字进行选择）：" << endl;
   cout << "1.创建二叉树并写入数据" << endl;
   cout << "2.先根遍历二叉树" << endl;
   cout << "3.中根遍历二叉树" << endl;
   cout << "4.后根遍历二叉树" << endl;
   cout << "5.层次遍历二叉树" << endl;
   cout << "6.搜索数据域为某值的结点" << endl;
   cout << "7.删除数据域为某值的结点及其子树" << endl;
   cout << "8.判断是否为完全二叉树" << endl;
   cout << "9.销毁二叉树" << endl;
   int choice;
   cin >> choice;
   switch (choice)
   {
   //由用户创建二叉树
  case 1:
   {
       if (root){ cout << "二叉树已经创建，无需再建！若想新建，请您先销毁旧树！" << endl; break; }
       Creat(root);
       cout << "二叉树创建完成！" << endl;
       cout << "此二叉树中共有结点" << size << "个！" << endl;
       break;
   }
   //先根遍历二叉树
  case 2:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁，无法执行遍历操作，请您先创建二叉树！" << endl; break; }
       int counter2=0;
       FiRoTra(root,counter2);
       cout << endl;
       break;
   }
   //中根遍历二叉树 
   case 3:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁，无法执行遍历操作，请您先创建二叉树！" << endl; break; }
       int counter3 = 0;
       MiRoTra(root, counter3);
       cout << endl;
       break;
   }
   //后根遍历二叉树
  case 4:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁，无法执行遍历操作，请您先创建二叉树！" << endl; break; }
       int counter4 = 0;
       LaRoTra(root, counter4);
       cout << endl;
       break;
   }
   //层次遍历二叉树
  case 5:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁，无法执行遍历操作，请您先创建二叉树！" << endl; break; }
       int counter5 = 0;
       LeveTra(root, counter5);
       cout << endl;
       head = tail = NULL;
       break;
   }
   //搜索数据域为某值的结点 
   case 6:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁，无法执行搜索操作，请您先创建二叉树！" << endl; break; }
       cout << "请您输入数据域的值;" << endl;
       T indata;  cin >> indata;
       bool flag = false;
       Search(root, indata, flag);
       if (!flag){ cout << "该二叉树中没有数据域为" << indata << "的结点！" << endl; break; }
       else cout << "该二叉树中数据域为" << indata << "的结点共有"<<qsize<<"个。" << endl;
       cout << "是否输出这些结点的地址？是请按1，否则按0：" << endl;
       int choice6; cin >> choice6;
       if (choice6 == 1)    ShowAll(head);
       Delq(); head = tail = NULL; qsize = 0;
       break;
   }
   //删除数据域为某值的结点及其子树
  case 7:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁，无法执行删除操作，请您先创建二叉树！" << endl; break; }
       T data7; bool flag7 = false; bool sign7 = true; int choice7;
       cout << "请您输入结点数据的值：" << endl;
       cin >> data7;
       Search(root, data7, flag7);
       if (!flag7){ cout << "目前二叉树中无数据域为" << data7 << "的结点！" << endl; Delq(); head = tail = NULL; qsize = 0; break; }
       while (sign7)
       {
        Node<T> *p7, *fp7;
        QNode<T> *item7;
        p7 = head->pdata;
        item7 = head; head = head->next; delete item7; qsize--;
        if (p7 == root)
        {
         cout << "数据域为"<<data7<<"的结点为根结点，若执行删除操作将会销毁整棵二叉树！" << endl;
         cout << "是否确定执行删除操作？确定请按1，取消请按0：" << endl;
         cin >> choice7;
         if (choice7 == 0){ Delq(); head = tail = NULL; qsize = 0; goto mark7; }
         else
         {
          Destory(p7); root = NULL; size = 0;
          root = NULL;
          cout << "删除成功！同时整棵二叉树也被销毁！" << endl;
          Delq(); head = tail = NULL; qsize = 0;         
          goto mark7;
         }
        }
        fp7 = GetFather(root, p7);
        if (fp7->left == p7)fp7->left = NULL;
        else fp7->right = NULL;
        Del(p7);
        cout << "删除成功！" << endl;
        if (qsize == 0){ cout << "此时树中已无数据域为" << data7 << "的结点及其子树！" << endl; sign7 = false; }
        if (qsize > 0){ cout << "但此时树中数据域为" << data7 << "的结点还有" <<qsize<<"个！"<< endl; }
        cout << "此次共删除结点" << dsize << "个，" << "目前树中还有结点" << size << "个。" << endl;
        cout << "是否显示被删除的各结点的值？是请按1，否则请按0：" << endl;
        cin >> choice7;
        if (choice7 == 1)D_ShowAll(dhead);
        Deld(); dhead = dtail = NULL; dsize = 0;
        if (qsize > 0)
        {
         cout << "是否继续删除数据域为" <<data7<<"的结点及其子树？是请按1，否则按0："<< endl;
         cin >> choice7;
         if (choice7 == 0)sign7 = false;
        }
       }
       Delq(); head = tail = NULL; qsize = 0;
      mark7:break;
   }
   //判断是否为完全二叉树
  case 8:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁，无法进行判断，请您先创建二叉树！" << endl; break; }
       bool branch=false;
       Addq(root);
       while (qsize>0)
       {
        Node<T>* pt;
        pt = Outq();
        if (!branch)
        {
         if (pt->left == NULL&&pt->right != NULL)
         {
          cout << "目前的二叉树不是完全二叉树！" << endl;
          Delq(); head = tail = NULL; qsize = 0;
          goto mark8;
         }
         if (pt->right==NULL)
         {
          branch = true;
         }
        }
        else
        {
         if (pt->left != NULL || pt->right != NULL)
         {
          cout << "目前的二叉树不是完全二叉树！" << endl;
          Delq(); head = tail = NULL; qsize = 0;
          goto mark8;
         }
        }
        if (pt->left != NULL)Addq(pt->left);
        if (pt->right != NULL)Addq(pt->right);
       }
       cout << "目前的二叉树是完全二叉树！" << endl;
       head = tail = NULL;
      mark8:break;
   }
   //销毁二叉树
  case 9:
   {
       if (!root){ cout << "二叉树还未创建或已被销毁！" << endl; break; }
       cout << "您确定销毁该二叉树吗？确定请按1，取消请按0：" << endl;
       int choice9; cin >> choice9;
       if (choice9 == 0)break;
       else Destory(root);
       root = NULL;
       size = 0;
       cout << "二叉树已销毁！" << endl;
       break;
   }
   //处理用户的错误输入 
   default:
   {
        cout << "您的输入有误，无法进行操作！" << endl;
        break;
   } 

  }//switch结束
  //控制循环
  cout << "是否继续？继续请按1，退出请按0：" << endl;
   int ifgoon;
   cin >> ifgoon;
   if (ifgoon == 0)flager = false;
  }//while结束
}
 #endif 

//.cpp文件 

#include"Tree.h"
 #include<iostream>
 using namespace std;
 int main()
 {
  //是否进入程序
 int uscho ;   bool flag = true;//uscho：user choice的缩写
 cout << "敬告;请您务必按提示要求操作，如果您进行了规定以外的操作，由此造成的一切后果，将全部由您个人承担，程序开发者概不负责！" << endl;
  cout << "是否进入程序？进入请按1，否则按0;" << endl;
  cin >> uscho;
  if (uscho == 0) return 0;
  //用户选择类型
 while (flag)
  {
   cout << "请选择您所要创建二叉树的数据类型，输入类型前的数字进行选择;" << endl;
   cout << "1.整型  2.浮点  3.字符" << endl;
   cin >> uscho;
   if (uscho != 1 && uscho != 2 && uscho != 3)
   {
    cout << "您的输入有误！重新输入请按1，退出请按0：" << endl;
    cin >> uscho;
    if (uscho == 0)return 0;
    else  flag = false;
   }
   if (flag) flag = false;
   else flag = true;
  }
  switch (uscho)
  {
  case 1:
  {
      Tree<int> tree_int;
      tree_int.Operate();
      break;
  }
  case 2:
  {
      Tree<float> tree_float;
      tree_float.Operate();
      break;
  }
  case 3:
  {
      Tree<char> tree_char;
      tree_char.Operate();
      break;
  }
  default:
   cout << "您的输入有误！" << endl;
   break;
  }
  return 0;
 } 

代码已经过测试，在VS2013上成功运行！ 

发此文有两大目的： 

1.和大家交流经验，供需要的人参考。 

2.在下菜鸟，代码中难免有不妥之处，恳求大神批评指正。您的批评就是在下提高的起点，对于您的批评，在下将不胜感激！

 

转载于:https://www.cnblogs.com/zpcdbky/p/4109716.html

dizhen7495
关注
自己动手写数据结构：二叉树BinaryTree类模板C++实现（功能较全）
jobsxiao的专栏
08-09 3958
#ifndef MYBINARYTREE_H #define MYBINARYTREE_H template class BinaryTree { protected: struct TNode { T val; TNode* parent; TNode* left; TNode* right; TNode(T t, TNode* p = 0, TNode* l = 0
二叉树(C++类模板实现)
zws的博客
11-21 4281
文章目录1. 二叉树的定义2.二叉树的性质3.二叉树的存储结构4. 代码 1. 二叉树的定义 后续更新 2.二叉树的性质 后续更新 3.二叉树的存储结构 顺序存储结构。顺序存储结构使用一组地址连续的存储单元来存储数据元素，为了能够在存储结构中反映出结点之间的逻辑关系，必须将二叉树中的结点依照一定的规律安排在这组单元中。 链式存储结构设计不同的结点结构可构成不同形式的链式存储结构。由二叉树的定义得知，二叉树的结点由一个数据元素和分别指向其左、 右子树的两个分支构成，则表示二叉树的链表 中的结点至少
C++实现树的基本操作，界面友好，操作方便，运行流畅，运用模板
dizhen7495的博客
11-22 146
Ⅰ.说明： 1.采用左孩子右兄弟的方式，转化为二叉树来实现。 2.树的后根遍历与二叉树的中根遍历即有联系又有区别，请读者注意分析体会。 Ⅱ.功能： 1.创建树并写入数据 2.先根遍历树 3.计算树高 4.后根遍历树 5.层次遍历树 6.搜索数据域为某值的结点 ...
用C语言实现基于链式栈的括号匹配问题,C++，利用链式栈实现括号匹配，界面友好，操作方便，运行流畅...
weixin_29358723的博客
05-22 632
#include#includeusing namespace std;struct Node{char ch;Node* next;Node(char c, Node* p){ ch = c; next = p; }};void main(){string str;bool flag = true;while (flag){cout << "请输入算术表达式：" << e...
C/C++数据结构综合实践课程设计任务书(12题)[2024-06-27]
code helper
06-27 677
如：对于下列数据的迷宫，输出的一条通路为z(1，1，1)，(1，2，2)，(2，2，2)，(3，2，3)，(3，1，2)，··。1、优：按要求完成题目，有完整的符合标准的文档，文档有条理、文笔通顺，格式正确，其中有总体设计思想的论述，有正确的流程图，程序完全实现设计方案，设计方案先进，软件可靠性好。④承办退票业务：根据客户提供的情况(日期、航班)，为客户办理退票手续，然后查询该航班是否有人排队候补，首先询问排在第一的客户，若所退票额能满足他的要求，则为他办理订票手续，否则依次询问其他排队候补的客户。
计算机专业大学生应该在大学四年踏实学哪些东西?（2021 年 3 月持续更新）
墨鱼菜鸡
09-09 465
大家好，我是程序员吴师兄，不知不觉在知乎有了好几万的关注，在此感谢大家的认可，在这些关注的读者中有不少是计算机专业的大学生或者是转行程序员，今天分享一下我对计算机专业学习路线的看法，希望对这些同学有帮助，能在大学四年里踏踏实实的学好这些内容。 这个路线简单粗暴，完全就是面向岗位(面向工资)来写的。 根据岗位要求，所需要的知识无非是编程语言、数...
android高级面试题（二）
影子
05-06 1万+
Android高级面试题 （⭐⭐⭐） 一、性能优化 1、做过哪些性能优化？是怎么评测和具体优化的？ 一、App启动速度优化 开放问题：如果提高启动速度，设计一个延迟加载框架或者sdk的方法和注意的问题 二、App绘制优化 三、App内存优化 内存抖动（代码注意事项）： 内存抖动是由于短时间内有大量对象进出新生区导致的，它伴随着频繁的GC，gc会大量占用ui线程和cpu资...
网络编程资源大集合(包含前端、java、linux、安卓、github开源项目、开发工具等)
sym的博客
03-14 1万+
以下内容来自转载（非常感谢此文第一作者）：1.安卓各组件介绍一、ListView二、ActionBar三、Menu四、ViewPager 、Gallery五、GridView六、ImageView七、ProgressBar八、其他2.GitHub上优秀Android开源项目3. Android开发神器1.Xabber客户端2.oschina客户端3.手机安全管家4.星座连萌5.玲闹铃6.魔乐盒7....
Android 应用和系统优化V1.2
懒人日志
09-15 8489
一年多年写了一篇简单的软件优化教程，给公司的同事使用。现在应该还不算过时，在过去一年里，在国家脱虚向实运动倡导下，一个个高科技企业如雨后春笋般诞生，对软件的优化和重构的需求也越来越多。早期的 android 开发者曾经十分羡慕C文开发者，C的调试工具是如此之多和丰富，内存，堆栈，CPU，GPU，断点，现在android的系统分析和优化工具也相当多，借助系统自带的开发者工具，android系统也变得
【Android 应用开发】GitHub 优秀的 Android 开源项目
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-09 8万+
文章转载自 : http://blog.csdn.net/zhixiang2010/article/details/18032871 作者 : Elysee2014 主要介绍那些不错个性化的View，包括ListView、ActionBar、Menu、ViewPager、Gallery、GridView、ImageView、ProgressBar及其他如Dialog、Toast、Ed
数据结构中二叉树的模板实现c++,基本上二叉树所有的操作都有了
12-24
,交换子树,层次遍历都用模板实现了,栈和队列用的是以前自己写的模板 程序的输入是数组,通过二叉树的数组表示创建的链表表示的二叉树,输出没有做成树型输出,感觉太复杂,而是按照广义表的输出方式输出 写的时候感觉...
mfc c++ 二叉树图形界面 遍历
11-17
在这个项目中，我们关注的是如何在MFC环境下实现一个二叉树的图形界面，并进行各种遍历操作。二叉树是一种数据结构，其中每个节点最多有两个子节点，通常分为左子节点和右子节点。 首先，`binaryTreeNode.h` 文件...
用C++实现二叉树的基本操作。
05-27
本程序以C++语言实现，提供了二叉树的基本操作，包括创建二叉树、前序遍历、中序遍历、后序遍历、删除节点、计算节点数量以及求解树的高度等。下面将详细解释这些操作。 1. **建树**：构建二叉树的过程通常涉及根据...
AVLTree自平衡二叉树C++模板类实现
01-19
使用C++实现的AVLTree自平衡二叉树，支持动态插入与删除操作，供C++数据结构课程学习与交流使用。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 133
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 303
HJ51输出单向链表中倒数第k个结点。
查找算法简记
well_fly的博客
10-30 607
简单记录查找算法相关知识点
C++算法第五天
2302_80418176的博客
10-31 1052
1. 首这个解法叫滑动窗口，本质是同向双指针2. 使用这个解法的原因是利用了单调性3.滑动窗口的正确性：利用的单调性，规避了没必要的枚举行为4.枚举二字算是在博主的文章中第一次出现，那么我也解释枚举是什么意思，枚举就是将每一种情况都一一列举出来。
实习冲刺Day11
2301_78814687的博客
11-02 276
c++中字符串有两种存储方式，一种是存储在char[]数组中，一种是存储在c++封装的string类中。在C中也可以使用字符指针来访问一个字符串,通过字符指针指向存放字符串数组的首元素地址来进行访问.在C中，并没有字符串这个数据类型，而是使用。char[]来保存字符串。二叉树的先序遍历根左右。二叉树的后序遍历左右根。
C++实现二叉树非递归遍历模板
"这篇资源提供的是关于二叉树遍历的C++实现，特别是非递归方式的前序、中序和后序遍历。它使用了栈数据结构作为辅助工具，通过模板类来实现通用性。" 在计算机科学中，二叉树是一种特殊的图结构，其中每个节点最多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值