C#實現二叉樹--二叉連結串列結構

阿新 • • 發佈：2019-01-14

  1 /// <summary>
  2     /// 二叉搜尋樹：結點的左子節點的值永遠小於該結點的值，而右子結點的值永遠大於該結點的值 稱為二叉搜尋樹
  3     /// </summary>
  4     public class LinkBinarySearchTree : LinkBinaryTree<indexnode>
  5     {
  6         //定義增加結點的方法
  7         public void insert(indexnode element)
  8         {
  9             TreeNode<indexnode> tmp, parent = null 
, currentNode = null;
 10             //呼叫FIND方法
 11             find(element, ref parent, ref currentNode);
 12             if (currentNode != null)
 13             {
 14                 Console.WriteLine("Duplicates words not allowed");
 15                 return;
 16             }
 17             else 

 18             {
 19                 //建立結點
 20                 tmp = new TreeNode<indexnode>(element);
 21                 if (parent == null)
 22                     Head = tmp;
 23                 else
 24                 {
 25                     if (element.Key < parent.Data.Key)
 
 26                         parent.LChild = tmp;
 27                     else
 28                         parent.RChild = tmp;
 29                 }
 30             }
 31         }
 32 
 33         //定義父結點
 34         public void find(indexnode element, ref TreeNode<indexnode> parent, ref TreeNode<indexnode> currentNode)
 35         {
 36             currentNode = Head;
 37             parent = null;
 38             while ((currentNode != null) && (currentNode.Data.Key.ToString() != element.Key.ToString()) && (currentNode.Data.Offset .ToString() != element.Offset .ToString()))//
 39             {
 40                 parent = currentNode;
 41                 if (element.Key < currentNode.Data.Key)
 42                     currentNode = currentNode.LChild;
 43                 else
 44                     currentNode = currentNode.RChild;
 45             }
 46         }
 47 
 48         //定位結點
 49         public void find(int key)
 50         {
 51             TreeNode<indexnode> currentNode = Head;
 52             while ((currentNode != null) && (currentNode.Data.Key.ToString () != key.ToString ()))
 53             {
 54                 Console.WriteLine(currentNode.Data.Offset.ToString());
 55                 if (key < currentNode.Data.Key)
 56                     currentNode = currentNode.LChild;
 57                 else
 58                     currentNode = currentNode.RChild;
 59             }
 60         }
 61 
 62         //中序遍歷
 63         //遍歷根結點的左子樹->根結點->遍歷根結點的右子樹 
 64         public void inorderS(TreeNode<indexnode> ptr)
 65         {
 66             if (IsEmpty())
 67             {
 68                 Console.WriteLine("Tree is Empty !");
 69                 return;
 70             }
 71             if (ptr != null)
 72             {
 73                 inorderS(ptr.LChild);
 74                 Console.WriteLine(ptr.Data.Key  + " ");
 75                 inorderS(ptr.RChild);
 76             }
 77         }
 78 
 79 
 80         //先序遍歷
 81         //根結點->遍歷根結點的左子樹->遍歷根結點的右子樹 
 82         public void preorderS(TreeNode<indexnode> ptr)
 83         {
 84             if (IsEmpty())
 85             {
 86                 Console.WriteLine("Tree is Empty !");
 87                 return;
 88             }
 89             if (ptr != null)
 90             {
 91                 Console.WriteLine(ptr.Data.Key  + " ");
 92                 preorderS(ptr.LChild);
 93                 preorderS(ptr.RChild);
 94             }
 95         }
 96 
 97 
 98         //後序遍歷
 99         //遍歷根結點的左子樹->遍歷根結點的右子樹->根結點
100         public void postorderS(TreeNode<indexnode> ptr)
101         {
102             if (IsEmpty())
103             {
104                 Console.WriteLine("Tree is Empty !");
105                 return;
106             }
107             if (ptr != null)
108             {
109                 postorderS(ptr.LChild);
110                 postorderS(ptr.RChild);
111                 Console.WriteLine(ptr.Data.Key + "");
112             }
113         }
114     }
115 
116 
117     /// <summary>
118     /// 迴圈順序佇列
119     /// </summary>
120     /// <typeparam name="T"></typeparam>
121     class CSeqQueue<T>
122     {
123         private int maxsize;       //迴圈順序佇列的容量
124         private T[] data;          //陣列，用於儲存迴圈順序佇列中的資料元素
125         private int front;         //指示最近一個已經離開佇列的元素所佔有的位置 迴圈順序佇列的對頭
126         private int rear;          //指示最近一個進入佇列的元素的位置           迴圈順序佇列的隊尾
127 
128         public T this[int index]
129         {
130             get { return data[index]; }
131             set { data[index] = value; }
132         }
133 
134         //容量屬性
135         public int Maxsize
136         {
137             get { return maxsize; }
138             set { maxsize = value; }
139         }
140 
141         //對頭指示器屬性
142         public int Front
143         {
144             get { return front; }
145             set { front = value; }
146         }
147 
148         //隊尾指示器屬性
149         public int Rear
150         {
151             get { return rear; }
152             set { rear = value; }
153         }
154 
155         public CSeqQueue()
156         {
157 
158         }
159 
160         public CSeqQueue(int size)
161         {
162             data = new T[size];
163             maxsize = size;
164             front = rear = -1;
165         }
166 
167         //判斷迴圈順序佇列是否為滿
168         public bool IsFull()
169         {
170             if ((front == -1 && rear == maxsize - 1) || (rear + 1) % maxsize == front)
171                 return true;
172             else
173                 return false;
174         }
175 
176         //清空迴圈順序列表
177         public void Clear()
178         {
179             front = rear = -1;
180         }
181 
182         //判斷迴圈順序佇列是否為空
183         public bool IsEmpty()
184         {
185             if (front == rear)
186                 return true;
187             else
188                 return false;
189         }
190 
191         //入隊操作
192         public void EnQueue(T elem)
193         {
194             if (IsFull())
195             {
196                 Console.WriteLine("Queue is Full !");
197                 return;
198             }
199             rear = (rear + 1) % maxsize;
200             data[rear] = elem;
201         }
202 
203         //出隊操作
204         public T DeQueue()
205         {
206             if (IsEmpty())
207             {
208                 Console.WriteLine("Queue is Empty !");
209                 return default(T);
210             }
211             front = (front + 1) % maxsize;
212             return data[front];
213         }
214 
215         //獲取對頭資料元素
216         public T GetFront()
217         {
218             if (IsEmpty())
219             {
220                 Console.WriteLine("Queue is Empty !");
221                 return default(T);
222             }
223             return data[(front + 1) % maxsize];//front從-1開始
224         }
225 
226         //求迴圈順序佇列的長度
227         public int GetLength()
228         {
229             return (rear - front + maxsize) % maxsize;
230         }
231     }

Leetcode 114. 二叉樹展開為連結串列 C++

文章目錄題目描述遞迴法方法一方法二非遞迴法題目描述遞迴法方法一這種方法，不太容易理解。第一步就是遞迴，後面才是對基本情況的處理。通過遞迴，直接

使用java實現二叉樹的三叉連結串列儲存

二叉連結串列和三叉連結串列實現二叉樹的儲存不同之處在於，三叉連結串列中的每一個結點多了一個指向父節點的區域，其他的地方和二叉連結串列沒有什麼區別，實現的思路和二叉連結串列一致，這裡就不再贅述了，詳情可以看上一篇二叉連結串列實現二叉樹儲存。直接上程式碼，不多BB

[leetcode] 114. 二叉樹展開為連結串列

114. 二叉樹展開為連結串列這個題描述不清啊一開始看描述每太明白題意，對著給出的樣例做的實際上就是：將右子樹接到左子樹的最右邊的葉子節點上將左子樹接到root的右兒子上把root的左兒子置空 class Solution { public void

Leetcode:114. 二叉樹展開為連結串列

給定一個二叉樹，原地將它展開為連結串列。例如，給定二叉樹 1 / \ 2 5 / \ \ 3 4 6 將其展開為： 1 \ 2 \ 3 \ 4 \ 5 \

劍指Offer36：二叉樹與雙向連結串列的轉換

題目：輸入一顆二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的節點，只能調整樹中節點指標的指向。例如：分析過程： 1.指標的調整：原先指向左子節點的指標，變成指向上一節點的指標原先指向右子節點的指標，變成指向下一節點的指標 2.調整思路：對於

leeetcode 114 將二叉樹展開成連結串列

給定一個二叉樹，原地將它展開為連結串列。思路是先利用DFS的思路找到最左子節點，然後回到其父節點，把其父節點和右子節點斷開，將原左子結點連上父節點的右子節點上，然後再把原右子節點連到新右子節點的右子節點上，然後再回到上一父節點做相同操作。 public void flatten(TreeN

劍指offer題解（二叉樹與雙向連結串列）

題目描述輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。解題思路中序遍歷搜尋二叉樹，用pre儲存中序遍歷的前一個節點，cur為當前節點，然後使pre->right=cu

LeetCode-114.二叉樹展開為連結串列（相關話題：深度優先）

給定一個二叉樹，原地將它展開為連結串列。例如，給定二叉樹 1 / \ 2 5 / \ \ 3 4 6 將其展開為： 1 \ 2 \ 3 \ 4 \ 5

leetcode 114. 二叉樹展開為連結串列(Flatten Binary Tree to Linked List)

給定一個二叉樹，原地將它展開為連結串列。例如，給定二叉樹 1 / \ 2 5 / \ \ 3 4 6 將其展開為： 1 \ 2 \ 3 \ 4 \ 5

Leetcode 114.二叉樹展開為連結串列

二叉樹展開為連結串列給定一個二叉樹，原地將它展開為連結串列。例如，給定二叉樹 1 / \ 2 5 / \ \ 3 4 6 將其展開為： 1 \ 2 \ 3 \ 4 \ 5 \ 6

【多次過】Lintcode 453. 將二叉樹拆成連結串列

將一棵二叉樹按照前序遍歷拆解成為一個假連結串列。所謂的假連結串列是說，用二叉樹的 right指標，來表示連結串列中的 next 指標。樣例 1 \ 1 2 / \

[LeetCode] Flatten Binary Tree to Linked List 將二叉樹展開成連結串列

Given a binary tree, flatten it to a linked list in-place. For example,Given 1 / \ 2 5 / \ \ 3 4 6

搜素二叉樹的權值為某值的路徑+二叉樹變雙向連結串列

搜素二叉樹的權值為某值的路徑 void findPath(node *root,int expect,int current,vector<int> &path) { if(root!=NULL) { current +

【劍指offer】搜尋二叉樹與雙向連結串列

題目描述輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。 class Solution { public: TreeNode* Convert(TreeNode* pRootOfTree) {

面試題怎麼將二叉樹轉化為連結串列

#include<iostream> #include<stdlib.h> using namespace std; struct BinaryTreeNode { int m_nValue; BinaryTreeNode* m_pLeft; Binary

【LeetCode 中等題】54-二叉樹展開為連結串列

題目描述：給定一個二叉樹，原地將它展開為連結串列。例如，給定二叉樹 1 / \ 2 5 / \ \ 3 4 6 將其展開為： 1 \ 2 \ 3 \ 4 \ 5

二叉樹之線索連結串列

上一章介紹了二叉樹的二叉連結串列的實現，並給出了相關遍歷演算法，但是，當以二叉連結串列作為二叉樹的儲存結構時，無法直接得到結點在任一序列中的前驅與後繼資訊。為了規避這個弊端，本章將引入線索二叉樹的概念，並給出相關Java實現。為了得到前驅與後繼的資

資料結構--二叉樹（線索連結串列）

//// Threaded Binary Tree.cpp : Defines the entry point for the console application. /*-----CODE FOR FUN--------------- -------CREATED BY

C++實現兩個已經排序的連結串列進行合併

//定義兩個同種單向連結串列,包含一個整數值和一個指向本節點的型別的指標,該連結串列中的資料都已經排好序 //編制程式,合併兩個連結串列 #include<iostream.h> #include<iomanip.h> struct Node {in

劍指offer66題--Java實現，c++實現和python實現 26.二叉搜尋樹與雙向連結串列

題目描述輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。 C++ /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *ri

C#實現二叉樹--二叉連結串列結構

相關推薦