数据结构与算法分析课后习题第四章(3)

最新推荐文章于 2020-07-07 17:33:33 发布
最新推荐文章于 2020-07-07 17:33:33 发布
阅读量1.2k 收藏
点赞数
分类专栏： c++ 数据结构 文章标签： 数据结构 算法 null object insert tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zybzmhhj/article/details/1545436
版权

4.38 The larger binary trees in this chapter were generated automatically by a program. This was done by assigning an (x,y) coordinate to each tree node, drawing a circle around each coordinate (this is hard to see in come pictures), and connecting each node to its parent. Asume you have a binary search tree stored in memory (perhaps generated by one of the routines above) and that each node has two extra fields to store the coordinates.

a. The x coordinate can be computed by assigning the inorder traversal number. Write a routine to do this for each node in the tree.

b. The y coordinate can be computed by using the negative of the depth of the node. Write a rutine to do this for each node in the tree.

4.39 Write a general-purpose tree-drawing programs that will convert a tree into the following graph-assemler instructions:

a. Circle(X, Y)

b. DrawLine(i, j)

The first instruction draws a circle at (X, Y), and the second instruction connects the ith circle to the jth circle (circles are numbered in the order drawn). You should either make this a program and define some sort of input language or make this a function that can be called from any program.

//4.38 bstree.hpp

#ifndef BSTREE_HPP__
#define BSTREE_HPP__

#include <iosfwd>

const int XIncrement = 5;
const int YIncrement = -10;

template< typename Object >
class BSTree {
private:
 class Node {
 public:
  Node(const Object& val = Object(), Node* l = NULL, Node* r = NULL,
   Node* p = NULL) : parent(p), lChild(l),
   rChild(r), data(val), x(0), y(0)
  {}

 public:
  Object data;
  Node* lChild;
  Node* rChild;
  Node* parent;
  int x, y;
 };

public:
 BSTree() : root(NULL), parent(NULL) {}
 ~BSTree(){ clear(); }
 BSTree(const BSTree& rhs){}
 BSTree& operator=(const BSTree& rhs){}

public:
 bool contains(const Object& val) const
 { return contains(val, root); }
 bool empty() const
 { return root == NULL; }
 void printTree(std::ostream& out)
 { 
  if(empty())
   out << "empty tree/n";
  else
   printTree(root, out); 
 }

 void clear()
 { clear(root); }
 void add(const Object& val)
 { insert(val, root, parent); }
 void del(const Object& val)
 { remove(val, root, parent); }
 void calcXCoordinate()
 { 
  int c = 0;
  calcXCoordinate(root, c);
 }
 void calcYCoordinate()
 {
  int c = 0;
  calcYCoordinate(root, c);
 }


 
private:
 void insert(const Object& val, Node* &t, Node* &parent)
 {
  if(t == NULL)
   t = new Node(val, NULL, NULL, parent);
  else if(val < t->data)
   insert(val, t->lChild, t);
  else if(t->data < val)
   insert(val, t->rChild, t);
  else
   return;
 }
 
 void remove(const Object& val, Node* &t, Node* &parent)
 {
  if(t == NULL)
   return;

  if(val < t->data)
   remove(val, t->lChild, t);
  else if(t->data < val)
   remove(val, t->rChild, t);
  else if(t->lChild != NULL && t->rChild != NULL)
  {
   t->data = findMin(t->rChild)->data;
   remove(t->data, t->rChild, t);
  }
  else if((t->lChild != NULL && t->rChild == NULL) ||
   (t->lChild == NULL && t->rChild != NULL))
  {
   Node* old = t;
   t = (t->lChild != NULL) ? t->lChild : t->rChild;
   t->parent = old->parent;
   delete old;
  }
  else
  {
   t->parent->rChild == t ? t->parent->rChild = NULL :
         t->parent->lChild = NULL;
   delete t;
  }
 }

 bool contains(const Object& val, Node* t) const
 {
  if(t == NULL)
   return false;
  else if(val < t->data)
   return contains(val, t->lChild);
  else if(t->data < val)
   return contains(val, t->rChild);
  else
   return true;
 }
 
 static Node* findMin(Node* t)
 {
  if(t != NULL)
   while(t->lChild != NULL)
    t = t->lChild;
  return t;
 }

 static Node* findMax(Node* t)
 {
  if(t != NULL)
   while(t->rChild != NULL)
    t = t->rChild;
  return t;
 }

 void clear(Node* &t)
 {
  if(t != NULL)
  {
   clear(t->lChild);
   clear(t->rChild);
   delete t;
  }
  t = NULL;
 }

 void printTree(Node* t, std::ostream& out)
 {
  if(t != NULL)
  {
   printTree(t->lChild, out);
   out << "[ " << t->x << ", "
    << t->y << " ]" << t->data << "/n";
   printTree(t->rChild, out);
  }
 }

 void calcXCoordinate(Node* t, int& count)
 {
  if(t != NULL)
  {
   calcXCoordinate(t->lChild, count);
   t->x += XIncrement * (count++);
   calcXCoordinate(t->rChild, count);
  }
 }

 void calcYCoordinate(Node* t, int count)
 {
  if(t != NULL)
  {
   t->y += YIncrement * (count++);
   calcYCoordinate(t->lChild, count);
   calcYCoordinate(t->rChild, count);
  }
 }

private:
 Node* root;
 Node* parent;

};

#endif

//4.39 bstree.hpp

#ifndef BSTREE_HPP__
#define BSTREE_HPP__

#include <iosfwd>

class DrawTree;

const int XIncrement = 30;
const int YIncrement = 40;

template< typename Object >
class BSTree {
private:
 class Node {
 public:
  Node(const Object& val = Object(), Node* l = NULL, Node* r = NULL,
   Node* p = NULL) : parent(p), lChild(l),
   rChild(r), data(val), x(10), y(10)
  {}

 public:
  Object data;
  Node* lChild;
  Node* rChild;
  Node* parent;
  int x, y;
 };

public:
 BSTree() : root(NULL), parent(NULL) {}
 ~BSTree(){ clear(); }
 BSTree(const BSTree& rhs){}
 BSTree& operator=(const BSTree& rhs){}

public:
 bool contains(const Object& val) const
 { return contains(val, root); }
 bool empty() const
 { return root == NULL; }
 void printTree(std::ostream& out)
 { 
  if(empty())
   out << "empty tree/n";
  else
   printTree(root, out); 
 }

 void clear()
 { clear(root); }
 void add(const Object& val)
 { insert(val, root, parent); }
 void del(const Object& val)
 { remove(val, root, parent); }
 void calcXCoordinate()
 { 
  int c = 0;
  calcXCoordinate(root, c);
 }
 void calcYCoordinate()
 {
  int c = 0;
  calcYCoordinate(root, c);
 }

private:
 void insert(const Object& val, Node* &t, Node* &parent)
 {
  if(t == NULL)
   t = new Node(val, NULL, NULL, parent);
  else if(val < t->data)
   insert(val, t->lChild, t);
  else if(t->data < val)
   insert(val, t->rChild, t);
  else
   return;
 }
 
 void remove(const Object& val, Node* &t, Node* &parent)
 {
  if(t == NULL)
   return;

  if(val < t->data)
   remove(val, t->lChild, t);
  else if(t->data < val)
   remove(val, t->rChild, t);
  else if(t->lChild != NULL && t->rChild != NULL)
  {
   t->data = findMin(t->rChild)->data;
   remove(t->data, t->rChild, t);
  }
  else if((t->lChild != NULL && t->rChild == NULL) ||
   (t->lChild == NULL && t->rChild != NULL))
  {
   Node* old = t;
   t = (t->lChild != NULL) ? t->lChild : t->rChild;
   t->parent = old->parent;
   delete old;
  }
  else
  {
   t->parent->rChild == t ? t->parent->rChild = NULL :
         t->parent->lChild = NULL;
   delete t;
  }
 }

 bool contains(const Object& val, Node* t) const
 {
  if(t == NULL)
   return false;
  else if(val < t->data)
   return contains(val, t->lChild);
  else if(t->data < val)
   return contains(val, t->rChild);
  else
   return true;
 }
 
 static Node* findMin(Node* t)
 {
  if(t != NULL)
   while(t->lChild != NULL)
    t = t->lChild;
  return t;
 }

 static Node* findMax(Node* t)
 {
  if(t != NULL)
   while(t->rChild != NULL)
    t = t->rChild;
  return t;
 }

 void clear(Node* &t)
 {
  if(t != NULL)
  {
   clear(t->lChild);
   clear(t->rChild);
   delete t;
  }
  t = NULL;
 }

 void printTree(Node* t, std::ostream& out)
 {
  if(t != NULL)
  {
   printTree(t->lChild, out);
   out << "[ " << t->x << ", "
    << t->y << " ]" << t->data << "/n";
   printTree(t->rChild, out);
  }
 }

 void calcXCoordinate(Node* t, int& count)
 {
  if(t != NULL)
  {
   calcXCoordinate(t->lChild, count);
   t->x += XIncrement * (count++);
   calcXCoordinate(t->rChild, count);
  }
 }

 void calcYCoordinate(Node* t, int count)
 {
  if(t != NULL)
  {
   t->y += YIncrement * (count++);
   calcYCoordinate(t->lChild, count);
   calcYCoordinate(t->rChild, count);
  }
 }

private:
 Node* root;
 Node* parent;

 friend class DrawTree;

};

#endif

//drawtree.hpp

#ifndef DRAWTREE_HPP__
#define DRAWTREE_HPP__

#include <windows.h>

class Point;

template < typename Object >
class BSTree;

const int Radius = 10;

class DrawTree {
public:
 DrawTree();
 ~DrawTree();
 
 void Draw(const HWND&);
 
private:
 void Circle(int, int, const HWND&);
 void DrawLine(const Point&, const Point&, const HWND&);
 
 template< typename Object >
 void DoDraw(const HWND&, const typename BSTree<Object>::Node*);
 DrawTree(const DrawTree&);
 DrawTree& operator=(const DrawTree&);

};

#endif

//treegen.hpp

#ifndef TREEGEN_HPP__
#define TREEGEN_HPP__

#include "bstree.hpp"
#include <cstdlib>
#include <vector>
#include <ctime>

template< typename Object >
void TreeGenerator(BSTree<Object>& tree, const int num)
{
 std::srand(time(NULL));
 std::vector<Object> vec;
 int size = num;
 
 for(int i = 1; i <= num; ++i)
 {
  vec.push_back(i);
 }

 for(int i = 0; i < num; ++i)
 {
  std::vector<Object>::iterator it = vec.begin();
  int n = rand() % (size--);
  it += n;
  tree.add(*it);
  vec.erase(it);
 }
}

#endif

//drawtree.cpp

#include "drawtree.hpp"
#include "treegen.hpp"
#include <cstdlib>

class Point{
public:
 Point(int x = NULL, int y = NULL) : x(x), y(y)
 {}
public:
 int x;
 int y;
};

DrawTree::DrawTree()
{}

DrawTree::~DrawTree()
{}

void DrawTree::Circle(int x, int y, const HWND& hwnd)
{
 HDC hdc = GetDC(hwnd);
 Ellipse(hdc, x-Radius, y-Radius, x+Radius, y+Radius);
}

void DrawTree::DrawLine(const Point &from, const Point &to,
      const HWND& hwnd)
{
 HDC hdc = GetDC(hwnd);
 MoveToEx(hdc, from.x, from.y, NULL);
 LineTo(hdc,to.x, to.y);
}

void DrawTree::Draw(const HWND& hwnd)
{
 BSTree<int> tree;
 TreeGenerator(tree, 30);
 tree.calcXCoordinate();
 tree.calcYCoordinate();

 DoDraw<int>(hwnd, tree.root);
}

template< typename Object >
void DrawTree::DoDraw(const HWND& hwnd, const typename BSTree<Object>::Node* t)
{
 if(t != NULL)
 {
  Circle(t->x, t->y, hwnd);
  if(t->lChild != NULL)
   DrawLine(Point(t->x-Radius, t->y+Radius),
    Point(t->lChild->x+Radius, t->lChild->y-Radius) ,hwnd);
  if(t->rChild != NULL)
   DrawLine(Point(t->x+Radius, t->y+Radius),
    Point(t->rChild->x-Radius, t->rChild->y-Radius) ,hwnd);
  wchar_t a[20];
  _i64tow_s(t->data, a, 20, 10);
  TextOut(GetDC(hwnd), t->x, t->y-Radius/2, a, wcslen(a));
  DoDraw<Object>(hwnd, t->lChild);
  DoDraw<Object>(hwnd, t->rChild);
 }
}

//main.cpp

#include "bstree.hpp"
#include "drawtree.hpp"
#include <windows.h>


LRESULT WINAPI WndProc (HWND, UINT, WPARAM, LPARAM);
//WinMain函数
int WINAPI WinMain (HINSTANCE hInstance,
     HINSTANCE hPrevInstance,
     LPSTR lpCmdLine,
     int nCmdShow)
{
 HWND hWnd; //主窗口句柄
 MSG msg; //窗口消息
 WNDCLASSEX wndcls; //窗口类
 if ( !hPrevInstance )
 {
  //填充窗口类信息
  wndcls.cbSize = sizeof(WNDCLASSEX);
  wndcls.style = CS_HREDRAW | CS_VREDRAW; //当长或宽改变的时候重画整个窗口
  wndcls.lpfnWndProc = WndProc; //长指针指向windows过程处理函数
  wndcls.cbClsExtra = 0; //指明了为windows类额外分配的内存的数量，windows初始化为0
  wndcls.cbWndExtra = 0; //指定了为windows实例额外分配的内存的数量，windows初始化为0
  wndcls.hInstance = hInstance; //指向windows程序实例的句柄
  wndcls.hIcon = LoadIcon(NULL, IDI_APPLICATION); //为了使用预先定义好的图标，需将第一个参数高为NULL
  wndcls.hCursor = LoadCursor(NULL,  IDC_ARROW);
  wndcls.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH); //背景的画刷
  wndcls.lpszMenuName = NULL; //菜单
  wndcls.lpszClassName = TEXT("Draw Binary Search Tree"); //指明了windows类的名称
  wndcls.hIconSm = NULL;
  //注册窗口类
  RegisterClassEx(&wndcls);
 }
 //创建应用程序主窗口
 hWnd = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW,
  TEXT("Draw Binary Search Tree"),
  TEXT("Tree graph"),
  WS_OVERLAPPED,
  0,
  0,
  1024,
  768,
  NULL,
  NULL,
  NULL,
  NULL);
 //显示窗口
 ShowWindow(hWnd, SW_SHOW);
 //更新主窗口客户区
 UpdateWindow(hWnd);
 //开始消息循环
 while ( GetMessage(&msg, NULL, 0, 0) )
 {
  TranslateMessage(&msg);
  DispatchMessage(&msg);
 }
 return msg.wParam;
}

//主窗口过程，处理窗口中各种各样的事件
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
 DrawTree* dt;
 switch ( msg )
 {
 case WM_PAINT:
  dt = new DrawTree();
  dt->Draw(hWnd);
  
  break;
 case WM_DESTROY:
  PostQuitMessage(0); //发送退出程序的消息
  break;
 default:
  break;
 }
 return DefWindowProc(hWnd, msg, wParam, lParam);
} 

 

zybzmhhj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法分析课后习题第四章(1)
zyb的专栏
03-16 1708
4.11 Write an implementation of the set class, with associated iterators using a binary search tree. Add to each node a link to the parent node.4.12 Write an implementation of the map class by stori
数据结构与算法分析(C++版)（第三版)第四章实验课习题答案
10-16
数据结构与算法分析(C++版)（第三版)第四章实验课习题答案，这次包含的是第四章课后的4.15、4.16两道题
数据结构与算法分析课后习题第四章(4)
zyb的专栏
03-29 4293
4.40 Write a routine to list out the nodes of a binary tree in level-order. List the root, then nodes at depth 1, followed by nodes at depth 2, and so on.4.44 Write a procedure to traverse a tree st
数据结构与算法分析（C++语言版）张琨版 课后答案———第四章
zim123zim的博客
06-09 1227
数据结构与算法分析（C++语言版）张琨版 课后答案———第四章一、选择二、判断三、填空四、简答 答案来自网络，如果有错误请联系我更正（772173629），谢谢合作！ 一、选择 1.B 2.E 3.C 4.A 5.C 6.A 7.D、F 8.B 9.B 二、判断 1.对 2.对 3.对 三、填空 1.零 2.串变量、串常量 3.链串 4.串匹配、 子串 5.n+m 6.01122312 7.01010421 8.模式匹配、模式串 9.堆分配存储、链式存储 10.两串的长度相等且两串中对于位置的字符也相等
《数据结构与算法分析C++描述第三版》答案
12-06
《数据结构与算法分析C++描述第三版》答案
DataStruct:张铭-数据结构与算法习题
04-11
:keycap_2: 习题 1 ：是北大张铭《数据结构与算法》教材习题以及对应的《数据结构与算法-学习指导与习题解析》 :keycap_3: 习题 2 ：来自王道教材习题 第一章 概述 第二章 线性表 第三章 栈和队列 :green_book: 第...
数据结构与算法分析习题答案
08-17
数据结构与算法分析每章练习的答案 数据结构与算法分析每章练习的答案
数据结构教程(第三版)课后答案.
09-26
数据结构教程(第三版)课后实验答案，word文档
数据结构与算法分析-C语言描述--第四章题目答案
bilililala的博客
10-31 2848
部分自己证明 部分翻自该书答案 1-3 不作详细证明 4.4 证明在N个节点的二叉树中，存在N+1个NULL指针代表N+1个儿子。 证: 对于N个节点的二叉树 共有2N个指针 而每个节点（除去根节点）都会占用一个指针，所以有N-1个指针不为空 所以共有： 2N-（N-1）= N+1 个NULL指针 4.5 证明在高度为H的二叉树中，节点最大个数是 证: 对于高度为H的二叉树，...
二叉查找树
烽火前秦路
05-17 575
二叉树 二叉树是一颗每个结点都不能多于两个儿子的树。 结点实现 具有N个结点的每一颗二叉树都需要N+1个NULL链。 //二叉树结点类 struct BinaryNode { Comprarable element; //The data in the node; BinaryNode *left; //left child BinaryNode *r
数据结构与算法MOOC-第四章字符串练习题解析汇总
[SZU_Crayon]
08-30 1906
数据结构与算法MOOC-第四章字符串练习题解析汇总 1:合格的字符串 OpenJudge-合格的字符串 2:去除C程序中的注释 OpenJudge-去除C程序中的注释 3:全在其中 POJ 938/UVA 10340-All in All(全在其中) 4:字符串乘方 KMP-(POJ 2406)Power Strings[字符串乘方] 5:英语数...
递归删除不带头节点的单链表——不断链的原因
qq_43840665的博客
07-07 681
题目：递归来实现删除单链表中一个值为x的节点的函数 void del(LinkList &L,ElemType x) { Node *t; if (L==NULL) return; if (L->data==x) { t=L; L=L->next; free(t); return; } else del(L->next,x); } 关键点：什么引用？ 引用是给同一个内存对象起的别名，即引用和原变量名表示
数据结构第四章课后题
独一无二的我的专栏
04-09 3172
4.1采用顺序结构存储串，编写一个实现串通配符匹配的算法pattern_index(),其中的通配符只有“?”，它可以和任一字符匹配成功，例如，pattern_index("?re","there are"),返回的结果是2。 代码： #include #include #include #include using namespace std; #define MaxSize 100
C++ class的一些习俗--提供print(ostream &out)成员函数
Blog of Tom Chao Zhou
06-05 3576
C++实现新的class有一些习俗，比如会提供一个 print(ostream & out)的公开的成员函数，例子如下 class Employee { public: void print(ostream& out) const { out << name << salary << endl; } private: string name;
数据结构之树
li_il的博客
03-24 303
基础知识 树的定义： 树是n (n≥1) 个结点的有限集合T，并且满足 有一个被称之为根(root)的结点 其余的结点可分为m(m≥0)个互不相交的集合Tl，T2，…，Tm，这些集合本身也是一棵树，也有自己的根结点，它们被称为根结点的子树(Subree)。 树结构中的概念 有序树：计算机的存储是有序的，为方便计算机处理，往往把子结点按从左到右的次序顺序编号，即把树作为有序树(orde...
数据结构与算法python语言实现-第四章答案
蹦迪小王子的博客
07-26 1560
数据结构与算法python语言实现-第四章答案时间复杂度为O(n) 空间复杂度为O(n)内循环操作数为n/2，调用情况为len(A)/2 -> len(A)/4 -> ...-> len(A)/2**r，即n/2**r<1，r>logn,r=floor(logn)+1,复杂度为logn，所以总的复杂度为O(nlogn) 4.1 def findmax(S, in...
算法第四版 课后习题答案
热门推荐
fuckluy的博客
03-28 3万+
算法第四版 Eclipse EOF
数据结构与算法c语言课后习题
最新发布
09-04
- *1* *2* *3* [《数据结构与算法分析:C语言描述_原书第二版》CH2算法分析_课后习题_部分解答...](https://blog.csdn.net/weixin_30527423/article/details/95199549)[target="_blank" data-report-click={"spm":...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值