Constructing Maximum-Lifetime Data-Gathering Tree in WSNs Based on Compressed Sensing

Abstract

Data gathering is one of the most important operations in many wireless sensor networks (WSNs) applications. In order to implement data gathering, a tree structure rooted at the sink is usually defined. In most wireless sensor networks, nodes are powered by batteries with limited energy. Prolonging network lifetime is a critical issue for WSNs. As a technique for signal processing, compressed sensing (CS) is being increasingly applied to wireless sensor networks for saving energy. Compressive sensing can reduce the number of data transmissions and balance the traffic load throughout networks. In this paper, we investigate data gathering in wireless sensor networks using CS and aim at constructing a maximum-lifetime data-gathering tree. The lifetime of the network is defined as the number of data-gathering rounds until the first node depletes its energy. Based on the hybrid-CS data-gathering model, we first construct an arbitrary data-gathering tree and then use the random switching decision and optimal parent node selecting strategy to adjust the load of the bottleneck node and prolong the network lifetime. Simulation results show that the proposed algorithm outperforms several existing approaches in terms of network lifetime.

1. Introduction

Wireless sensor networks (WSNs) consist of a great number of nodes that sense the environment and collaboratively work to process and route the sensory data. They have a great application value in the fields of habitat monitoring, medical care, battlefield monitoring, and so on. Data gathering is a basic operation in WSNs, where sensors are responsible for collecting all sensory data and delivering them to the sink node [1]. Typically, sensors have strictly limited communication abilities and energy resources; therefore, how to reduce energy consumption in data gathering so as to prolong network lifetime is an important issue [2].

The problem of energy efficient data gathering in WSNs has been extensively investigated. Data-gathering methods based on cluster and tree are proposed in many literatures [3, 4]. The goal of such methods is to construct a network topology in order to use energy resources of sensor node effectively. However, these methods cannot overcome the “hot pot” problem; that is, nodes close to the sink would suffer from heavy loads and their energy would be exhausted soon, which would shorten the network lifetime. Data aggregation [5] and source coding technique [6] are two efficient methods to overcome the “hot pot” problem. However, data aggregation adopts a simple aggregation function that only extracts certain statistical information from the sensory data. The sink node cannot recover all sensory data. Hence, this technique can only be applied to particular applications that require partial information from WSNs. The distributed source coding technique performs noncollaborative data compression at the source nodes; it is not exactly practical in WSNs either due to the lack of prior knowledge of the data correlation or because of resulting in high communication load.

Compressed sensing is a signal processing technique for efficiently acquiring and reconstructing a signal, by finding solutions to underdetermined linear systems [7]. This technique promises to successfully recover the original signal from far fewer measurements than its original dimension, as long as the signal is sparse or compressible in some domain. Recently, the growing interest in CS has inspired many works in WSNs [8–11]. Many researches show that the CS technique suits well data gathering in WSNs because the sensory data is generally quite sparse in nature [8]. The authors in [12] made the first effort to speculate the potential of using CS theory for data gathering in multihop WSNs. However, they have not proposed a real scheme based on this initial idea. The authors in [8] firstly presented a complete framework for data gathering based on CS in large-scale WSNs where a large number of sensor nodes are densely deployed and sensor readings are spatially correlated. In Compressive Data Gathering (CDG) proposed in [8], the sensory data are transmitted as weighted sums on a routing path so as to reduce global communication cost without introducing intensive computation or complicated transmission control. However, CDG can result in many unnecessary data transmissions during data-gathering procedure.

In [13], the authors introduced two data-gathering models, that is, plain-CS and hybrid-CS. The plain-CS model which is the same as the CDG scheme uses CS encoding for all nodes in the network. The hybrid-CS model applies CS only to relay nodes that are overloaded. The hybrid-CS model marries the merits of nonaggregation data gathering and plain-CS scheme. Recently, Xiang et al. in [14] introduced a Minimum Energy Compressed Data Aggregation (MECDA) algorithm to implement the data gathering in WSNs based on hybrid-CS technique. The aim of MECDA is to allocate the traffic load properly in a given data-gathering round, through joint routing and aggregator assignment, such that the total energy consumption is minimized. Unfortunately, MECDA only takes into account the overall energy consumption of sensor network and does not consider balancing the energy consumption of each node; therefore, the energy of some sensor nodes may be exhausted quickly, which will affect the network lifetime eventually. Therefore, it is significant for the researchers to design a maximum-lifetime data-gathering method which balances the energy consumption of sensor nodes by using CS theory in designing of underlying routing.

In this paper, we propose a method of constructing maximum-lifetime data-gathering tree (MLDGT) in WSNs based on the hybrid-CS data-gathering model. The contributions of this paper are as follows:

• (1)

We first define the problem of maximum-lifetime data-gathering tree in WSNs based on compressed sensing, prove that it is NP-complete, and then analyze the characterizations of the optimal solutions.

(2)

We propose a novel algorithm, which used random switching and optimal parent node selecting strategy to keep transferring descendants of bottleneck node to realize load balancing and extending the lifetime of WSNs.

(3)

Extensive experiments have been conducted to verify that our algorithm achieves higher lifetime than existing approaches.

The rest of the paper is organized as follows. In Section 2, we give a brief overview of applying compressed sensing in data gathering of WSNs. Section 3 formally defines the problem of maximum-lifetime data-gathering tree and analyzes the complexity of the problem. The proposed algorithms are detailed and analyzed in Section 4. Simulation results are presented in Section 5 and conclusions are drawn in Section 6.

2. Preliminaries

2.1. Compressed Sensing Basics

In CS framework, the real-valued signal $\mathbf{X}\in {\mathbb{R}}^N$ can be reconstructed from a far fewer measurements than its original dimension N as long as the signal X is sparse or compressible in a certain domain. Let $\mathbf{X}=[x_{\mathrm{1}},x_{\mathrm{2}},\dots ,x_N{]}^T$ be N-dimensional original data that can be represented in some orthonormal basis $\mathit{\Psi }=\{{\mathbf{\psi }}_i{\}}_{i=\mathrm{1}}^N\hspace{0.17em}\hspace{0.17em}(\mathrm{l}\mathrm{e}\mathrm{t}\hspace{0.17em}\hspace{0.17em}{\mathbf{\psi }}_i$ be N-dimensional column vector) as $\mathbf{X}={\sum }_{i=\mathrm{1}}^N{\theta }_i{\mathbf{\psi }}_i=\mathit{\Psi }\mathbf{\theta }$ . If the coefficient vector $\mathbf{\theta }=[{\theta }_{\mathrm{1}},{\theta }_{\mathrm{2}},\dots ,{\theta }_N{]}^T$ is k-sparse, that is, there are only k ( $k\ll N$ ) nonzero entries in vector $\mathbf{\theta }$ , the signal is k-sparse in basis $\mathit{\Psi }$ . Let $\mathbf{\Phi }=[{\varphi }_{\mathrm{1}},{\varphi }_{\mathrm{2}},\dots ,{\varphi }_N]$ be the $M\times N$ -dimensional measurement matrix whose row vectors are largely incoherent with $\mathit{\Psi }$ . Suppose Y is the measurements of the k-sparse X; that is, $\mathit{Y}=\mathit{\Phi }\mathit{X}=\mathit{\Phi }\mathit{\Psi }\mathit{\theta }$ .

According to CS theory, we can recover X from Y by solving the following optimization problem:

$$\begin{array}{cc}& \underset{\mathbf{\theta }\in {\mathbb{R}}^N}{\min }\hspace{1em}{‖\mathbf{\theta }‖}_{\mathrm{0}}\\ \text{s.t.}\hspace{1em}\mathbf{Y}=\mathbf{\Phi }\mathit{\Psi }\mathbf{\theta }.\end{array}$$

(1)

Suppose $\widehat{\mathbf{\theta }}$ is the optimal solution of the optimization problem (1). The recovery signal of X can be obtained by

$$\begin{array}{cc}& \widehat{\mathbf{X}}=\mathit{\Psi }\widehat{\mathbf{\theta }}.\end{array}$$

(2)

The difference between the original signal X and recovery signal $\widehat{\mathbf{X}}$ represents the practical performance of CS coding, which depends on the scarcity of the original signal, as well as on the reconstruction algorithm. Because the sensory data of WSNs is generally quite sparse in nature, CS suits well data gathering in WSNs [15, 16]. In this paper, we define the ratio of the dimension of measurement vector Y to the dimension of original sensory data vector X as sampling rate λ; that is, $\lambda =M/N$ . The sampling rate is an important parameter that affects the energy consumption of nodes in a data-gathering tree that is constructed based on CS.

2.2. Overview of Data Gathering Based on Compressed Sensing in WSNs

For the traditional data-gathering method of WSNs, nodes around the sink need to transmit more raw data and consume more energy than the downstream nodes of the sensor network. The unbalanced energy consumption has a major impact on network lifetime. In [8], Luo et al. proposed CDG for data gathering in large-scale WSNs which is an efficient way to alleviate the bottleneck.

To illustrate the idea of data gathering based on CS, we rewrite the CS coding as

$$\begin{array}{cc}& \mathbf{Y}=\mathbf{\Phi }\mathbf{X}=x_{\mathrm{1}}{\varphi }_{\mathrm{1}}+x_{\mathrm{2}}{\varphi }_{\mathrm{2}}+\cdots +x_i{\varphi }_i+\cdots +x_n{\varphi }_n,\end{array}$$

(3)

where $x_i$ is sensory data of node $v_i$ and ${\varphi }_i$ is $i\mathrm{t}\mathrm{h}$ column vector of measurement matrix $\mathbf{\Phi }$ . In CDG, instead of individual readings, the weighted sums of sensor readings are delivered to the sink. In the process of data gathering, node $v_i$ first multiplies its reading $x_i$ with ${\varphi }_i$ and then adds the product to the M- $\mathrm{d}\mathrm{i}\mathrm{m}\mathrm{e}\mathrm{n}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{a}\mathrm{l}$ column vector ${\sum }_{j=\mathrm{1}}^{i+\mathrm{1}}{x}_j{\varphi }_j$ which is received from children nodes. The sum ${\sum }_{j=\mathrm{1}}^i{x}_j{\varphi }_j={\sum }_{j=\mathrm{1}}^{i-\mathrm{1}}{x}_j{\varphi }_j+x_i{\varphi }_i$ will be sent to the parent node of $v_i$ . If each node performs this operation, the compressed measurement will be completed during the process of data gathering. Eventually, the sink collects the M- $\mathrm{d}\mathrm{i}\mathrm{m}\mathrm{e}\mathrm{n}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}$ vector Y, and then the decoding algorithm is used to recover the N original sensory data. The method mentioned above is referred to as plain-CS model. In plain-CS data gathering, each node needs to send exactly an N- $\mathrm{d}\mathrm{i}\mathrm{m}\mathrm{e}\mathrm{n}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{a}\mathrm{l}$ vector irrespective of what it has received; there is no “hot pot” phenomenon.

However, the plain-CS model may lead to unnecessary higher traffic at the earlier stage of data gathering. Therefore, Luo et al. in [13] proposed the hybrid-CS data-gathering model. The main idea of hybrid-CS model is that the non-CS scheme is applied in the earlier stages of data gathering, and the CS-based compression is only applied at node whose incoming traffic intensity becomes larger than M or equal to M. The data-gathering process based on hybrid-CS model is depicted in Figure 1 through a simple chain-type topology. There are N sensor nodes $\{v_{\mathrm{1}},v_{\mathrm{2}},\dots ,v_N\}$ , and each node senses one piece of data in a round of data gathering. These data need to be transmitted to the sink node. During the transmission, sensor nodes $v_{\mathrm{1}},v_{\mathrm{2}},\dots ,v_M$ transmit the raw sensory data $x_{\mathrm{1}},x_{\mathrm{2}},\dots ,x_M$ directly, and the amount of transmitting data of each node is no more than M. But nodes $n_{M+\mathrm{1}},n_{M+\mathrm{2}},\dots ,n_N$ transmit data based on CS; that is, node $v_L\hspace{0.17em}\hspace{0.17em}(M<L<N)$ transmits data ${\sum }_{i=\mathrm{1}}^L{x}_i{\varphi }_i$ , and the transmission load of each node in set $\{n_{M+\mathrm{1}},n_{M+\mathrm{2}},\dots ,n_N\}$ is equal to M.

Figure 1

Hybrid-CS data gathering in a chain-type topology.

In this paper, we focus on maximizing the lifetime of data-gathering trees based on hybrid-CS model. As can be seen from the above analysis, the energy consumption characteristic of sensor node brings about a new challenge for constructing a maximum-lifetime data-gathering tree based on hybrid-CS model.

3. System Model and Problem Formulation

3.1. System Model

We consider a static wireless sensor network with N sensor nodes $\{v_{\mathrm{1}},v_{\mathrm{2}},\dots ,v_N\}$ and one sink node S. All sensor nodes are randomly deployed over an $A\times A$ Euclidean plane to continuously monitor the environment and periodically report data to the sink. We use an undirected graph $G(V,E)$ to represent the WSNs, where V is the set of all nodes and E is the set of edges. The underlying communication graph is a unit disk graph. All nodes have the same transmission range r. There is an edge $(v_i,v_j)\in E$ whenever the Euclidean distance between nodes $v_i$ and $v_j$ satisfies $‖v_i-v_j‖\le r$ . Each node has unique initial energy. Assume that $E(v_i)$ denotes the initial energy of node $v_i$ . The sink is AC-powered which has infinite power supply and powerful computation ability. Since data communication is the dominant energy consumption in sensor network, we can only take into account the energy consumption of communication. At each data-gathering round, each node generates a reading which is referred to as one-unit data. We denote by $E_{\mathrm{R}\mathrm{x}}$ and $E_{\mathrm{T}\mathrm{x}}$ the energy consumption of one-unit data transmission and reception, respectively.

The architecture for hybrid-CS data gathering that we refer to in [13, 14, 17] is shown in Figure 2. A spanning tree rooted at sink is adopted to gather the readings of the whole network. In Figure 2, the arrowed line represents the transmission link, and the data on the left side of each line is ready for transmitting. For leaf nodes, such as nodes $v_{\mathrm{1}}$ ~ $v_i$ and $v_{i+\mathrm{3}}$ ~ $v_{i+\mathrm{6}}$ , the original sensory data will be transmitted to their parents. For other nodes, the outgoing traffic has two possibilities:

• (1)

When the number of data received from node v's children is less than M, where M is the dimension of column vector ${\varphi }_i$ , node v forwards the received and its owns data directly. The node v is referred to as forwarding node. In Figure 2, the outgoing traffic of node $v_{i+\mathrm{7}}$ is data set $\{x_{i+\mathrm{3}},\dots ,x_{i+\mathrm{6}},x_{i+\mathrm{7}}\}$ , in which $x_{i+\mathrm{7}}$ is its own sensory data; the others are received from its children.

(2)

When the number of data received from node v's children nodes is more than M, node v performs the CS coding according to (3) and transmits exactly M encoded data corresponding to the aggregated column vector. We call node v the aggregating node. In Figure 2, node $v_{i+\mathrm{1}}$ is an aggregating node and performs the CS coding ${\sum }_{j=\mathrm{1}}^{i+\mathrm{1}}{x}_j{\varphi }_j$ . The outgoing traffic of $v_{i+\mathrm{1}}$ is always M.

Figure 2

The architecture for hybrid-CS data gathering.

Based on the above analysis, in a given data-gathering tree T, the outgoing traffic of node v is

$$\begin{array}{cc}& R_{\mathrm{T}\mathrm{x}}\left(T,v\right)=\left\{\begin{array}{cc}{{\displaystyle \sum }}_{u\in \mathrm{C}\mathrm{h}\left(v\right)}{R}_{\mathrm{T}\mathrm{x}}\left(T,u\right)+\mathrm{1},\hfill & \text{if}{{\displaystyle \sum }}_{u\in \mathrm{C}\mathrm{h}\left(v\right)}{R}_{\mathrm{T}\mathrm{x}}\left(T,u\right)<M;\hfill \\ M,\hfill & \text{otherwise,}\hfill \end{array}\right.\end{array}$$

(4)

where $\mathrm{C}\mathrm{h}(v)$ is the set of v's children nodes. Thus, the energy consumption of node v in each data-gathering round is

$$\begin{array}{cc}& C\left(T,v\right)=\left\{\begin{array}{cc}{E}_{\mathrm{T}\mathrm{x}}{R}_{\mathrm{T}\mathrm{x}}\left(T,v\right)+E_{\mathrm{R}\mathrm{x}}{{\displaystyle \sum }}_{u\in \mathrm{C}\mathrm{h}\left(v\right)}{R}_{\mathrm{T}\mathrm{x}}\left(T,u\right),\hfill & \text{if node}v\text{is not a leaf node}\hfill \\ E_{\mathrm{T}\mathrm{x}},\hfill & \text{otherwise.}\hfill \end{array}\right.\end{array}$$

(5)

3.2. Problem Formulation

In this paper, we define a data-gathering round as the process of gathering all data from nodes to the sink, regardless of how much time it takes [18].

The lifetime of a node v in tree T is defined as the number of data-gathering rounds since it began to work until its death:

$$\begin{array}{cc}& L_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)=\frac{E\left(v\right)}{C\left(T,v\right)}.\end{array}$$

(6)

We also define the load, $l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}(T,v)$ , of node v as the ratio of $C(T,v)$ to $E(v)$ ; that is,

$$\begin{array}{cc}& l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)=\frac{C\left(T,v\right)}{E\left(v\right)}=\frac{\mathrm{1}}{L_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)}.\end{array}$$

(7)

The lifetime of a tree T is defined as the lifetime of the first dead node in the tree:

$$\begin{array}{cc}& L_{\mathrm{t}\mathrm{r}\mathrm{e}\mathrm{e}}\left(T\right)=\underset{v\in V}{\min }\left\{L_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\right\}.\end{array}$$

(8)

For any network G, we refer to $S(G)$ as the set of all possible trees for G. The problem of finding a maximum-lifetime data-gathering tree (MLDGT) based on hybrid-CS model can be defined as

$$\begin{array}{cc}& \underset{T\in S\left(G\right)}{\max }{L}_{\mathrm{t}\mathrm{r}\mathrm{e}\mathrm{e}}\left(T\right)=\underset{T\in S\left(G\right)}{\max }\underset{v\in V}{\min }\left\{L_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\right\}.\end{array}$$

(9)

This problem that is similar to the maximum-lifetime problem proposed in [18–20] is an NP-complete problem. The unique property of the problem is the energy consumption model of the node in data-gathering tree based on hybrid-CS model, which brings about new challenges for constructing data-gathering tree. Since the problem is NP-complete, we try to find an approximate solution to solve the problem. Details of the solution techniques are shown in the next section.

4. Solution Techniques

4.1. Basic Ideal of Solution Techniques

To facilitate the analysis, we first provide some relevant assumptions and definitions in this section. We denote by $P(T,v_i)$ the path from node $v_i$ to sink S in spanning tree T. The expression $v_j\in P(T,v_i)$ represents the notion that node $v_j$ is a relaying node on the path $P(T,v_i)$ . In a spanning tree T, the nodes on the path $P(T,v_i)$ may have different loads. We define path load, $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v_i)$ , of node $v_i$ as the maximum load of all nodes along the path from node $v_i$ to sink S; that is,

$$\begin{array}{cc}& l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_i\right)=\max \left\{l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v_j\right)\mid v_i\in P\left(T,v_j\right)\right\}.\end{array}$$

(10)

And the node with the largest load on the path $P(T,v_i)$ is called bottleneck node on the path $P(T,v_i)$ of node $v_i$ .

Formula (9) can be transformed into an equivalent form:

$$\begin{array}{cc}& \underset{T\in S\left(G\right)}{\max }{L}_{\mathrm{t}\mathrm{r}\mathrm{e}\mathrm{e}}\left(T\right)⟺\\ \underset{T\in S\left(G\right)}{\min }\underset{v\in V}{\max }\left\{\frac{\mathrm{1}}{L_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)}\right\}=\underset{T\in S\left(G\right)}{\min }\underset{v\in V}{\max }\left\{l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\right\}.\end{array}$$

(11)

Let $Q(T)$ denote the set of all leaf nodes in tree T. Assume that $q=\left|Q(T)\right|$ is the number of nodes in set $Q(T)$ , and the elements of set $Q(T)$ are $u_{\mathrm{1}}$ , $u_{\mathrm{2}}$ ,…, and $u_q$ . Thus, the sensor node set V can be divided into q paths of q leaf nodes; that is,

$$\begin{array}{cc}& V=P\left(T,u_{\mathrm{1}}\right)\cup P\left(T,u_{\mathrm{2}}\right)\cup \cdots \cup P\left(T,u_p\right)={\displaystyle \bigcup }_{u_i\in Q\left(T\right)}P\left(T,u_i\right).\end{array}$$

(12)

Based on the division of node set V, formula (11) is equal to

$$\begin{array}{cc}& \underset{T\in S\left(G\right)}{\mathrm{m}\mathrm{a}\mathrm{x}}{L}_{\mathrm{t}\mathrm{r}\mathrm{e}\mathrm{e}}\left(T\right)⟺\\ \underset{T\in S\left(G\right)}{\min }\underset{v\in V}{\max }\left\{l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\right\}=\underset{T\in S\left(G\right)}{\min }\max \left\{l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\mid v\in {\displaystyle \bigcup }_{u_i\in Q\left(T\right)}P\left(T,u_i\right)\right\}=\underset{T\in S\left(G\right)}{\min }\underset{}{\max }\left\{\underset{}{\max }\left\{l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\mid v\in P\left(T,u_{\mathrm{1}}\right)\right\},\max \left\{l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\mid v\in P\left(T,u_{\mathrm{2}}\right)\right\},\dots ,\max \left\{l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T,v\right)\mid v\in P\left(T,u_p\right)\right\}\right\}=\underset{T\in S\left(G\right)}{\min }\underset{}{\max }\left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,u_{\mathrm{1}}\right),l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,u_{\mathrm{2}}\right),\dots ,l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,u_p\right)\right\}=\underset{T\in S\left(G\right)}{\min }\max \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,u_i\right)\mid u_i\in Q\left(T\right)\right\}.\end{array}$$

(13)

Therefore, the MLDGT problem is transformed to construct a spanning tree, in which the maximum path load of leaf nodes is minimal.

Inspired by [19], in order to solve the problem of formula (13), we need to find a spanning tree in which the difference between the maximum path load and the minimum path load of leaf node is minimal. Therefore, the MLDGT problem can be described as follows:

$$\begin{array}{cc}& \underset{T\in S\left(G\right)}{\mathrm{m}\mathrm{a}\mathrm{x}}{L}_{\mathrm{t}\mathrm{r}\mathrm{e}\mathrm{e}}\left(T\right)⟺\\ \underset{T\in S\left(G\right)}{\min }\underset{}{\max \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,u_i\right)\mid u_i\in Q\left(T\right)\right\}}⟺\\ \underset{T\in S\left(G\right)}{\min }\left\{\max \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_i\right)\mid v_i\in Q\left(T\right)\right\}-\min \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_i\right)\mid v_i\in Q\left(T\right)\right\}\right\}.\end{array}$$

(14)

For a given connectivity group G, we assume that tree $T_{\mathrm{o}\mathrm{p}\mathrm{t}}$ is an optimal spanning tree which provides the maximum lifetime. Let ${\sigma }_{\mathrm{o}\mathrm{p}\mathrm{t}}$ be the difference between the maximum path load and the minimum path load of leaf node in tree $T_{\mathrm{o}\mathrm{p}\mathrm{t}}$ ; that is,

$$\begin{array}{cc}& {\sigma }_{\mathrm{o}\mathrm{p}\mathrm{t}}=\max \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T_{\mathrm{o}\mathrm{p}\mathrm{t}},v_i\right)\mid v_i\in Q\left(T_{\mathrm{o}\mathrm{p}\mathrm{t}}\right)\right\}-\min \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T_{\mathrm{o}\mathrm{p}\mathrm{t}},v_i\right)\mid v_i\in Q\left(T_{\mathrm{o}\mathrm{p}\mathrm{t}}\right)\right\}.\end{array}$$

(15)

Each connectivity group G has a unique ${\sigma }_{\mathrm{o}\mathrm{p}\mathrm{t}}$ which depends on the node's initial energy, network deployment, and network connectivity of WSNs. It is an NP-complete problem for finding ${\sigma }_{\mathrm{o}\mathrm{p}\mathrm{t}}$ of any given connectivity group.

We can enumerate all spanning trees of graph G and find a spanning tree which minimizes the maximum path load of leaf nodes. However, the number of the spanning trees of graph G can be an exponential function of the number of nodes N. Therefore, we try to find an approximate solution to minimize the maximum path load of leaf node in the data-gathering tree. Details of the algorithm are described in the next section.

4.2. Algorithm Description

In this section, we design an approximate algorithm to deal with the problem raised by formula (13). Our algorithm uses randomized tree transformation and switching method and optimal parent node selecting strategy that make full use of the property of energy consumption in data gathering based on CS to improve convergence speed of the algorithm.

Our algorithm starts from an arbitrary tree T and then keeps transferring descendants of bottleneck node to nodes with smaller path load iteratively. In order to make the algorithm converge, we define a terminate parameter σ as the maximum allowable difference in the path loads among all leaf nodes. If the current spanning tree $T^{\prime }$ satisfies the condition

$$\begin{array}{cc}& \max \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T^{\prime },v_i\right)\mid v_i\in Q\left(T^{\prime }\right)\right\}-\underset{}{\min }\left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T^{\prime },v_i\right)\mid v_i\in Q\left(T^{\prime }\right)\right\}\le \sigma ,\end{array}$$

(16)

the iterative operation will be terminated, and $T^{\prime }$ is the final result. It is obvious that the terminate parameter σ is more close to ${\sigma }_{\mathrm{o}\mathrm{p}\mathrm{t}}$ , and the algorithm result is more close to the optimal solution. Therefore, our algorithm may be superior well under proper choice of terminate parameter σ.

However, if the current spanning tree $T^{\prime }$ does not satisfy condition (16), we need to continue to adjust the load of bottleneck node. We use Figure 3 to illustrate the details of our algorithm. Figure 3 shows a part of the spanning tree $T^{\prime }$ . In Figure 3, the solid lines with arrow indicate the directions of data transmission in the tree $T^{\prime }$ while the dotted lines without arrow represent the edges in graph G. The omitted parts of the tree $T^{\prime }$ are represented by the dotted lines with arrow. $T_{v_i}$ denotes the subtree rooted at node $v_i$ .

Figure 3

A part of the spanning tree $T^{\prime }$ .

In Figure 3, suppose that node $v_i$ has the highest load in current tree $T^{\prime }$ . We need to switch some descendant nodes of $v_i$ to new parent node. Node $v_i$ has three children nodes, $v_{i+\mathrm{4}}$ , $v_{i+\mathrm{5}}$ , and $v_{i+\mathrm{6}}$ . Those nodes can be selected to switch to an alternate path. If node $v_{i+\mathrm{4}}$ is selected, it may have two potential parent nodes, $v_{i+\mathrm{1}}$ and $v_{i+\mathrm{2}}$ . Assume that node $v_{i+\mathrm{4}}$ is switched to node $v_{i+\mathrm{1}}$ . After switching, the load of node $v_{i+\mathrm{1}}$ increases and may become greater than the load of node $v_i$ by more than the terminate parameter σ. Consequently, the path load of leaf nodes in $T_{v_{i+\mathrm{1}}}$ may exceed the path load of leaf nodes in $T_{v_i}$ by more than σ. In the next iteration, node $v_{i+\mathrm{4}}$ may be switched to node $v_i$ again. In such case, we say that an oscillation has occurred. This phenomenon influences convergence and convergence speed of the algorithm. In order to reduce the influence of the oscillation, we adopt some mechanisms such as random switching decision and optimal parent node selecting strategy.

In the random switching decision, whether a node is selected for switching depends on its switching probability. For a considered node, we generated a random number, 0 or 1, according to its switching probability. If the random number is 1, the corresponding node is selected to switch; otherwise, the node is not selected. It is more likely to generate random number 1 when the switching probability is higher. The initial switching probability for each node is $\mathrm{1}/\mathrm{2}$ . Then, the switching probability $p(v_i)$ of node $v_i$ is decided by the number of switching instances where node $v_i$ is selected. The switching probability can be expressed as

$$\begin{array}{cc}& p\left(v_i\right)={\mathrm{2}}^{-\left[n\left(v_i\right)+\mathrm{1}\right]},\end{array}$$

(17)

where $n(v_i)$ denotes the switching numbers of node $v_i$ . When a node has been selected for switching many times, there may be an oscillation that happened on such node. We use formula (17) to give such node with a smaller switching probability, reduce the chance of the node being selected, and give other nodes more opportunities. This method is beneficial to reduce the oscillation.

In Figure 3, if node $v_{i+\mathrm{4}}$ is switched many times and the algorithm cannot converge, the switching probability of node $v_{i+\mathrm{4}}$ will decrease, and the opportunities of other $v_i$ 's children node, such as $v_{i+\mathrm{5}}$ or $v_{i+\mathrm{6}}$ , will increase. This feature is advantageous to improve the convergence of the algorithm.

We have used a random switching decision to select a switching node. We will design an optimal parent node selecting strategy for assigning an optimal parent node to the selected switching node. Intuitively, in graph G, each neighbor of a selected switching node is likely to be the parent node of the switching node. However, in fact, only a part of the neighbor nodes are qualified to be the parent eventually. Because the path loads of some neighbor nodes are high originally, the node switching may increase the path load of such nodes, and the oscillation may happen. Therefore, we should choose some neighbor nodes as the potential parent nodes. Suppose that $v_i$ is a switching node and its original path load is $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v_i)$ in tree T. If $v_i$ is switched to a neighbor node $v_j$ , the new tree $T^{\prime }$ is constructed, and the new path load of $v_i$ is $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_j}(T^{\prime },v_i)$ . If the new path load of $v_i$ is bigger than the original path load, the neighbor node $v_j$ cannot become a potential parent node. The set of $v_i$ 's potential parents can be determined as follows:  

$$\begin{array}{cc}& P_{v_i}=\left\{v_j\mid l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_j}\left(T^{\prime },v_i\right)<l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_i\right),\hspace{0.17em}\hspace{0.17em}{v}_j\in {\mathrm{N}\mathrm{e}\mathrm{i}}_{v_i}\right\},\end{array}$$

(18)

where ${\mathrm{N}\mathrm{e}\mathrm{i}}_{v_i}$ is the set of $v_i$ 's neighbor nodes.

In neighbor nodes set ${\mathrm{N}\mathrm{e}\mathrm{i}}_{v_i}$ , there may be two kinds of node: the first is the forwarding node and the other is the aggregating node. As described in formula (4), when neighbor node $v_j$ is an aggregating node, the outgoing traffic of aggregating node $v_j$ is a constant value, M. If $v_i$ switches to $v_j$ , the outgoing traffic of $v_j$ is also a constant value M; that is, the load of nodes on the path from $v_j$ to sink does not change, and the node load of $v_j$ changes. Therefore, the new path load $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_j}(T^{\prime },v_i)$ of $v_i$ can be determined as

$$\begin{array}{cc}& l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_j}\left(T^{\prime },v_i\right)=\max \left(l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_j\right),l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}\left(T^{\prime },v_j\right)\right),\end{array}$$

(19)

where $l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}(T^{\prime },v_j)$ is the node load of $v_j$ in the new tree $T^{\prime }$ . Otherwise, if neighbor node $v_j$ is a forwarding node, the loads of nodes on the path from $v_j$ to sink change, until a node becomes an aggregating node.

We need to choose a node v from the set $P_{v_i}$ to be the ultimate parent of $v_i$ . When node $v_i$ is switched to the ultimate parent, its new path load is the smallest; that is,

$$\begin{array}{cc}& v=\arg \underset{v_j\in P_{v_i}}{\min }\left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_j}\left(T^{\prime },v_i\right)\right\}.\end{array}$$

(20)

In Figure 3, if node $v_{i+\mathrm{5}}$ is selected to switch, $v_{i+\mathrm{5}}$ has three neighbor nodes, $v_{i+\mathrm{1}}$ , $v_{i+\mathrm{2}}$ , and $v_{i+\mathrm{8}}$ . If nodes $v_i$ and $v_{i+\mathrm{2}}$ satisfy $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_i}(T^{\prime },v_{i+\mathrm{5}})<l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v_{i+\mathrm{5}})$ and $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_{i+\mathrm{2}}}(T^{\prime },v_{i+\mathrm{5}})<l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v_{i+\mathrm{5}})$ , respectively, they may become $v_{i+\mathrm{5}}$ 's potential parents. Then, we select a node whose new path load is smaller from $v_i$ and $v_{i+\mathrm{2}}$ as $v_{i+\mathrm{5}}$ 's ultimate parent according to formula (20).

4.3. Details of the Algorithm

The core of our algorithm is shown in Algorithm 1. In our algorithm, ${\beta }_{v_i}$ counts how many times node $v_i$ is selected as the node with the highest load in tree T, and $p(v_i)$ denotes switching probability of node $v_i$ . The initial values of ${\beta }_{v_i}$ and $p(v_i)$ for each $v_i\in V$ are set to 0 and $\mathrm{1}/\mathrm{2}$ , respectively. In line (2), $v_a$ denotes the node with the highest load in tree T, whose children nodes will be selected for switching. ${\beta }_{\mathrm{m}\mathrm{a}\mathrm{x}}$ denotes the maximum allowed number of times that a node can be selected for switching. It is an important parameter that affects the convergence of the algorithm. If the node $v_a$ with the highest load has been selected for ${\beta }_{\mathrm{m}\mathrm{a}\mathrm{x}}$ times, the switching procedure will be terminated (line (3)) and the data-gathering tree T is returned (line (27)). Within the while loop, if the current spanning tree T satisfies inequality (16), the iterative operations of the algorithm will be terminated, and the data-gathering tree T is returned (lines (4)-(5)). Otherwise, the children of $v_a$ are inserted in queue α, and each node in queue α is qualified to be selected to switch. If queue α is not empty, we remove a node $v_b$ from queue α in FIFO order and then determine $v_b$ 's potential parents set $P_{v_b}$ using formula (18) (lines (9)-(10)). If node $v_b$ has no potential parent, the children nodes $\mathrm{C}\mathrm{h}(v_b)$ of $v_b$ are added to the queue and considered for switching in subsequent rounds (line (12)). If $v_b$ has some potential parents, a random decision is made based on its current switching probability $p(v_b)$ through the switching decision function. If the outcome of the decision is to switch, a node ${\mathrm{P}\mathrm{a}\mathrm{r}}_{v_b}$ is chosen as the parent of node $v_b$ through formula (20), and then the tree T is updated by switching the subtree $T_{v_b}$ rooted at node $v_b$ to ${\mathrm{P}\mathrm{a}\mathrm{r}}_{v_b}$ . The new loads $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v_i)$ and $l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}(T,v_i)$ of each $v_i\in V$ are updated (lines (14)–(16)). Because node $v_b$ is switched, the subsequent switching probability becomes a half of its original; that is, $p(v_b)=p(v_b)/\mathrm{2}$ (line (17)). Since node $v_b$ is switched and the tree T is updated, we should terminate the while loop (line (18)) and then reselect a new node $v_a$ with the highest load (line (25)) for subsequent iterations. If the outcome of the decision is not to switch, node $v_b$ remains with its current parent and the descendants of $v_b$ are added to the queue for subsequent consideration (lines (19)-(20)).

Algorithm 1: Construction of data-gathering tree.

Input: graph G, arbitrary spanning tree T, $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v_i)$ and $l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}(T,v_i)$ for each $v_i\in V$ , ${\beta }_{\mathrm{m}\mathrm{a}\mathrm{x}}$

Output: Data-gathering tree

(1) Set ${\beta }_{v_i}\leftarrow \mathrm{0}$ and $p(v_i)=\mathrm{1}/\mathrm{2}$ for each $v_i\in V$ ;

(2) Let $v_a$ be the node with the highest load in tree T;

(3) While   ${\beta }_{v_a}\le {\beta }_{\mathrm{m}\mathrm{a}\mathrm{x}}$   do

(4)  if   $\max \left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_i\right)\mid v_i\in Q\left(T\right)\right\}-\min$ $\left\{\hspace{0.17em}\right.$ $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_i\right)\mid v_i\in Q\left(T\right)\le \left.\sigma \right\}$  then

(5)    Return T;

(6)  else

(7)    Set $\alpha \leftarrow \mathrm{C}\mathrm{h}(v_a)$ , ${\beta }_{v_a}={\beta }_{v_a}+\mathrm{1}$ ;

(8)    While   $\alpha \ne \mathrm{⌀}$   do

(9)      Remove node $v_b$ from α in FIFO order;

(10)       $$P_{v_b}=\left\{v_c\mid l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_c}\left(T^{\prime },v_b\right)<l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}\left(T,v_b\right),v_c\in {\mathrm{N}\mathrm{e}\mathrm{i}}_{v_b}\right\}$$ ;

(11)      if   $P_{v_b}=\mathrm{⌀}$   then

(12)        $\alpha =\alpha \cup \mathrm{C}\mathrm{h}\left(v_b\right)$ ;

(13)      else

(14)       if SwitchingDecision ( $p(v_b)$ ) == 1 then

(15)         ${\mathrm{P}\mathrm{a}\mathrm{r}}_{v_b}=\arg \underset{}{{\min }_{v\in P_{v_b}}}\left\{l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^v\left(T^{\prime },v_b\right)\right\}$ ; / ${}^{\ast }{\mathrm{P}\mathrm{a}\mathrm{r}}_{v_b}$ is new parent of $v_b$

(16)        Update T by switching $T_{v_b}$ to ${\mathrm{P}\mathrm{a}\mathrm{r}}_{v_b}$ , update $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v)$ and $l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}(T,v)$ for each $v\in V$ ;

(17)         $$p\left(v_b\right)=\frac{p\left(v_b\right)}{\mathrm{2}}$$ ;

(18)        break;

(19)       else

(20)         $$\alpha =\alpha \cup \mathrm{C}\mathrm{h}\left(v_b\right)$$ ;

(21)       end if

(22)      end if

(23)    end while

(24)  end if

(25)  Select $v_a$ as the node with the highest load;

(26) end while

(27) Return T

4.4. Analysis of Algorithm

In this section, we present the time complexity of our algorithm. The calculation of $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v_i)$ and $l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}(T,v_i)$ for each $v_i\in V$ that is done during the initialization can be performed in $O(N)$ time. Lines (1)-(2) of our algorithm can be performed in $O(N)$ time. On line (4), since there can be at most $O(N)$ leaf nodes in current spanning tree, the calculation of the maximum and minimum path load of leaf node takes at most $O(N)$ time. The initialization of α on line (7) takes $O(C_{\mathrm{m}\mathrm{a}\mathrm{x}})$ time, where $C_{\mathrm{m}\mathrm{a}\mathrm{x}}$ is the maximum number of children of any node. On line (10), we determine the potential parents of the selected switching node $v_b$ . Because each neighbor of the switching node $v_b$ has the potential to become the parent, we need to calculate $v_b$ 's new path load $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_c}(T^{\prime },v_b)$ when $v_b$ switch to each neighbor. The calculations take $O(Q_{\mathrm{m}\mathrm{a}\mathrm{x}})$ times, where $Q_{\mathrm{m}\mathrm{a}\mathrm{x}}$ is the maximum number of neighbors of a node in graph G. In order to determine $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}^{v_c}(T^{\prime },v_b)$ , we need to calculate the load of each node on the path from the selected switching node to the sink. It takes at most $O(D)$ time where D is the diameter of the network. Therefore, determining the potential parents on line (10) takes $O(D{Q}_{\mathrm{m}\mathrm{a}\mathrm{x}})$ time. Updating α on lines (12) and (20) takes $O(C_{\mathrm{m}\mathrm{a}\mathrm{x}})$ time. Selecting the ultimate parent on line (15) takes at most $O(Q_{\mathrm{m}\mathrm{a}\mathrm{x}})$ since the new path load has been calculated on line (10). On line (16), updating $l_{\mathrm{p}\mathrm{a}\mathrm{t}\mathrm{h}}(T,v)$ and $l_{\mathrm{n}\mathrm{o}\mathrm{d}\mathrm{e}}(T,v)$ takes $O(N)$ time. Since $C_{\mathrm{m}\mathrm{a}\mathrm{x}}\le N$ and $Q_{\mathrm{m}\mathrm{a}\mathrm{x}}\le N$ , the running time for operations from line (9) to line (22) is dominated by $O(D{Q}_{\mathrm{m}\mathrm{a}\mathrm{x}}+N)$ . Because the subtree $T_{v_a}$ rooted at node $v_a$ can have at most N descendants, the second loop on line (8) can run for $O(N)$ times. Therefore, the running time for the second loop takes $O(N(D{Q}_{\mathrm{m}\mathrm{a}\mathrm{x}}+N))$ time. If all nodes periodically participate in switching, the loop on line (3) runs at most $N{\beta }_{\mathrm{m}\mathrm{a}\mathrm{x}}$ times. Hence, the total time complexity of our algorithm is $O(N^{\mathrm{2}}(D{Q}_{\mathrm{m}\mathrm{a}\mathrm{x}}+N))$ .

5. Performance Evaluation

In this section, we evaluate the performance of our algorithm through simulation experiments.

5.1. Simulation Setup

We evaluate the performance of our algorithm using Matlab simulations. In our simulation, we randomly deploy sensor nodes in a square region of size 100 m × 100 m. The number of sensors is varied from 100 to 300. We consider three scenarios associated with the different location of the sink in the network. In Scenario 1, the sink was placed at the corner of the deployment area, that is, at the (0 m, 0 m) coordinate. In Scenario 2, the sink was placed at one side of the deployment area, specifically at the (50 m, 0 m) coordinate. In Scenario 3, the sink was placed in the middle of the deployment area, namely, at the (50 m, 50 m) coordinate. Each sensor is randomly assigned an initial energy between 0.5 and 1 joule (J). We assumed that all nodes have the same energy consumption model. The radio transmission range of each node is set to 25 m. Similar to [18], the energy required to receive data is 50 nJ/bit and the energy required to transmit data is 100 nJ/bit. The size of one-unit data is 16 bytes. The energy consumption for one-unit data transmission and reception is 6400 nJ and 12800 nJ, respectively; that is $E_{\mathrm{R}\mathrm{x}}=6400$  nJ and $E_{\mathrm{T}\mathrm{x}}=\mathrm{12800}$  nJ. We generate 100 random networks and present the average results for performing comparisons. We evaluate the lifetime performance measured as the number of data-gathering rounds until the first node runs out of energy.

The choice of the terminate parameter σ governs convergence speed of the algorithm and lifetime of the tree produced at converged point. However, it is not possible to know the optimal value of σ for a random connectivity graph. Intuitively, it may appear that choosing σ as low as possible results in a higher lifetime tree. When σ is too low, the algorithm will perform more switching to find a spanning tree to meet the terminate parameter. However, such spanning tree may not topologically exist in a given connectivity graph representing the sensor network. The oscillations may occur and diminish the lifetime of the final tree. Therefore, we need to learn the appropriate ranges of σ for different network configurations. To solve this problem, we generate 100 random deployed networks for each scale sensor network as training inputs to our algorithm. Then, we measure their lifetimes with varying σ values and select the optimal σ value for simulation experiments. The maximum allowed switching time ${\beta }_{\mathrm{m}\mathrm{a}\mathrm{x}}$ is set to 1000.

5.2. Simulation Results

In this section, we first compare our algorithm with the MITT [18], RaSMaLai [19], and MECDA [14] data-gathering schemes for Scenario 2. The lifetime performance is compared as a function of the number of nodes. The sampling rate is set to 10% and 20%.

It can be seen from Figure 4 that our algorithm outperforms the compared algorithms. Furthermore, the lower the sampling rate, the better the lifetime performance of our algorithm. When the sampling rate is low, more nodes in the network can become the aggregating nodes, so as to save energy. The MITT algorithm is based on a min-max-weight spanning tree. The algorithm improves the lifetime of a given tree by switching the parent of the node under consideration. The MECDA algorithm uses hybrid-CS technology, and the objective of the algorithm is to minimize the total energy consumption in a data-gathering tree. It does not consider the balance of energy consumption and energy consumption of each node. The nodes near the sink may have higher energy consumption, which affects the lifetime of the network. The RaSMaLai algorithm uses randomized switching scheme to maximize the lifetime of data collection trees based on the concept of the bounded balanced trees. However, because the algorithm collects the raw data directly, the nodes close to the sink need to relay data of all the downstream nodes on the path, so that the energy consumption is higher, and the network lifetime is shorter. Our algorithm uses both the hybrid-CS strategy and the random switching method to adjust the load of bottleneck node, thus obtaining the best lifetime performance.

Figure 4

Lifetime of different algorithms.

Figure 5 shows the lifetime of different algorithms when the sampling rate is varied from 10% to 30%, and the number of nodes is 200 and 300, respectively. As shown in Figure 5, with the increase of the number of nodes, the nodes near the sink need to forward more data, the energy consumption increases, and the lifetime is reduced. With the increase of sampling rate, the lifetime for our algorithm and MECDA decreases. This is because when the sampling rate increases, the maximum data length M is increased, and the intermediate nodes need to gather more data to become aggregating nodes, the energy consumption of such nodes increases, and the network lifetime is reduced. However, the lifetime of RaSMaLai does not change with the varying of sampling rate, because it does not use the CS strategy. When the sampling rate is over 30%, the performance of our algorithm is more and more close to that of the RaSMaLai algorithm. The reason is that when the sampling rate is large, few nodes can become the aggregating node, and the characteristic of energy consumption is consistent with the RaSMaLai algorithm.

Figure 5

Lifetime with different sampling rates.

As shown in Figure 6, we compare our algorithm with MECDA in different scenarios. No matter which scenario is used, our algorithm outperforms the MECDA algorithm. In Scenario 1, the performance of our algorithm is more superior, because when the sink is placed at (0, 0) coordinate, the nodes around the sink need to forward more data of downstream nodes and have heavy loads, and thus our algorithm can make the load of such nodes become more balanced by switching. However, in Scenario 3, the performance improvement of our algorithm is relatively small; this happens since the sink located at the middle naturally gives better balancing for each algorithm.

Figure 6

Lifetime in different scenarios.

6. Conclusion

In this paper, we have studied the problem of constructing a maximum-lifetime data-gathering tree. We used hybrid-CS theory to data gathering in wireless sensor networks. We first constructed an arbitrary data-gathering tree, used a random switching decision to select a bottleneck node's child as switching node, and then designed an optimal parent node selecting strategy for assigning an optimal parent to the selected switching node. We kept transferring descendants of the bottleneck node to realize load balancing until the terminate parameter or maximum allowed switching time is satisfied. Simulation results show that the proposed algorithms can significantly increase the lifetime of WSNs and outperform several existing approaches in terms of network lifetime.