码迷,mamicode.com
首页 > 编程语言 > 详细

Standard C++ Episode 8

时间:2015-08-21 07:00:49      阅读:217      评论:0      收藏:0      [点我收藏+]

标签:

数据结构

 
一、数据结构的基本概念
1.逻辑结构
1)集合结构(集):结构中的元素除了同属一个集之外,没有任何联系。
2)线性结构(表):结构中的元素具有一对一的前后关系。
3)树型结构(树):结构中的元素具有一对多的父子关系。
4)网状结构(图):结构中的元素具有多对多的交叉映射关系。
2.物理结构
1)顺序结构(数组):结构中的元素存放在一段连续的地址空间中。随机访问方便,空间利用率低,插入删除不便。
2)链式结构(链式):结构中的元素存放在彼此独立的地址空间中,每个独立的地址空间被称为节点,节点除了保存数据以外,还保存另外一个或几个相关节点的地址。空间利用率高,插入删除方便,随机访问不便。
3.逻辑结构和物理结构的关系
      表    树  图
顺序 数组 顺序树 复  
链式 链表 链式树 合
二、数据结构的基本运算
1.创建与销毁
2.插入与删除
3.获取与修改
4.排序与查找
三、堆栈
1.基本特征:后进先出
2.基本操作:压入(push),弹出(pop)
3.实现要点:初始化空间,栈顶指针,判空判满。

 

 

 1 #include <iostream>
 2 using namespace std;
 3 // 基于顺序表的堆栈
 4 class Stack {
 5 public:
 6     // 构造过程中分配内存
 7     Stack (size_t size = 10) :
 8         m_array (new int[size]), m_size (size),
 9         m_top (0) {}
10     // 析构过程中释放内存
11     ~Stack (void) {
12         if (m_array) {
13             delete[] m_array;
14             m_array = 0;
15         }
16     }
17     // 压入
18     void push (int data) {
19         if (full ())
20             throw OverFlow ();
21         m_array[m_top++] = data;
22     }
23     // 弹出
24     int pop (void) {
25         if (empty ())
26             throw UnderFlow ();
27         return m_array[--m_top];
28     }
29     // 判满
30     bool full (void) const {
31         return m_top >= m_size;
32     }
33     // 判空
34     bool empty (void) const {
35         return ! m_top;
36     }
37 private:
38     // 上溢异常
39     class OverFlow : public exception {
40         const char* what (void) const throw () {
41             return "堆栈上溢!";
42         }
43     };
44     // 下溢异常
45     class UnderFlow : public exception {
46         const char* what (void) const throw () {
47             return "堆栈下溢!";
48         }
49     };
50     int* m_array; // 数组
51     size_t m_size; // 容量
52     size_t m_top; // 栈顶
53 };
54 void printb (unsigned int numb, int base) {
55     Stack stack (256);
56     do {
57         stack.push (numb % base);
58     }    while (numb /= base);
59     while (! stack.empty ()) {
60         int digit = stack.pop ();
61         if (digit < 10)
62             cout << digit;
63         else
64             cout << char (digit - 10 + A);
65     }
66     cout << endl;
67 }
68 int main (void) {
69     try {
70         Stack stack;
71         for (int i = 0; ! stack.full (); ++i)
72             stack.push (i);
73 //        stack.push (0);
74         while (! stack.empty ())
75             cout << stack.pop () << endl;
76 //        stack.pop ();
77     }
78     catch (exception& ex) {
79         cout << ex.what () << endl;
80         return -1;
81     }
82     cout << "输入一个整数:" << flush;
83     int numb;
84     cin >> numb;
85     cout << "您想看几进制:" << flush;
86     int base;
87     cin >> base;
88     cout << "结果:";
89     printb (numb, base);
90     return 0;
91 }

 

 

 1 #include <iostream>
 2 using namespace std;
 3 // 基于链式表的堆栈
 4 class Stack {
 5 public:
 6     // 构造过程中初始化为空堆栈
 7     Stack (void) : m_top (NULL) {}
 8     // 析构过程中销毁剩余的节点
 9     ~Stack (void) {
10         for (Node* next; m_top; m_top = next) {
11             next = m_top->m_next;
12             delete m_top;
13         }
14     }
15     // 压入
16     void push (int data) {
17         /*
18         Node* node = new Node;
19         node->m_data = data;
20         node->m_next = m_top;
21         m_top = node;*/
22         m_top = new Node (data, m_top);
23     }
24     // 弹出
25     int pop (void) {
26         if (empty ())
27             throw UnderFlow ();
28         int data = m_top->m_data;
29         Node* next = m_top->m_next;
30         delete m_top;
31         m_top = next;
32         return data;
33     }
34     // 判空
35     bool empty (void) const {
36         return ! m_top;
37     }
38 private:
39     // 下溢异常
40     class UnderFlow : public exception {
41         const char* what (void) const throw () {
42             return "堆栈下溢!";
43         }
44     };
45     // 节点
46     class Node {
47     public:
48         Node (int data = 0, Node* next = NULL) :
49             m_data (data), m_next (next) {}
50         int m_data; // 数据
51         Node* m_next; // 后指针
52     };
53     Node* m_top; // 栈顶
54 };
55 int main (void) {
56     try {
57         Stack stack;
58         for (int i = 0; i < 10; ++i)
59             stack.push (i);
60         while (! stack.empty ())
61             cout << stack.pop () << endl;
62 //        stack.pop ();
63     }
64     catch (exception& ex) {
65         cout << ex.what () << endl;
66         return -1;
67     }
68     return 0;
69 }

 

 

 

 

四、队列
1.基本特征:先进先出,FIFO
2.基本操作:压入(push)、弹出(pop)
3.实现要点:初始化空间,从前端(front)弹出,从后端(rear)压入,循环使用,判空判满

 1 #include <iostream>
 2 using namespace std;
 3 // 基于顺序表的队列
 4 class Queue {
 5 public:
 6     // 构造过程中分配内存
 7     Queue (size_t size = 5) :
 8         m_array (new int[size]), m_size (size),
 9         m_rear (0), m_front (0), m_count (0) {}
10     // 析构过程中释放内存
11     ~Queue (void) {
12         if (m_array) {
13             delete[] m_array;
14             m_array = NULL;
15         }
16     }
17     // 压入
18     void push (int data) {
19         if (full ())
20             throw OverFlow ();
21         if (m_rear >= m_size)
22             m_rear = 0;
23         ++m_count;
24         m_array[m_rear++] = data;
25     }
26     // 弹出
27     int pop (void) {
28         if (empty ())
29             throw UnderFlow ();
30         if (m_front >= m_size)
31             m_front = 0;
32         --m_count;
33         return m_array[m_front++];
34     }
35     // 判空
36     bool empty (void) const {
37         return ! m_count;
38     }
39     // 判满
40     bool full (void) const {
41         return m_count == m_size;
42     }
43 private:
44     // 上溢异常
45     class OverFlow : public exception {
46         const char* what (void) const throw () {
47             return "队列上溢!";
48         }
49     };
50     // 下溢异常
51     class UnderFlow : public exception {
52         const char* what (void) const throw () {
53             return "队列下溢!";
54         }
55     };
56     int* m_array; // 数组
57     size_t m_size; // 容量
58     size_t m_rear; // 后端
59     size_t m_front; // 前端
60     size_t m_count; // 计数
61 };
62 int main (void) {
63     try {
64         Queue queue;
65         queue.push (10);
66         queue.push (20);
67         queue.push (30);
68         queue.push (40);
69         queue.push (50);
70 //        queue.push (60);
71         cout << queue.pop () << endl; // 10
72         queue.push (60);
73         cout << queue.pop () << endl; // 20
74         queue.push (70);
75 //        queue.push (80);
76         cout << queue.pop () << endl; // 30
77         cout << queue.pop () << endl; // 40
78         cout << queue.pop () << endl; // 50
79         cout << queue.pop () << endl; // 60
80         cout << queue.pop () << endl; // 70
81 //        queue.pop ();
82     }
83     catch (exception& ex) {
84         cout << ex.what () << endl;
85         return -1;
86     }
87     return 0;
88 }

 

 

 1 #include <iostream>
 2 using namespace std;
 3 // 基于链式表的队列
 4 class Queue {
 5 public:
 6     // 在构造过程中初始化为空队列
 7     Queue (void) : m_rear (NULL), m_front (NULL) {}
 8     // 在析构过程中销毁剩余的节点
 9     ~Queue (void) {
10         for (Node* next; m_front; m_front = next) {
11             next = m_front->m_next;
12             delete m_front;
13         }
14     }
15     // 压入
16     void push (int data) {
17         Node* node = new Node (data);
18         if (m_rear)
19             m_rear->m_next = node;
20         else
21             m_front = node;
22         m_rear = node;
23     }
24     // 弹出
25     int pop (void) {
26         if (empty ())
27             throw UnderFlow ();
28         int data = m_front->m_data;
29         Node* next = m_front->m_next;
30         delete m_front;
31         if (! (m_front = next))
32             m_rear = NULL;
33         return data;
34     }
35     // 判空
36     bool empty (void) const {
37         return ! m_front && ! m_rear;
38     }
39 private:
40     // 下溢异常
41     class UnderFlow : public exception {
42         const char* what (void) const throw () {
43             return "队列下溢!";
44         }
45     };
46     // 节点
47     class Node {
48     public:
49         Node (int data = 0, Node* next = NULL) :
50             m_data (data), m_next (next) {}
51         int m_data; // 数据
52         Node* m_next; // 后指针
53     };
54     Node* m_rear; // 后端
55     Node* m_front; // 前端
56 };
57 int main (void) {
58     try {
59         Queue queue;
60         for (int i = 0; i < 10; ++i)
61             queue.push (i);
62         while (! queue.empty ())
63             cout << queue.pop () << endl;
64     }Node* 
65     catch (exception& ex) {
66         cout << ex.what () << endl;
67         return -1;
68     }
69     return 0; 
70 }

 

思考:用堆栈实现队列,俗称"适配器"。

 1 /*
 2  * 文件名: lstack.h
 3  */
 4 #ifndef _LSTACK_H
 5 #define _LSTACK_H
 6 #include <stdexcept>
 7 using namespace std;
 8 // 基于链式表的堆栈
 9 class Stack {
10 public:
11     // 构造过程中初始化为空堆栈
12     Stack (void) : m_top (NULL) {}
13     // 析构过程中销毁剩余的节点
14     ~Stack (void) {
15         for (Node* next; m_top; m_top = next) {
16             next = m_top->m_next;
17             delete m_top;
18         }
19     }
20     // 压入
21     void push (int data) {
22         /*
23         Node* node = new Node;
24         node->m_data = data;
25         node->m_next = m_top;
26         m_top = node;*/
27         m_top = new Node (data, m_top);
28     }
29     // 弹出
30     int pop (void) {
31         if (empty ())
32             throw UnderFlow ();
33         int data = m_top->m_data;
34         Node* next = m_top->m_next;
35         delete m_top;
36         m_top = next;
37         return data;
38     }
39     // 判空
40     bool empty (void) const {
41         return ! m_top;
42     }
43 private:
44     // 下溢异常
45     class UnderFlow : public exception {
46         const char* what (void) const throw () {
47             return "堆栈下溢!";
48         }
49     };
50     // 节点
51     class Node {
52     public:
53         Node (int data = 0, Node* next = NULL) :
54             m_data (data), m_next (next) {}
55         int m_data; // 数据
56         Node* m_next; // 后指针
57     };
58     Node* m_top; // 栈顶
59 };
60 #endif // _LSTACK_H

 

 1 #include <iostream>
 2 #include "lstack.h"
 3 using namespace std;
 4 // 基于堆栈的队列
 5 class Queue {
 6 public:
 7     // 压入
 8     void push (int data) {
 9         m_i.push (data);
10     }
11     // 弹出
12     int pop (void) {
13         if (m_o.empty ()) {
14             if (m_i.empty ())
15                 throw underflow_error("队列下溢!");
16             while (! m_i.empty ())
17                 m_o.push (m_i.pop ());
18         }
19         return m_o.pop ();
20     }
21     // 判空
22     bool empty (void) const {
23         return m_i.empty () && m_o.empty ();
24     }
25 private:
26     Stack m_i; // 输入栈
27     Stack m_o; // 输出栈
28 };
29 int main (void) {
30     try {
31         Queue queue;
32         for (int i = 0; i < 10; ++i)
33             queue.push (i);
34         cout << queue.pop () << endl; // 0
35         cout << queue.pop () << endl; // 1
36         cout << queue.pop () << endl; // 2
37         cout << queue.pop () << endl; // 3
38         cout << queue.pop () << endl; // 4
39         queue.push (10);
40         queue.push (11);
41         queue.push (12);
42         while (! queue.empty ())
43             cout << queue.pop () << endl;
44     }
45     catch (exception& ex) {
46         cout << ex.what () << endl;
47         return -1;
48     }
49     return 0;
50 }

 

 

 

五、链表
1.基本特征:内存中不连续的节点序列,彼此之间通过指针相互关联,前指针(prev)指向前节点,后指针(next)指向后节点。
2.基本操作:追加、插入、删除、遍历

  1 #include <iostream>
  2 #include <stdexcept>
  3 using namespace std;
  4 // 双向线性链表
  5 class List {
  6 public:
  7     // 构造过程中初始化为空链表
  8     List (void) : m_head (NULL), m_tail (NULL) {}
  9     // 析构过程中销毁剩余的节点
 10     ~List (void) {
 11         for (Node* next; m_head; m_head = next) {
 12             next = m_head->m_next;
 13             delete m_head;
 14         }
 15     }
 16     // 追加
 17     void append (int data) {
 18         m_tail = new Node (data, m_tail);
 19         if (m_tail->m_prev)
 20             m_tail->m_prev->m_next = m_tail;
 21         else
 22             m_head = m_tail;
 23     }
 24     // 插入
 25     void insert (size_t pos, int data) {
 26         for (Node* find = m_head; find;
 27             find = find->m_next)
 28             if (pos-- == 0) {
 29                 Node* node = new Node (data,
 30                     find->m_prev, find);
 31                 if (node->m_prev)
 32                     node->m_prev->m_next = node;
 33                 else
 34                     m_head = node;
 35                 node->m_next->m_prev = node;
 36                 return;
 37             }
 38         throw out_of_range ("链表越界!");
 39     }
 40     // 删除
 41     void erase (size_t pos) {
 42         for (Node* find = m_head; find;
 43             find = find->m_next)
 44             if (pos-- == 0) {
 45                 if (find->m_prev)
 46                     find->m_prev->m_next =
 47                         find->m_next;
 48                 else
 49                     m_head = find->m_next;
 50                 if (find->m_next)
 51                     find->m_next->m_prev =
 52                         find->m_prev;
 53                 else
 54                     m_tail = find->m_prev;
 55                 delete find;
 56                 return;
 57             }
 58         throw out_of_range ("链表越界!");
 59     }
 60     // 正向遍历
 61     void forward (void) const {
 62         for (Node* node = m_head; node;
 63             node = node->m_next)
 64             cout << node->m_data <<  ;
 65         cout << endl;
 66     }
 67     // 反向遍历
 68     void backward (void) const {
 69         for (Node* node = m_tail; node;
 70             node = node->m_prev)
 71             cout << node->m_data <<  ;
 72         cout << endl;
 73     }
 74     // 下标访问
 75     int& operator[] (size_t index) {
 76         for (Node* find = m_head; find;
 77             find = find->m_next)
 78             if (index-- == 0)
 79                 return find->m_data;
 80         throw out_of_range ("链表越界!");
 81     }
 82     const int& operator[] (size_t index) const {
 83         return const_cast<List&> (*this) [index];
 84     }
 85 private:
 86     // 节点
 87     class Node {
 88     public:
 89         Node (int data = 0, Node* prev = NULL,
 90             Node* next = NULL) : m_data (data),
 91             m_prev (prev), m_next (next) {}
 92         int m_data; // 数据
 93         Node* m_prev; // 前指针
 94         Node* m_next; // 后指针
 95     };
 96     Node* m_head; // 头指针
 97     Node* m_tail; // 尾指针
 98 };
 99 int main (void) {
100     try {
101         List list;
102         list.append (10);
103         list.append (30);
104         list.append (50);
105         list.append (60);
106         list.append (80);
107         list.insert (1, 20);
108         list.insert (3, 40);
109         list.insert (6, 70);
110         list.forward ();
111         list.backward ();
112         list.erase (5);
113         list.erase (5);
114         list.erase (5);
115         list.forward ();
116         for (size_t i = 0; i < 5; ++i)
117             ++list[i];
118         const List& cr = list;
119         for (size_t i = 0; i < 5; ++i)
120             cout << /*++*/cr[i] <<  ;
121         cout << endl;
122     }
123     catch (exception& ex) {
124         cout << ex.what () << endl;
125         return -1;
126     }
127     return 0;
128 }

 

 

  1 // 练习:实现一个单向线性链表类
  2 // 1.建立、测长、正反向打印
  3 // 2.逆转
  4 // 3.获取中间节点值,单次遍历
  5 // 4.有序链表的插入和删除
  6 #include <iostream>
  7 #include <stdexcept>
  8 using namespace std;
  9 class List {
 10 public:
 11     List (void) : m_head (NULL), m_tail (NULL) {}
 12     ~List (void) {
 13         for (Node* next; m_head; m_head = next) {
 14             next = m_head->m_next;
 15             delete m_head;
 16         }
 17     }
 18     void append (int data) {
 19         Node* node = new Node (data);
 20         if (m_tail)
 21             m_tail->m_next = node;
 22         else
 23             m_head = node;
 24         m_tail = node;
 25     }
 26     size_t size (void) const {
 27         size_t cn = 0;
 28         for (Node* node = m_head; node;
 29             node = node->m_next)
 30             ++cn;
 31         return cn;
 32     }
 33     void print (void) const {
 34         for (Node* node = m_head; node;
 35             node = node->m_next)
 36             cout << node->m_data <<  ;
 37         cout << endl;
 38     }
 39     void rprint (void) const {
 40         rprint (m_head);
 41         cout << endl;
 42     }
 43     /*
 44     void reverse (void) {
 45         reverse (m_head);
 46         swap (m_head, m_tail);
 47     }
 48     */
 49     void reverse (void) {
 50         if (m_head != m_tail) {
 51             Node* p1 = m_tail = m_head;
 52             Node* p2 = p1->m_next;
 53             Node* p3 = p2->m_next;
 54             for (p1->m_next=NULL;p3;p3=p3->m_next) {
 55                 p2->m_next = p1;
 56                 p1 = p2;
 57                 p2 = p3;
 58             }
 59             (m_head = p2)->m_next = p1;
 60         }
 61     }
 62     int middle (void) const {
 63         if (! m_head || ! m_tail)
 64             throw underflow_error ("链表下溢!");
 65         if (m_head == m_tail)
 66             return m_head->m_data;
 67         Node* mid = m_head;
 68         for (Node* node = m_head;
 69             node->m_next && node->m_next->m_next;
 70             node = node->m_next->m_next)
 71             mid = mid->m_next;
 72         return mid->m_data;
 73     }
 74     // 插入data,仍然保持有序
 75     void insert (int data) {
 76     }
 77     // 删除所有的data
 78     void remove (int data) {
 79     }
 80 private:
 81     class Node {
 82     public:
 83         Node (int data = 0, Node* next = NULL) :
 84             m_data (data), m_next (next) {}
 85         int m_data;
 86         Node* m_next;
 87     };
 88     void rprint (Node* head) const {
 89         if (head) {
 90             rprint (head->m_next);
 91             cout << head->m_data <<  ;
 92         }
 93     }
 94     void reverse (Node* head) {
 95         if (head && head->m_next) {
 96             reverse (head->m_next);
 97             head->m_next->m_next = head;
 98             head->m_next = NULL;
 99         }
100     }
101     Node* m_head;
102     Node* m_tail;
103 };
104 int main (void) {
105     List list;
106     for (int i = 0; i < 11; ++i)
107         list.append (i);
108     cout << list.size () << endl;
109     list.print ();
110     list.rprint ();
111     list.reverse ();
112     list.print ();
113     cout << list.middle () << endl;
114     return 0;
115 }

 

 

六、二叉树
1.基本特征
1)树型结构的最简模型,每个节点最多有两个子节点。
2)单根。除根节点外每个节点有且仅有一个父节点,整棵树只有一个根节点。
3)递归结构,用递归处理二叉树问题可以简化算法。
2.基本操作
1)生成
2)遍历
D-L-R:前序遍历
L-D-R:中序遍历
L-R-D:后序遍历
有序二叉树(二叉搜索树)
L<=D<=R
50 70 20 60 40 30 10 90 80
               50
              /  \
           /--    --\
        20|          70
        /  \        /  \
      10    40    60    90
           /           /
         30          80
        /
      10
中序遍历:10 20 30 40 50 60 70 80 90


  1 #include <iostream>
  2 using namespace std;
  3 // 有序二叉树(二叉搜索树)
  4 class Tree {
  5 public:
  6     // 构造过程中初始化为空树
  7     Tree (void) : m_root (NULL), m_size (0) {}
  8     // 析构过程中销毁剩余节点
  9     ~Tree (void) {
 10         clear ();
 11     }
 12     // 插入数据
 13     void insert (int data) {
 14         insert (new Node (data), m_root);
 15         ++m_size;
 16     }
 17     // 删除第一个匹配数据,不存在返回false
 18     bool erase  (int data) {
 19         Node*& node = find (data, m_root);
 20         if (node) {
 21             // 左插右
 22             insert (node->m_left, node->m_right);
 23             Node* temp = node;
 24             // 右提升
 25             node = node->m_right;
 26             delete temp;
 27             --m_size;
 28             return true;
 29         }
 30         return false;
 31     }
 32     // 删除所有匹配数据
 33     void remove (int data) {
 34         while (erase (data));
 35     }
 36     // 清空树
 37     void clear (void) {
 38         clear (m_root);
 39         m_size = 0;
 40     }
 41     // 将所有的_old替换为_new
 42     void update (int _old, int _new) {
 43         while (erase (_old))
 44             insert (_new);
 45     }
 46     // 判断data是否存在
 47     bool find (int data) {
 48         return find (data, m_root) != NULL;
 49     }
 50     // 中序遍历
 51     void travel (void) {
 52         travel (m_root);
 53         cout << endl;
 54     }
 55     // 获取大小
 56     size_t size (void) {
 57         return m_size;
 58     }
 59     // 获取树高
 60     size_t height (void) {
 61         return height (m_root);
 62     }
 63 private:
 64     // 节点
 65     class Node {
 66     public:
 67         Node (int data) : m_data (data),
 68             m_left (NULL), m_right (NULL) {}
 69         int m_data; // 数据
 70         Node* m_left; // 左树
 71         Node* m_right; // 右树
 72     };
 73     void insert (Node* node, Node*& tree) {
 74         if (! tree)
 75             tree = node;
 76         else if (node) {
 77             if (node->m_data < tree->m_data)
 78                 insert (node, tree->m_left);
 79             else
 80                 insert (node, tree->m_right);
 81         }
 82     }
 83     // 返回子树tree中值与data相匹配的节点的父节点中
 84     // 指向该节点的成员变量的别名
 85     Node*& find (int data, Node*& tree) {
 86         if (! tree)
 87             return tree;
 88         else
 89         if (data == tree->m_data)
 90             return tree;
 91         else
 92         if (data < tree->m_data)
 93             return find (data, tree->m_left);
 94         else
 95             return find (data, tree->m_right);
 96     }
 97     void clear (Node*& tree) {
 98         if (tree) {
 99             clear (tree->m_left);
100             clear (tree->m_right);
101             delete tree;
102             tree = NULL;
103         }
104     }
105     void travel (Node* tree) {
106         if (tree) {
107             travel (tree->m_left);
108             cout << tree->m_data <<  ;
109             travel (tree->m_right);
110         }
111     }
112     size_t height (Node* tree) {
113         if (tree) {
114             size_t lh = height (tree->m_left);
115             size_t rh = height (tree->m_right);
116             return (lh > rh ? lh : rh) + 1;
117         }
118         return 0;
119     }
120     Node* m_root; // 树根
121     size_t m_size; // 大小
122 };
123 int main (void) {
124     Tree tree;
125     tree.insert (50);
126     tree.insert (70);
127     tree.insert (20);
128     tree.insert (60);
129     tree.insert (40);
130     tree.insert (30);
131     tree.insert (10);
132     tree.insert (90);
133     tree.insert (80);
134     tree.travel ();
135     cout << tree.size () <<   << tree.height ()
136         << endl;
137     tree.erase (70);
138     tree.travel ();
139     tree.insert (70);
140     tree.insert (70);
141     tree.insert (70);
142     tree.travel ();
143     tree.remove (70);
144     tree.travel ();
145     tree.insert (40);
146     tree.insert (40);
147     tree.travel ();
148     tree.update (40, 69);
149     tree.travel ();
150     cout << boolalpha << tree.find (50) << endl;
151     cout << tree.find (55) << endl;
152     tree.clear ();
153     tree.travel ();
154     return 0;
155 }

 

Standard C++ Episode 8

标签:

原文地址:http://www.cnblogs.com/libig/p/4746715.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!