## 1. Introduction

## 2. Related Work and Our Contributions

## 3. Generic Algorithm to Determine Maximum Bottleneck Node Weight-Based Data Gathering Trees

#### 3.1. System Model

_{V}, W

_{E}) of a set of vertices (V) and edges (E); the link weights (W

_{E}) may or may not be related to node weights (W

_{V}). The link weights and node weights are positive real numbers. We assume each node in the graph has a weight; if two or more nodes have the same weight during the execution of the algorithms (described in Section 3.2, Section 3.3, Section 3.4 and Section 3.5), ties are broken arbitrarily. We do not anticipate frequently encountering ties, as the node weights (as well as link weights) are real numbers (and not integers). We use higher precisions for the real numbers (of length allowed by the programming environment) in the simulations. In addition, in the simulations, since we run multiple iterations of the algorithms for the same operating condition and average the results, our conjecture is that the arbitrary breaking of the ties is the best way to avoid any bias towards excessive usage of any particular node. For example, if the ties are broken in favor of the node with a smaller ID or larger ID, then such nodes get overused all the time in situations of a tie and the results could be biased.

#### 3.2. Description of the MaxBNW-DG Algorithm

Algorithm 1. Pseudo Code for the Algorithm to Determine Maximum Bottleneck Node Weight-DG Trees. | |

Input: Graph G = (V, E, W_{V}, W_{E}) | |

Output: ${T}_{Max}^{BNW}(V,{E}_{T})$ where E_{T} is the set of edges in the MaxBNW-DG tree | |

Auxiliary Variables: Optimized-Nodes-List, Candidate-Nodes-List, Parent-Node-List | |

Estimated-join-weight, Tree-join-weight, Leader Node | |

Initialization: Optimized-Nodes-List = ϕ; Candidate-Nodes-List = ϕ, Parent-Node-List = ϕ, E_{T} = ϕ | |

$\forall u\in V$: Estimated-join-weight(u) = -1, Tree-join-weight(u) = -1 | |

Begin MaxBNW-DG Algorithm | |

1 | Leader Node s = {u | $\underset{u\in V}{Maximum}({W}_{V}(u))$} |

2 | Parent-Node-List(s) = NULL |

3 | Candidate-Nodes-List = Candidate-Nodes-List $\cup $ {s} |

4 | Estimated-join-weight(s) = W_{V}(s) |

5 | while (Candidate-Nodes-List ≠ ϕ) do |

6 | Node u = {i | $\underset{i\in Candidate-Nodes-List}{Maximum}$ (Estimated-join-weights(i)} |

7 | Candidate-Nodes-List = Candidate-Nodes-List - {u} |

8 | Optimized-Nodes-List = Optimized-Nodes-List $\cup $ {u} |

9 | Tree-join-weight(u) = Estimated-join-weight(u) |

10 | for ( Node v $\in $ Neighbors(u) AND v $\notin $ Optimized-Nodes-List) do |

11 | if (Estimated-join-weight(v) < Minimum(W_{V}(v), Tree-join-weight(u) ) ) then |

12 | Estimated-join-weight(v) = Minimum(W_{V}(v), Tree-join-weight(u) ) |

13 | Parent-Node-List(v) = u |

14 | end if |

15 | end for |

16 | end while |

17 | if (Candidate-Nodes-List = ϕ AND | Optimized-Nodes-List | < | V | ) then |

18 | return NULL; // the graph is not connected |

19 | end if |

20 | if (Candidate-Nodes-List = ϕ AND | Optimized-Nodes-List | = | V | ) then |

21 | for (Node u $\in $ V AND u ≠ Leader Node ) do |

22 | E_{T} = E_{T} $\cup $ {(u, Parent-Node-List(u))} |

23 | end for |

24 | end if |

25 | return ${T}_{Max}^{BNW}(V,{E}_{T})$ |

End MaxBNW-DG Algorithm |

#### 3.3. Modifications to the MaxBNW-DG Algorithm to Determine MinBNW-DG Tree

Algorithm 2. Pseudo Code for the Algorithm to Determine Minimum Bottleneck Node Weight-DG Trees. | |

Input: Graph G = (V, E, W_{V}, W_{E}) | |

Output: ${T}_{Min}^{BNW}(V,{E}_{T})$ where E_{T} is the set of edges in the MaxBNW-DG tree | |

Auxiliary Variables: Optimized-Nodes-List, Candidate-Nodes-List, Parent-Node-List | |

Estimated-join-weight, Tree-join-weight, Leader Node | |

Initialization: Optimized-Nodes-List = ϕ; Candidate-Nodes-List = ϕ, Parent-Node-List = ϕ, E_{T} = ϕ | |

$\forall u\in V$: Estimated-join-weight(u) = ∞, Tree-join-weight(u) = ∞ | |

Begin MaxBNW-DG Algorithm | |

1 | Leader Node s = {u | $Minimum({W}_{V}(u))$} |

2...4 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

5 | while (Candidate-Nodes-List ≠ ϕ) do |

6 | Node u = {i | $\underset{i\in Candidate-Nodes-List}{Minimum}$ (Estimated-join-weights(i)} |

7...8 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

10 | for ( Node v $\in $ Neighbors(u) AND v $\notin $ Optimized-Nodes-List) do |

11 | if (Estimated-join-weight(v) > Maximum(W_{V}(v), Tree-join-weight(u) ) ) then |

12 | Estimated-join-weight(v) = Maximum(W_{V}(v), Tree-join-weight(u) ) |

13 | Parent-Node-List(v) = u |

14 | end if |

15 | end for |

16...24 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

25 | return ${T}_{Min}^{BNW}(V,{E}_{T})$ |

End MinBNW-DG Algorithm |

#### 3.4. Modifications to the MaxBNW-DG Algorithm to Determine the MaxBLW-DG Tree

Algorithm 3. Pseudo Code for the Algorithm to Determine Minimum Bottleneck Node Weight-DG Trees. | |

Input: Graph G = (V, E, W_{V}, W_{E}) | |

Output: ${T}_{Max}^{BLW}(V,{E}_{T})$ where E_{T} is the set of edges in the MaxBNW-DG tree | |

Auxiliary Variables: Optimized-Nodes-List, Candidate-Nodes-List, Parent-Node-List | |

Estimated-join-weight, Tree-join-weight, Leader Node | |

Initialization: Optimized-Nodes-List = ϕ; Candidate-Nodes-List = ϕ, Parent-Node-List = ϕ, E_{T} = ϕ | |

$\forall u\in V$: Estimated-join-weight(u) = -1, Tree-join-weight(u) = -1 | |

Begin MaxBNW-DG Algorithm | |

1 | Leader Node s is arbitrarily chosen among the vertices in V |

2...3 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

4 | Estimated-join-weight(s) = ∞ |

5 | while (Candidate-Nodes-List ≠ ϕ) do |

6 | Node u = {i | $\underset{i\in Candidate-Nodes-List}{Maximum}$ (Estimated-join-weights(i)} |

7...9 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

10 | for ( Node v $\in $ Neighbors(u) AND v $\notin $ Optimized-Nodes-List) do |

11 | if (Estimated-join-weight(v) < W_{E}(u-v)) then |

12 | Estimated-join-weight(v) = W_{E}(u-v) |

13 | Parent-Node-List(v) = u |

14 | end if |

15 | end for |

16...24 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

25 | return ${T}_{Max}^{BLW}(V,{E}_{T})$ |

End MaxBNW-DG Algorithm |

#### 3.5. Modifications to the MaxBNW-DG Algorithm to Determine the MinBLW-DG Tree

Algorithm 4. Pseudo Code for the Algorithm to Determine Minimum Bottleneck Node Weight-DG Trees. | |

Input: Graph G = (V, E, W_{V}, W_{E}) | |

Output: ${T}_{Min}^{BLW}(V,{E}_{T})$ where E_{T} is the set of edges in the MinBNW-DG tree | |

Auxiliary Variables: Optimized-Nodes-List, Candidate-Nodes-List, Parent-Node-List | |

Estimated-join-weight, Tree-join-weight, Leader Node | |

Initialization: Optimized-Nodes-List = ϕ; Candidate-Nodes-List = ϕ, Parent-Node-List = ϕ, E_{T} = ϕ | |

$\forall u\in V$: Estimated-join-weight(u) = ∞, Tree-join-weight(u) = ∞ | |

Begin MinBNW-DG Algorithm | |

1 | Leader Node s is arbitrarily chosen among the vertices in V |

2...3 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

4 | Estimated-join-weight(s) = -∞ |

5 | while (Candidate-Nodes-List ≠ ϕ) do |

6 | Node u = {i | $\underset{i\in Candidate-Nodes-List}{Minimum}$ (Estimated-join-weights(i)} |

7...9 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

10 | for ( Node v $\in $ Neighbors(u) AND v $\notin $ Optimized-Nodes-List) do |

11 | if (Estimated-join-weight(v) > W(u-v)) _{E}then |

12 | Estimated-join-weight(v) = W_{E}(u-v) |

13 | Parent-Node-List(v) = u |

14 | end if |

15 | end for |

16...24 | (as in the pseudo code for the MaxBNW-DG algorithm, refer Algorithm 1) |

25 | return ${T}_{Min}^{BLW}(V,{E}_{T})$ |

End MaxBNW-DG Algorithm |

## 4. Algorithms to Determine the Diameter of the DG Tree and Minimum Delay for Data Aggregation

#### 4.1. Algorithm to Determine Diameter of a Data Gathering Tree

#### 4.2. Algorithm to Determine the Minimum Aggregation Delay of a Data Gathering Tree

Algorithm 5. Pseudo Code for an Algorithm to Determine the Diameter of a Data Gathering Tree. | |

Input: DG Tree ${T}_{Max}^{BNW}(V,{E}_{T})$, Leader Node s | |

Output: Diameter, Nodes-At-Levels, Child-Nodes-List | |

Auxiliary Variables: Nodes-Explored; Candidate-Nodes-List, Child-Nodes-List; | |

Neighbor-List; Node-Level | |

Initialization: $\forall i\in V$: Neighbor-List[i] = ϕ, Node-Level[i] = 0; Child-Nodes-List[i] = ϕ | |

Nodes-At-Levels = ϕ; Diameter = 0; Nodes-Explored = ϕ; Candidate-Nodes-List = ϕ | |

Begin Algorithm Diameter-DG Tree | |

1 | for (edge (u, v) $\in $ E_{T}) do |

2 | Neighbor-List[u] = Neighbor-List[u] $\cup $ {v} |

3 | Neighbor-List[v] = Neighbor-List[v] $\cup $ {u} |

4 | end for |

5 | Candidate-Nodes-List = {s} |

6 | Node-Level[s] = 0 |

7 | Nodes-At-Levels[0].add({s}) // adds the leader node s to the list of nodes at level 0 |

8 | Nodes-Explored = Nodes-Explored $\cup $ {s} |

9 | while (Candidate-Nodes-List ≠ ϕ) do |

10 | Node u = Dequeue(Candidate-Nodes-List) // removes u from Candidate-Nodes-List |

11 | for ( Node v $\in $ Neighbor-List(u) AND v $\notin $ Nodes-Explored) do |

12 | Node-Level[v] = Node-Level[u] + 1 |

13 | Nodes-At-Levels[Node-Level[v]].add({v}) |

14 | Child-Nodes-List(u) = Child-Nodes-List(u) $\cup $ {v} |

15 | Nodes-Explored = Nodes-Explored $\cup $ {v} |

16 | Candidate-Nodes-List = Candidate-Nodes-List $\cup $ {v} |

17 | if (Diameter < Node-Level[v]) then |

18 | Diameter = Node-Level[v] |

19 | end if |

20 | end for |

21 | end while |

22 | return Diameter, Nodes-At-Levels, Child-Nodes-List |

End Algorithm Diameter-DG Tree |

#### 4.3. Time Complexity and Proof of Correctness

Algorithm 6. Pseudo Code for an Algorithm to Determine the Minimum Aggregation Delay of a Data Gathering Tree. | |

Input: Diameter, Nodes-At-Levels, Child-Nodes-List, Leader Node s | |

Output: Delay[s] | |

Auxiliary Variables: Temp-Delay; Sorted-Delay-Child-Nodes | |

Initialization: $\forall i\in V$: Delay[i] = 0, Temp-Delay[i] = 0, Sorted-Delay-Child-Nodes[i] = ϕ | |

Begin Algorithm Aggregation-Delay-DG Tree | |

1 | for (Node-level = Diameter to 0) do |

2 | for (Node u $\in $ Nodes-At-Levels.get(Node-level) ) do |

3 | for (Node v $\in $ Child-Nodes-List[u]) do |

4 | Insert (v, Delay[v]) at appropriate entry in Sorted-Delay-Child-Nodes[u] |

5 | end for |

6 | for (tuple (v, Delay[v]) in Sorted-Delay-Child-Nodes[u]) do |

7 | Temp-Delay[u] = Maximum(Temp-Delay[u] + 1, Delay[v] + 1) |

8 | end for |

9 | Delay[u] = Temp-Delay[u] |

10 | end for |

11 | end for |

12 | return Delay[s]End Algorithm Aggregation-Delay-DG Tree |

#### 4.4. Examples to Compute the Minimum Aggregation Delay of Data Gathering Trees

## 5. Simulations

^{2}/A, where R is the transmission range and A is the network area. We consider the 50-node network to be of moderate to high node density (20 to 40 neighbors per node on average) and the 100-node network to be of high to very high node density (40 to 80 neighbors per node on average).

#### 5.1. Performance Metrics

- (i)
- Diameter of the DG Tree—The maximum distance (number of hops) from any leaf node to the root node of the DG tree.
- (ii)
- Minimum Aggregation Delay—The minimum number of time slots it takes for the data to get aggregated, starting from the leaf nodes and propagating to the root node of the DG tree
- (iii)
- Hop Count per Path—The average of the number of hops per path from every node (other than the root node) to the root node of the DG tree.
- (iv)
- Number of Child Nodes per Intermediate Node—The average of the number of immediate child nodes per intermediate node, considered across all the intermediate nodes (including the root node) of the DG tree.
- (v)
- Fraction of Nodes as Leaf Nodes—The ratio of the total number of leaf nodes (nodes without any child nodes) at all levels divided by the total number of nodes in the network.

#### 5.2. MaxBNW-DG Trees vs. MinBNW-DG Trees and MaxBLW-DG Trees vs. MinBLW-DG Trees

#### 5.3. Discussion of the Results

#### 5.4. Margin of Error for Minimum Aggregation Delay

_{s}is the number of samples collected (200 graph snapshots). If $\overline{x}$ is the average value of the n

_{s}samples collected for the minimum aggregation delay under a particular operating condition, then one could say that the range of values for the minimum aggregation delay is $\left(\overline{x}-z*\sigma /\sqrt{{n}_{s}},\mathrm{...},\overline{x}+z*\sigma /\sqrt{{n}_{s}}\right)$ with a probability of 0.95 (95% confidence interval; z-score is 1.96).

#### 5.5. Performance Tradeoffs

#### 5.6. Impact of the Algorithm Design Choices on the Structure of the DG Trees and their Performance

## 6. Conclusions and Future Work

## Acknowledgments

## Conflicts of Interest

## References

- Heinzelman, W.R.; Chandrakasan, A.; Balakarishnan, H. Energy-Efficient Communication Protocols for Wireless Microsensor Networks. In Proceedings of the Hawaiian International Conference on Systems Science, Maui, HI, USA, 4–7 January 2000; p. 8020.
- Meghanathan, N. Grid Block Energy based Data Gathering Algorithms for Wireless Sensor Networks. Int. J. Commun. Netw. Inf. Secur.
**2010**, 2, 151–161. [Google Scholar] - Lindsey, S.; Raghavendra, C.; Sivalingam, K.M. Data Gathering Algorithms in Sensor Networks using Energy Metrics. IEEE Trans. Parallel Distrib. Syst.
**2002**, 13, 924–935. [Google Scholar] [CrossRef] - Meghanathan, N. A Data Gathering Algorithm based on Energy-aware Connected Dominating Sets to Minimize Energy Consumption and Maximize Node Lifetime in Wireless Sensor Networks. Int. J. Interdiscip. Telecommun. Netw.
**2010**, 2, 1–17. [Google Scholar] [CrossRef] - Meghanathan, N. A Comprehensive Review and Performance Analysis of Data Gathering Algorithms for Wireless Sensor Networks. Int. J. Interdiscip. Telecommun. Netw.
**2012**, 4, 1–29. [Google Scholar] [CrossRef] - Lindsey, S.; Raghavendra, C.; Sivalingam, K.M. Data Gathering in Sensor Networks using the Energy*Delay Metric. In Proceedings of the 15th International Parallel and Distributed Processing Symposium, San Francisco, CA, USA, 23–27 April 2001; pp. 2001–2008.
- Liang, J.; Wang, J.; Cao, J.; Chen, J.; Lu, M. An Efficient Algorithm for Constructing Maximum Lifetime Tree for Data Gathering without Aggregation in Wireless Sensor Networks. In Proceedings of the 29th IEEE Conference on Computer Communications, San Diego, CA, USA, 15–19 March 2010; pp. 1–5.
- Huang, S.C.; Wan, P.-J.; Vu, C.T.; Li, Y.; Yao, F. Nearly Constant Approximation for Data Aggregation Scheduling in Wireless Sensor Networks. In Proceedings of the 26th IEEE International Conference on Computer Communications, Anchorage, AK, USA, 6–12 May 2007; pp. 366–372.
- Wan, P.-J.; Huang, S.C.-H.; Wang, L.; Wan, Z.; Jia, X. Minimum-Latency Aggregation Scheduling in Multi-hop Wireless Networks. In Proceedings of the 10th ACM International Symposium on Mobile Ad hoc Networking and Computing, New Orleans, LA, USA, 18–21 May 2009; pp. 185–194.
- Yu, B.; Li, J. Minimum-Time Aggregation Scheduling in Multi-Sink Sensor Networks. In Proceedings of the 8th IEEE Conference on Sensor, Mesh and Ad hoc Communications and Networks, Salt Lake City, UT, USA, 27–30 June 2011; pp. 422–430.
- Li, Y.; Guo, L.; Prasad, S.K. An Energy-Efficient Distributed Algorithm for Minimum-Latency Aggregation Scheduling in Wireless Sensor Networks. In Proceedings of the 30th IEEE International Conference on Distributed Computing Systems, Genova, Italy, 21–25 June 2010; pp. 827–836.
- Xu, X.; Li, X.-Y.; Mao, X.; Tang, S.; Wang, S. A Delay-Efficient Algorithm for Data Aggregation in Multi-hop Wireless Sensor Networks. IEEE Trans. Parallel Distrib. Syst.
**2011**, 22, 163–175. [Google Scholar] - Yu, B.; Li, J.; Li, Y. Distributed Data Aggregation Scheduling in Wireless Sensor Networks. In Proceedings of the 28th IEEE International Conference on Computer Communications, Rio de Janeiro, Brazil, 19–25 April 2009; pp. 2159–2167.
- Viterbi, A.J. CDMA: Principles of Spread Spectrum Communication, 1st ed.; Prentice Hall: Upper Saddle River, NJ, USA, 1995. [Google Scholar]
- Wu, Y.; Fahmy, S.; Shroff, N.B. On the Construction of a Maximum Lifetime Data Gathering Tree in Sensor Networks: NP-Completeness and Approximation Algorithm. In Proceedings of the 27th IEEE Conference on Computer Communications, Phoenix, AZ, USA, 13–18 April 2008; pp. 1013–1021.
- Meghanathan, N. An Algorithm to Determine Energy-aware Maximal Leaf Nodes Data Gathering Tree for Wireless Sensor Networks. J. Theor. Appl. Inform. Technol.
**2010**, 15, 96–107. [Google Scholar] - Meghanathan, N.; Mumford, P. Centralized and Distributed Algorithms for Stability-based Data Gathering in Mobile Sensor Networks. Macrothink Netw. Protoc. Algorithms
**2013**, 5, 84–116. [Google Scholar] [CrossRef] - Meghanathan, N. A Pair-wise Key Distribution Mechanism and Distributed Trust Evaluation Model for Secure Data Aggregation in Mobile Sensor Networks. Int. J. Comb. Optim. Probl. Inform.
**2014**, 5, 29–46. [Google Scholar] - Xie, R.; Jia, X. Minimum Transmission Data Gathering Trees for Compressive sensing in Wireless Sensor Networks. In Proceedings of the IEEE Global Telecommunications Conference, Houston, TX, USA, 5–9 December 2011; pp. 1–5.
- Ramanan, K.; Baburaj, E. Data Gathering Algorithms for Wireless Sensor Networks: A Survey. Int. J. Ad hoc Sens. Ubiquitous Comput.
**2010**, 1, 102–114. [Google Scholar] [CrossRef] - Li, H.; Hua, Q.S.; Wu, C.; Lau, F.C.M. Minimum-Latency Aggregation Scheduling in Wireless Sensor Networks under Physical Interference Model. In Proceedings of the 13th ACM International Conference on Modeling, Analysis, and Simulation of Wireless and Mobile Systems, Bodrum, Turkey, 17–21 October 2010; pp. 360–367.
- Yu, Y.; Krishnamachari, B.; Prasanna, V.K. Energy-Latency Tradeoffs for Data Gathering in Wireless Sensor Networks. In Proceedings of the 23rd IEEE Conference on Computer Communications, Hong Kong, China, 7–11 March 2004; pp. 244–255.
- Ammari, H.M.; Das, S.K. Trade-off between Energy Savings and Source-to-Sink Delay in Data Dissemination for Wireless Sensor Networks. In Proceedings of the 8th ACM International Symposium on Modeling, Analysis and Simulation of Wireless and Mobile Systems, Montreal, QC, Canada, 10–13 October 2005; pp. 126–133.
- Ballister, P.; Bollobas, B.; Anandkumar, A.; Willsky, A. Energy-Latency Tradeoff for In-Network Function Computation in Random Networks. In Proceedings of the 23rd IEEE Conference on Computer Communications, Shanghai, China, 10–15 April 2011; pp. 1575–1583.
- Li, H.; Wu, C.; Yu, D.; Hua, Q.-S.; Lau, F.C.M. Aggregation Latency-Energy Tradeoff in Wireless Sensor Networks with Successive Interference Cancellation. IEEE Trans. Parallel Distrib. Syst.
**2013**, 24, 2160–2170. [Google Scholar] [CrossRef][Green Version] - Cormen, T.H.; Leiserson, C.E.; Rivest, R.L.; Stein, C. Introduction to Algorithms, 3rd edition; MIT Press: Cambridge, MA, USA, 2009. [Google Scholar]
- Meghanathan, N. Graph Theory Algorithms for Mobile Ad hoc Networks. Inform. Int. J. Comput. Inform.
**2012**, 36, 185–200. [Google Scholar] - Demirkol, I.; Ersoy, C.; Alagoz, F. MAC Protocols for Wireless Sensor Networks: A Survey. IEEE Commun. Magazine
**2006**, 44, 115–121. [Google Scholar] [CrossRef] - Stojmenovic, I. Simulations in Wireless Sensor and Ad hoc Networks: Matching and Advancing Models, Metrics, and Solutions. IEEE Commun. Magazine
**2008**, 46, 102–107. [Google Scholar] [CrossRef] - Cagalj, M.; Phubaux, J.; Enz, C. Minimum-Energy Broadcast in All-Wireless Networks: NP-Completeness and Distribution Issues. In Proceedings of the 8th annual international conference on Mobile computing and networking, Atlanta, GA, USA, 23–28 September 2002; pp. 172–182.
- Wieselthier, E.; Nguyen, G.D.; Ephremides, A. Energy-Efficient Broadcast and Multicast Trees in Wireless Networks. Mob. Netw. Appl.
**2002**, 7, 481–492. [Google Scholar] [CrossRef] - Williams, B.; Camp, T. Comparison of Broadcasting Techniques for Mobile Ad hoc Networks. In Proceedings of the 3rd ACM International Symposium on Mobile Ad hoc Networking and Computing, Lausanne, Switzerland, 9–11 June 2002; pp. 194–205.
- Keshavarz, A.H.; Ribeiro, V.; Riedi, R. Color-Based Broadcasting for Ad Hoc Networks. In Proceedings of the 4th International Symposium on Modeling and Optimization in Mobile, Boston, MA, USA, 3–6 April 2006; pp. 1–10.
- Meghanathan, N. Stability-based and Energy-Efficient Distributed Data Gathering Algorithms for Mobile Sensor Networks. Ad hoc Netw.
**2014**, 19, 111–131. [Google Scholar] [CrossRef]

© 2015 by the authors; licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution license (http://creativecommons.org/licenses/by/4.0/).