Page 1

Construction and Maintenance of a Cluster-based Architecture for Sensor

Networks

Jiro Uchida∗, Islam A.K.M. Muzahidul∗, Yoshiaki Katayama∗, Wei Chen†and Koichi Wada∗

∗Nagoya Institute of Technology

Gokiso-cho, Syowa-ku, Nagoya, 466-8555, Japan

Email: {jiro, islam}@phaser.elcom.nitech.ac.jp, {katayama, wada}@nitech.ac.jp

†Tennessee State University

3500 John A Merrit Blvd, Nashville, TN 37209, USA

Email: wchen@tnstate.edu

Abstract:

transmitter-receiver devices (referred to as nodes). We

assume that each node synchronizes and performs trans-

mission or reception per round. In this paper, we consider

the construction and maintenance of a cluster-based archi-

tecture for a sensor network, with two atomic operations

node-move-in and node-move-out which are performed by

appearance and disappearance of a node. In our proposed

architecture, a deterministic broadcasting can be done

in O(p) rounds, where p is the number of clusters. We

present a randomized algorithm for a node-move-in and a

deterministic algorithm for a node-move-out, which work

in O(q) expected rounds and O(|T|) rounds, respectively,

where q is the number of neighbors in the network of the

joining node and T is a subtree of the architecture whose

root is the leaving node. We also provide some alternative

algorithms for the operations.

A sensor network isa collection of

I. INTRODUCTION

A sensor network is a collection of sensor nodes, where

each sensor node has a sensor array, a controling processor

and a transimitter-receiver communication unit.

There is increasing interest in self-organizing multi-hop

wireless sensor networks composed of a large number

of autonomous nodes communicating via radio without

any additional infrastructure. These nodes can be static

or mobile, and they are usually constrained as for the

critical resources, such as power and radio frequency band.

A typical example is given by wireless sensor networks,

where sensor nodes are usually irreplaceable, and become

unusable after energy depletion or other failures.

After the nodes (devices) of a sensor network are

deployed physically, a flat network topology is formed

in which a link exists between two nodes if they are in

each others communication range. In such a flat network

topology, there is no established structure on which the

nodes could take efficient communication.

Clustering is seen as the step to provide the flat sensor

network topology with a hierarchical organization. The

basic idea is that of breaking the network into physical

proximity clusters which are smaller in scale and usually

simpler to manage by the nodes called as cluster head.

The subsequent backbone construction uses the cluster-

ing induced hierarchy to form a structure which mainly

consists of cluster heads and provides the communication

between the clusters. The structured network is functional

in providing desirable properties such as minimizing com-

munication overhead, choosing data aggregation points,

increasing the probability of aggregating redundant data,

and minimizing the overall power consumption [11].

Considering the mobility and scalability, we need the

operations such as nodes getting out of and nodes joining

into an existing network. Even for stationary nodes, when

battery is low, it must get out and go to charge mode. Then,

the charged nodes should join back to the network once

again. Therefore, once a hierarchical clustering established,

the maintenance of the cluster organization turns to be

crucial in the presence of network topology changing.

Distributed clustering for a flat sensor network topology

G has been investigated in many literatures. Most of the

proposed protocols end up generating a clustering of G

and a corresponding backbone in which the cluster heads

forming a dominating set (DS) or an independent set (IS)

of G [2]–[5], [8], [10]. A set is a DS of G if any node of

G is either the node of DS or is the neighbor of a node of

DS. A set is an IS of G if no two nodes of the set are the

neighbors in G. In most of these distributed algorithms,

the nodes need two hops knowledge, i.e., the knowledge

of the neighbors and the neighbors’ neighbors which need

O(n) time to get, to establish a clustering structure of

G. It is known that finding a minimum DS (MDS) or

a maximum IS of a graph is an NP-complete problem.

Therefore, finding a clustering with the minimum number

of clusters is also an NP-complete problem. Sometimes, a

sensor network can be modeled by a unit disk graph, where

an edge exists between two nodes iff the Euclidean distance

of two nodes is at most 1. When G is a unit disk graph, a

cluster structure can be formed by selecting a maximul IS

(MIS) and then connect them to a backbone whose size is a

constant times of MDS in O(n) - O(n2) time [4], [8], [10].

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

1

0-7695-2507-5/06/$20.00 (C) 2006 IEEE

Page 2

In [3], a randomized algorithm is presented to compute an

asymptotically optimal MDS (i.e., it finds a set of cluster

heads but not connect them to form a cluster structure) in

polylogarithmic time. This algorithm computes clustering

but does not make a backbone.

The comparative performance evaluation of these above

algorithms for clustering and backbone formation is shown

in [11].

Although many efforts have been made for establishment

of a hierarchical clustering on a sensor network, the

research for the maintenance of the cluster organization

under the similar scenario is seldom seen.

This paper puts emphasis on the maintenance of the

clustering structure of the sensor network. In this paper we

consider a sensor network in which the network topology

dynamically changes. We propose a novel cluster structure

on which two operations node-move-in and node-move-

out are defined for maintaining the cluster organization.

Our work is based on the following radio network model

[1]: each node has a distinct ID, nodes transmit or receive

message in each synchronized round, and all nodes use a

single radio channel without collision detection capability.

In our distributed clustering, the nodes of a flat network

G are grouped into disjoint clusters, and the backbone is a

tree consisting of cluster heads and gateway nodes (gate-

way nodes are used to connect the heads). Furthermore,

the backbone and the clusters are combined into a tree

which we call as cluster-based network of G, denoted as

CNet(G). Let n be the number of the nodes in G and p be

the number of the clusters in our clustering. A CNet(G)

has several novel properties: (1) the backbone consists of

at most 2p−1 nodes; (2) p is not larger than the smallest

number of disjoint complete subgraphs of G, and so when

G is a dense graph, p ? n; (3) a broadcasting on G can

be executed via the backbone in O(p) time (it needs Ω(n)

time on a flat network [9]); and (4) if G is a unit disk

graph, p ≤ 5 × |MDS|.

In our clustering, when a CNet(G) is established, each

node has only one hop knowledge (i.e., each node knows

their neighbors in the backbone, CNet(G) and G, respec-

tively). We will show that a CNet(G) can be established

either in a static way which means that all topological

information are gathered somewhere and the problem is

solved there, or in a dynamic way which means that

each node solves the problem locally without gathering all

information, in O(n) time or in O(|E|) time, respectively.

The operations node-move-in and node-move-out maintain

the cluster structure for G with the same properties when a

node gets out of or joins into G. We will show algorithms

for these operations.

Sometimes, nodes need only to know partial one hop

knowledge (nodes don’t need to know all the neighbors in

G, but their neighbors in the backbone and CNet(G)). We

TABLE I

OUR RESULTS

maintained

information

1-hop,

partial 1-hop

operationcompletion time

broadcast

O(p)

1-hop

node-move-in

node-move-out

node-move-in

node-move-out

expected O(q)

O(|T|)

expected O(logq)

O(n)

partial 1-hop

n : the number of the nodes in G,

p : the number of the clusters in CNet(G),

q : the number of the move-in node’s neighbors in G,

T : the subtree of CNet(G) whose root is the move-out

node.

will also show algorithms for maintaining such a structure.

Our results are summarized in Table I.

The emphasis of our algorithms is to keep the clustering

structure of the sensor network. The algorithms to make

the structure follows on it. Though you may use a previous

algorithm to make the clustering, you should check what

information nodes have.

In a word, our clustering is not worse than a previous

results, and the main point of this paper is to keep the

structure but to make it.

II. A CLUSTER-BASED ARCHITECTURE

A. Definitions

We give definitions for some technical terms which will

be used throughout the paper. Let G = (V,E) be a directed

graph.

Bi-directional graph: A graph G is a bi-directional graph

if there is an edge from node u to node v, then there is an

edge from v to u.

Strongly connected component: A directed graph, in which

there exists at least one path from u to v for any two

distinct nodes u and v, is said to be strongly connected.

A strongly connected component C of a directed graph G

is a subgraph C = (V?,E?)(V?⊆ V and E?⊆ E) which

satisfies that no node of G can be added to C such that C

is strongly connected.

Induced subgraph: The graph H = (U,F), where U ⊆ V

and F is the set of all edges in G with both ends in U, is

called the subgraph of G induced by U, denoted by G[U].

In-neighbors: Node u is an in-neighbor of node v, if there

is a directed edge from node u to node v.

Independent set: An independent set of G is a set U ⊆ V

in which no pair of nodes are adjacent in G.

Maximal independent set (MIS): An independent set I of

nodes in a graph G such that no more nodes can be added

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

2

Page 3

and it still be an independent set.

Dominating set: A set D(⊆ V ) of nodes is a dominating

set of G if any node in G is either in D or the neighbor

of a node in D.

Tree: A connected bi-directional graph such that it is

acyclic when all bi-directional edges are replaced with

undirected ones.

Unit disk graph: A graph G is a unit disk graph if for each

edge (u,v) ∈ E, the Euclidean distance between u and v

is at most 1.

Since a bi-directional graph can be treated as an undi-

rected graph, in this paper, our networks are represented by

undirected graphs, and the figure of a graph and technical

terms also follow it (e.g. strongly connected component →

connected component).

B. Model of Sensor Networks

The model of a sensor network G in this paper is as

follows:

• Nodes repeat transmissions and receptions in synchro-

nized fixed intervals, called rounds. In each round,

each node acts as either a transmitter or a receiver.

• A node acting as a receiver in a given round gets a

message iff exactly one of its neighbors transmits in

this round. When more than one neighbor transmits

simultaneously in a given round, collision occurs and

none of the messages is received in this round. A node

can not notice the occurrence of a collision, i.e., there

is no collision detection in the network.

• Each node knows its ID, which is distinct for every

node.

C. A Cluster-based Sensor Network and Its Properties

Let G = (V,E) be a connected bi-directional graph. A

cluster of G is a star subgraph of G, where one node,

called a cluster head, has an edge to each other node

called as cluster member, and no edge exists between

any two cluster members in the cluster. A clustering of

G is to partition G into node disjoint clusters. The union

of the clusters produced by a clustering of G is denoted

as C(G) = (V,EC), where the edges of EC are those

between the cluster heads and their members. In order to

minimize the number of clusters, our clustering does not

allow two cluster heads to be neighbors with each other. In

other words, the set of the cluster heads in our clustering

is a maximal independent set in G. We consider a MIS

such that a graph induced by cluster heads (∈ MIS) and

the nodes with two or more neighboring cluster heads is

connected. Any two cluster heads are jointed through one

special cluster member called gateway node which is in an

intersection of neighbors in G of two cluster heads.

Clustering provides a flat graph G to a hierarchical

organization. A backbone of G is a connected subgraph

of G formed by only the cluster heads and the gateway

nodes, where a gateway node must connect two or more

cluster heads. Since heads can not be neighbors with each

other, any edge in a backbone must be formed between

a cluster head and a gateway node. As G is a connected

bi-directional graph, a backbone must exist. A backbone

tree of G, denoted as BT(G) = (VBT,EBT), is defined

to be a spanning tree of a backbone of G (see Fig.1).

: edge in CNet(G)

: cluster head

: gateway node

: cluster member

cluster

backbone tree BT(G)

: edge in G

Fig. 1.

G, BT(G), CNet(G)

Backbone tree BT(G) can be considered as a commu-

nication highway on G. To see this, let u and v be two

cluster members, and hu and hv be their cluster heads,

respectively. If u wants to send message to v, u first sends

the message to its cluster head hu. And hu sends the

message to hv via BT(G), then hv sends the message

to its cluster member v. A transmission between a cluster

head and its members is called local transmission and

a transmission between cluster heads is called backbone

transmission.

Now we use the backbone tree to connect the clusters

for forming a structured network on G. A cluster-based

network of G = (V,E) is a rooted tree CNet(G) =

(V,EBT∪ EC) with one cluster head as a root, where

the edges of EBT come from the backbone tree and the

edges of ECcome from all the clusters (see Fig 1). Since

gateway nodes are also cluster members, we call the cluster

members which are not gateway nodes as pure cluster

members. In CNet(G) a pure cluster member connects

only with its cluster head.

Lemma 1: Let G be a bidirectional graph and BT(G)

be a backbone tree of G. If BT(G) has p cluster heads,

then it has at most 2p − 1 nodes.

Proof: We define a red-connected-by-blue tree to be

a tree which contains only red and blue nodes, each blue

node connects two or more red nodes, and no edge exists

between any two red nodes. From the definition a blue

node can not be a leaf.

We prove the conclusion that if a red-connected-by-blue

tree has p red nodes, then it has at most 2p − 1 nodes

totally. Obviously, BT(G) is a red-connected-by-blue if

we consider cluster heads to be red and gateway nodes to

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

3

Page 4

be blue.

Let T be a red-connected-by-blue tree and have p red

nodes. If p = 1, T contains only one node which is red.

Therefore, the conclusion holds when p = 1. Assuming

that the conclusion holds when p = k, we prove the

conclusion holds for the case p = k + 1.

Let u be a leaf of T. Obviously, u is red and connected

with some blue node g in T. If g connects more than two

red nodes, then remove u from T. Otherwise, g connects

two red nodes in which one is u, and in this case we

remove both u and g from T. Obviously, no matter which

situation the resulted tree T?is a red-connected-by-blue

tree with k red nodes. From the induction assumption, |T?|

≤ 2k −1, therefore |T| ≤ 2k −1 + 2 = 2(k +1)−1.

Lemma 2: Let G be a bidirectional graph and CNet(G)

be a cluster-based network of G. The CNet(G) is a

spanning tree of G.

Proof: From the definition, CNet(G) contains all the

nodes of G which are either cluster heads, gateway nodes,

or pure cluster members. The cluster heads and gateway

nodes belong to a backbone tree. Therefore, if any path in

CNet(G) is a cycle there must be a pure cluster member

inside. It contradicts to the fact that in CNet(G) a pure

cluster member connects to only its cluster head.

Lemma 3: Let G be a bidirectional graph and pGbe the

smallest number of disjoint complete subgraphs of G. The

number of the clusters in CNet(G) is at most pG.

Proof:

From the definition of the clustering of G,

there is only one cluster head in one cluster, and the cluster

heads do not connect with each other. On the other hand,

any two nodes connect with each other in a complete graph.

Therefore, there is at most one cluster head exist in any

complete subgraph of G. Thus, the number of the cluster

in CNet(G) is at most pG.

Lemma 4: Let G = (V,E) be a unit disk graph, and

MDS(G) be the minimum dominating set of G. The

number of the clusters in a CNet(G) is not larger than

5 × |MDS(G)|.

Proof: We treat the nodes of G to be the points on

the plane. If x is a cluster head in the CNet(G), then x

can not have any cluster head as its neighbor. Otherwise,

we prove that for any node x in MDS(G) it can have at

most 5 cluster heads as its neighbors.

Assume that x has cluster heads u and v as its neighbors.

If? uxv ≤ 60◦, then

uv2= xu2+ xv2− 2xu xv cos? uxv < xu2+ xv2

− xu xv ≤ xu xv ≤ 1.

It is contradictory in u and v are cluster heads and their

distance is larger than 1. Therefore, x has at most 5 cluster

heads as its neighbors.

In the following sections, we will show how a flat

graph G can self-organize and self-maintain itself into a

cluster-based network CNet(G). Before we discuss the

algorithms, we first declare the data structure for CNet(G)

clearly.

A CNet(G) has two level structures: a set of clusters,

and a backbone tree which is used to connect the clusters.

Each node v in G maintains the information described

below:

• For each node v in CNet(G), it keeps a value v.stat

to denote v’s status as a cluster head, a gateway node

or a pure cluster member.

• For each node v in G, it keeps a node v.prt and a node

set v.chd to denote who are its parent and children

in CNet(G), respectively. For root r, r.prt = ⊥, and

for each pure cluster member m, m.chd = ∅.

• For each node v in G, it keeps a node set v.oneigh

to denote the neighbors of v in G except v.prt and

v.chd.

• For each node v in the backbone tree BT(G) (i.e., v

is either a cluster head or a gateway node), it keeps

a set v.bneigh to denote who are its neighbors in the

backbone tree.

• For each node v in G, it keeps status of its known

neighbors in G.

We call above information as total 1-hop data. When

the information are maintained for each node v in G, it is

called that G is organized with total 1-hop data.

Hereafter we use v.neigh as a node set which represents

neighbors of v in G, (i.e., v.neigh = {v.prt} ∪ v.chd ∪

v.oneigh).

We define two operations node-move-in and node-move-

out on a CNet(G).

• node-move-in: a new node v announces itself by

sending a message to join the existing CNet(G) and

the network re-organizes itself to a new CNet(G?),

where G?is the graph obtained by adding v to G.

• node-move-out: a node v of CNet(G) announces

itself by sending a message to leave the existing

CNet(G), and the network re-organizes itself to a

new CNet(G?), where G?is the graph obtained by

removing v from G.

Theorem 1: A CNet(G) can be formed statically and

dynamically in O(n) and O(?n

operation requires for an i-node graph.

Proof:

For statical construction we use a gossip

algorithm in [1]. After gossiping, each node has whole

information of G, then the graph of a same CNet(G) can

be constructed at each node. For dynamical construction,

we use node-move-in operation to add n nodes n times

(the condition is that every time the adding node should

be connected to the existing network).

Since our randomized node-move-in algorithm which

runs in O(q) expected time will be mentioned in IV-A,

where q is the number of neighbors of added node in the

i=1T(i)) time, respectively,

where T(i) is the number of rounds which node-move-in

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

4

Page 5

existing network, a CNet(G) can be formed dynamically

in O(|E|) expected time.

III. BROADCASTING

In this section, we present our broadcasting algorithm

using CNet(G).

In our algorithm, we use a broadcasting technique shown

in [1], and we call it as procedure Eulerian.

Eulerian(H) performs a broadcast on a bi-directional

graph H. A message called token starts from the source

node, visits every node and turns to the source node. At

the beginning, the token is in the source node. It then visits

each node in H from the source node in depth-first order.

When node v gets the token, it sends the token with the

message and its ID to one of its neighbors which have not

received the token yet. If v has no neighbor which has not

been visited by the token yet, v returns the token to the

node from which it got the token for the first time. The

movement of the token forms an Eulerian cycle of H. It

patrols every node in H and returns to the source node

finally.

Lemma 5:

[1]Let H = (V,E) be a bi-directional

graph. If each node of H knows all its neighbors in H,

procedure Eulerian(H) completes broadcasting for H in

O(|V |) rounds.

We now show our broadcasting algorithm Broad-

castALG in CNet(G), where s is the source node with

a message M and needs to be informed to the rest of the

nodes in a given network G.

A broadcasting in CNet(G) can be completed by per-

forming Eulerian on BT(G). Fig.2 shows our algorithm

BroadcastALG.

BroadcastALG

if source node s is a pure cluster member then

s sends source message M to s.prt;

s.prt calls procedure Eulerian(BT(G));

else

s calls procedure Eulerian(BT(G));

Fig. 2.BroadcastALG

Theorem 2: Let CNet(G) be a cluster-based network

of G, and p be the number of clusters in CNet(G). A

broadcasting on CNet(G) can be done in O(p) rounds.

Proof: In BT(G), each node, cluster heads or gate-

way node, knows its neighbors in BT(G). There are at

most 2p − 1 nodes in BT(G) from Lemma 1. If a source

node is a cluster head or a gateway node, a broadcasting

on BT(G) is completed in O(p) rounds from Lemma 5.

Since every cluster head in CNet(G) is in BT(G) and

participates in relaying the source message, all the cluster

members in CNet(G) receive the source message from

their cluster heads when they relay the source message on

BT(G). If the source node is a cluster member, it takes

one more round to send message to its cluster head. Hence,

a broadcasting from any node can be done in O(p) rounds.

Theorem 3: Let CNet(G) be a cluster-based network

of G, and p be the number of clusters in CNet(G). The

number of the nodes in G can be counted in O(p) rounds.

Proof: Each cluster head knows the cluster members

in CNet(G). Therefore, the number of nodes in CNet(G)

can be counted during broadcasting on BT(G).

IV. CONSTRUCTING CLUSTER-BASED SENSOR

NETWORK DYNAMICALLY

In this section we show two algorithms of node-move-

in and node-move-out respectively on CNet(G). The pro-

posed cluster-based structure is always maintained after

completing the operations of node-move-in or node-move-

out. Though we assume that atomic operations cannot be

performed simultaneously i.e., only one atomic operation

can be performed at a time, it is possible to schedule for

two or more simultaneous operations. When G is organized

with total 1-hop data, our first randomized algorithm for

a node-move-in operation and deterministic algorithm for

a node-move-out operation work in O(q) expected rounds

and O(|T|) rounds, respectively, where q is the number of

neighbors in G of the move-in node and T is a subtree

of CNet(G) with the leaving node as root. When G is

organized with partial 1-hop data, our second randomized

algorithm for a node-move-in operation and deterministic

algorithm for a node-move-out operation work in O(logq)

expected rounds and O(n) rounds, respectively, where n

is the number of nodes in G.

A. Node-move-in Algorithm

Let new be a node who wants to join a network G =

(V,E), and let G?= (V ∪ {new},E ∪ Enew) in this

subsection, where Enew= {(u,new)|u is in transmitting

range of the node new, u ∈ V }. Let |Enew| = q.

What should be performed by node-move-in is to decide

the status of new and update the information which the

neighbors of new in G?have.

To decide the status of new, new needs to know the

status of its neighbors. If there exist cluster heads in the

neighbors of new in G?, new selects one to be it’s head

and itself becomes a pure cluster member. Else if there

are gateway nodes in its neighbors, new selects one of

the gateway nodes as its gateway and becomes the cluster

head of a new cluster. If there are no cluster heads and no

gateway nodes in its neighbors, new becomes a cluster

head and sets one neighboring pure cluster member to

be the gateway of itself. Based on the status of new has

decided, the neighbors of new update their information.

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

5

Page 6

In no matter which cases, the process affects only 2-hop

neighbors of new in G?.

In order to determine the status of new and update

the information, it is sufficient that the neighbors of new

transmit their own IDs and status one by one. It can be

done by numbering the neighbors of new from 1 to q and

transmitting their information in order of the numbers.

Lemma 6: The neighbors of new can be numbered from

1 to q in O(q) expected rounds, where q is the number of

neighbors of new in G?.

Proof: By simulating the Initialization Protocol [7] on

a complete graph in O(1) rounds, it is possible to number

the nodes from 1 to q on a star graph with new as a

center node. (See APPENDIX A about how to simulate

the protocol).

Now, we present our node-move-in algorithm move-in-1

in Fig.3.

move-in-1

% (neighbor recognition)

The joining node new sends AddMe message;

The nodes receiving AddMe message are numbered

from 1 to q, and send their IDs and status to new

one by one;

% (new determines its status)

if there are cluster heads in the neighbors of new in G?

new sends I’mMember message to the cluster

head h with minimum ID;

new.stat := pure cluster member;

new.prt := h, h.chd := h.chd ∪ {new};

new adds its neighbors (other than h) and they

add new to their oneigh, respectively;

else if there are gateway nodes in the neighbors of

new in G?

new sends I’mHead message to the gateway

node g with minimum ID;

new.stat := cluster head;

new.prt := g, g.chd := g.chd ∪ {new};

new adds g and g adds new to its bneigh,

respectively;

new adds its neighbors (other than g) and they

add new to their oneigh, respectively;

else

new sends BeGateway message to one pure

cluster member m with minimum ID in its

neighbors in G?;

new.stat := cluster head, m.stat := gateway node;

new.prt := m, m.chd := m.chd ∪ {new};

new adds m and m adds new to own bneigh,

respectively;

new adds its neighbors (other than m) and they

add new to their oneigh, respectively;

m sends ChgGateway message to its neighbors

in G?;

m.prt adds m to its bneigh and neighbors in G?

of m change m’status into gateway node in their

information;

Fig. 3.move-in-1

Lemma 7: Let CNet(G) be a cluster-based network of

G. When G is organized with total 1-hop data, after an

execution of move-in-1 for a node new, G?is organized

with total 1-hop data.

Theorem 4: Let CNet(G) be a cluster-based network of

G, q be the number of neighbors of new in G?, and p be

the number of clusters in CNet(G). When G is organized

with total 1-hop data, node-move-in of new can be done

in O(q) expected rounds, and G?is organized with total

1-hop data.

Proof: In the node-move-in algorithm move-in-1, the

neighbors of new in G?can be numbered from 1 to q

in expected O(q) rounds by Lemma 6. After numbering

of the neighbors, they send their IDs and status. It takes

O(q) rounds. new sends its message in one round. Hence

the total time for the node-move-in algorithm move-in-1 is

O(q) expected rounds.

In the execution of move-in-1 only the neighbors of

new, and neighbors of the neighbors of new in CNet(G)

receive a message caused by node-move-in. Hence, node-

move-in can be performed locally in only 2-hop neighbors

of new without changing status of other nodes.

B. Node-move-out Algorithm

Here, we show our first node-move-out algorithm called

move-out-1. Let del be a node who wants to leave from

G and G?be the graph after del leaves, that is, G?=

G[V \{del}] in this subsection (“\” is substraction operator

of sets). We assume that both G and G?are connected.

It is possible to judge whether G?is connected in O(|T|)

rounds, where T = (V (T),E(T)) is a subtree of CNet(G)

with the leaving node del as the root (see Fig.4).

Our node-move-out algorithm is executed when del

wishes to leave from the network. If del is a pure cluster

member, it sends I’mLeaving message and simply leaves

from the network. Otherwise, the node-move-out algorithm

works as follows: First, we consider the case where del is

not the root of CNet(G). The case where del is the root is

described later. If del is a cluster head or a gateway node,

CNet(G) is divided into two subtrees. One is the tree T

with del as the root (not including the root in CNet(G)),

and one is the tree H with the root of CNet(G) as the

root. The algorithm move-out-1 removes del from T, and

adds other nodes of T to H so that the resulted tree is

CNet(G).

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

6

Page 7

T

del

root

CNet(G)

edge in G

Ci

C2

C1

v

v

v

H

Fig. 4.

CNet(G), a subtree T and connected components in T

Let Ci(i = 1,2,...) be the connected components of

G[V (T) \ {del}] (Fig.4). H always changes and grows

larger each time when a node in T is added to H.

The edges in G between T and H are used in order to

add the nodes of T to H. By using node-move-in operation

described in the previous section, the nodes in T can be

merged into H. Each node already knows its neighbors in

G and their status in CNet(G), therefore, a node-move-

in operation can be performed deterministically in O(1)

rounds. First, del calls Eulerian(T) to wake up each

node of T. Whenever the waken node v ∈ Cj has an

edge connected with H, v moves to H by move-in-1, then

v calls Eulerian(Cj) and each node in Cj moves to H

following v by move-in-1 one by one. The above process

will be repeated until all of the nodes in T other than del

are moved to H.

Here we describe about an exception, when del is a

root of CNet(G). If del.bneigh ?= ∅, electing a cluster

head which is connected with del by a gateway node and

setting it to a new root of CNet(G), our algorithm in

the general case can be used. Otherwise del is the only

cluster head in CNet(G), select one node in del.neigh

becomes the new root of CNet(G?). The new root calls

Eulerian(G[V \ {del}]) and a cluster-based network is

constructed sequentially by repeating node-move-in for the

node with token.

Our first node-move-out algorithm move-out-1 is de-

scribed in Fig.5.

move-out-1

% Let T = (V (T),E(T)) be a subtree of CNet(G)

% with root del;

% Let Ci(i = 1,2,...) be the connected components

% of G[V (T) \ {del}];

% Let H = G[V \ V (T)

%

∪{v|v∈V (T),v has called move-in-1}];

% Let t be a node with a token in Eulerian;

foreach v ∈ G

v.link := v.neigh;

del sends I’mLeaving message;

if del.stat = pure cluster member then

nodes that received I’mLeaving delete del from

neighbor list in G;

else

if del is a root of CNet(G) then

if del.bneigh = ∅ then exception; exit;

else change-root;

if del is a cluster head and |(del.prt).bneigh|=2

then

(del.prt).stat := pureclustermember;

del.prt sends ChgMember message to its neighbors

in G?, and its neighbors in G?change m’status

into pure cluster member in their information;

% Let T?:= T;

del calls Eulerian(T) which works as follows in

each round:

v.link := v.link \ {t} for each node v who

receives messages from t;

while there is a node in del.chd who has not

joined to H do

% find link;

del calls Eulerian(T?), and it works as follows

in each round:

if t.link ?= ∅ then the procedure finishes;

% node-move-in;

t ∈ Cjcalls Eulerian(Cj), and it works as

follows in each round:

t joins into H by the last step of move-in-1,

and each neighbor v of t adds t to v.link;

t sends the token back to del by Eulerian(T?);

nodes who have joined to H are removed from T?;

exception % (CNet(G) is a star)

del sends a message to one of its neighbors, denoted

by r, and r becomes the root and has a token (t := r);

r sends I’mRoot message and v.link := v.link ∪ {r}

for each neighbor v of r;

% Let G??:= G[{r}];

t calls Eulerian(G[G(V )\{del}]) which works as

follows in each round:

if t has not joined then

t joins into G??according to the status of nodes

in t.link like the last step of move-in-1, and

each neighbor v?of t adds t to v?.link;

change-root

del sends a message to a gateway node g in del.bneigh;

del.prt := g, g.chd := g.chd ∪ {del};

g sends a message to a cluster head h in its neighbors;

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

7

Page 8

g.prt := h, h.chd := h.chd ∪ {g};

h.prt := ⊥ and h becomes a root;

Fig. 5. move-out-1

Lemma 8: Let CNet(G) be a cluster-based network of

G. When G is organized with total 1-hop data, after an

execution of move-out-1 for a node del, G?is organized

with total 1-hop data.

Theorem 5: Let CNet(G) be a cluster-based network

of G, p be the number of clusters in CNet(G) and T be

the subtree of CNet(G) with the leaving node del as root.

When G is organized with total 1-hop data, node-move-out

of del can be done in O(|T|) rounds, and G?is organized

with total 1-hop data.

Proof:

del calls Eulerian(T) so that each node

knows its neighbors in T. Next, Eulerian(G[V \V (H)\

{del}]) is called to find the edge (u,v), u / ∈ V (H),

v ∈ V (H), and to make each node in T join to H. These

calls of Eulerian takes O(|T|) rounds.

When del is a root in CNet(G) and del.bneigh =

∅, del calls Eulerian(T) once and each node joins in

some round during the procedure. It takes O(T) rounds.

Otherwise, if del is a root in CNet(G), replacing the role

of del by other cluster head can be done in O(1) rounds.

Then each node in T joins to H as already mentioned

above.

So, a node-move-out can be done in O(|T|) rounds.

Only nodes in T, their neighbors in G and neighbors of

them in G receive messages during execution of move-out-

1. Hence, node-move-out can be performed locally without

changing other part of CNet(G).

C. Trade-off of Time and Information

In this subsection, we consider networks where node-

move-in operations are performed more frequently than

node-move-out operations. We reduce the amount of in-

formation each node maintains in order to reduce the

running time of node-move-in algorithms. If node v does

not maintain oneigh, the neighbor list of v in G, node-

move-in operation will be faster. Given a graph G, when

v.stat, v.prt, v.chd, v.bneigh (called partial 1-hop data)

are maintained for each node v in G, we say that G is

organized with partial 1-hop data.

1) Node-move-in Algorithm with Less Information: Let

new be a node who wants to join a network, and let G?=

(V ∪{new},E∪Enew) in this subsection, where Enew=

{(u,new)|u is in transmitting range of the node new, u ∈

V }. Let |Enew| = q. Operation node-move-in has been

already described in subsection IV-A. First, a node new

who wants to join a network confirms whether there is a

cluster head in its neighbors in G?and if not any, whether

there is a gateway node in them. Then new elects a leader

of them and sets its status. After status of new is decided,

the neighbors of new update their information according to

the status. In no matter which cases, the operation does not

affect other than the neighbors of new and the neighbors

of them (i.e., 2-hop neighbors) like move-in-1.

Here we show how to check the status of the neighbors

of new in G?. One leader is first elected from the neighbors

of new in G?. If the leader is not a cluster head, the leader

and new’s neighbor cluster heads in G?send their IDs in

one round. Assume that every node v ∈ S, S = {the leader

(not a cluster head)} ∪ {neighbor cluster heads of new in

G?}, sends its ID at some round t. If new receives an ID at

round t, it means |S| = 1, i.e., S contains only the leader,

and there is no cluster head in neighbors of new in G?. Else

if new receives no ID at round t, |S| ≥ 2, i.e., there exists

at least one cluster head. new can also check about gateway

nodes similarly. Then, if there are neighbor cluster heads,

new elects a leader from them, else if there are gateway

nodes, new elects one leader from them, else new elects

one leader from neighbor pure cluster member, and updates

its status and then the information are maintained.

Now we show the node-move-in algorithm move-in-2 in

Fig.6.

move-in-2

the new node new sends AddMe message;

one leader is elected from nodes that have received

AddMe message by calling procedure SelectWinner

(mentioned later);

let w be the leader;

w sends its status to new;

if w is a cluster head then

new sends I?mMember message to w;

new becomes a pure cluster member of w;

else

h := chkstatus(w, cluster head)

if h ?= ⊥ then % (Neighbor cluster heads exist)

new sends I?mMember message to h and

becomes a pure cluster member of h;

else if new received w.id and w is a gateway node

then

new sends I?mHead message to w and becomes

a cluster head;

else

g := chkstatus(w, gateway node)

if g ?= ⊥ then % (Neighbor gateway nodes exist)

new sends I?mHead message to g and

becomes a cluster head;

else % (Neighbors of new in G?are

% all pure cluster members)

new sends BeGateway message to w;

new becomes a cluster head and w becomes

a gateway node;

w informs the change of its status to its

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

8

Page 9

neighbors in G;

chkstatus(w, status)

new sends chk-status message;

node w and all neighbors of new with status send

their IDs in one round;

if new does not received w.id then

% (a node with status exists)

new sends Select-status message;

one leader l is elected from nodes with status

who received Select-status;

return l;

else % (no node with status exists)

return ⊥;

Fig. 6.move-in-2

Here we show the SelectWinner procedure in Fig.7

which is used to elect a leader in move-in-2.

In this procedure, all nodes receiving AddMe message

toss a coin ?tj? (j = 1,2,...) times to select a single

winner, where t is going to be determined later. If “head”

comes, the nodes are in the race, otherwise keep silent.

SelectWinner

j := 0;

while(1) do

for i := 1 to ?tj? do

Each node tosses a coin;

All nodes that tossed “head” transmit their IDs

to the new node new, and all nodes that tossed

“tail” keep silent during the procedure;

if new receives the winner’s ID then

new informs its ID to all its neighbors;

return;

else

new waits one round;

j := j + 1;

Fig. 7.SelectWinner

O(logq) times of tossing are expected until a winner is

decided, where q is the number of the neighbors of new

(see [6]).

Lemma 9: Let CNet(G) be a cluster-based network of

G. When G is organized with partial 1-hop data, after an

execution of move-in-2 for a node new, G?is organized

with partial 1-hop data.

Proof: The proof is similar to that of Lemma 7.

Theorem 6: Let CNet(G) be a cluster-based network of

G, q be the number of neighbors of new in G?, and p be

the number of clusters in CNet(G). When G is organized

with partial 1-hop data, node-move-in of new can be done

in O(logq) expected rounds, and G?is organized with total

1-hop data.

Proof:

In order to determine a winner the time

requirement is O(logq) expected rounds (see [6]). Since

only procedure SelectWinner is called at most twice, the

total time for the joining algorithm is O(logq) expected

rounds.

A joining of a node can be locally performed like move-

in-1.

2) Node-move-out Algorithm with Less Information:

Here we show our node-move-out algorithm move-out-2.

Let del be a node who wants to leave from a network and

G?= G[V \ {del}] in this subsection. We assume that G

is connected before and after del leaves.

Since the difference between total 1-hop data and partial

1-hop data is whether each node in G knows its oneigh, if

each node can know its oneigh list, node-move-out can be

performed dynamically using move-out-1 aforementioned.

To know oneigh for each node, Eulerian(CNet(G)) is

performed. During the procedure each node in CNet(G)

sends their IDs and status, so that all nodes in G know

their oneigh in G.

Our node-move-out algorithm move-out-2 is shown in

Fig.8.

move-out-2

del calls Eulerian(CNet(G)) and each node of G

knows all its neighbors in G;

del calls move-out-1;

Fig. 8. move-out-2

Lemma 10: Let CNet(G) be a cluster-based network of

G. When G is organized with partial 1-hop data, after an

execution of move-out-2 for node del, G?is organized with

partial 1-hop data.

Proof: During Eulerian(CNet(G)) each node re-

ceives all its neighbors’ IDs and status in G since every

node sends own ID and status and only one node acts as

transmitter for any round in the procedure. The rest of the

proof is the same as one for Lemma 8.

Theorem 7: Let CNet(G) be a cluster-based network

of G. When G is organized with partial 1-hop data, node-

move-out of del can be done in O(n) rounds.

Proof: First, O(n) rounds are required for a call of

Eulerian(CNet(G)). Then move-out-1 is called. It takes

O(|T|) rounds from Theorem 5. So, leaving of a node can

be done in O(n) rounds.

It is open whether a node-move-out operation can be

done faster in the cluster-based network.

V. CONCLUSIONS

In this paper we have proposed a new architecture of

sensor networks in which broadcasting can be done in

O(p) rounds. In order to support dynamic changes of

the architecture we used two operations node-move-in and

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

9

Page 10

node-move-out. To add a new node, we have presented

two different randomized algorithms working in expected

rounds O(q) and O(logq), and to remove a node, our

algorithms work in rounds O(|T|) and O(n), depending

on the network information available to the nodes. It will

be interesting to find the lower bound of node-move-in and

node-move-out in our proposed new architecture.

ACKNOWLEDGEMENT

This work is supported in part by grant ARO W911NF-

04-2-0049, U.S.A., the Japan Society for the Promo-

tion of Science, Grant-in-Aid for Scientific Research(C),

17500036, and for Young Scientists (B), 16700010, 2004

and the Telecommunication Advancement Foundation in

2005.

APPENDIX

A. SIMULATING THE INITIALIZATION PROTOCOL

For a given n-node network, Initialization is to give a

unique ID ranging from 1 to n for a set of nodes.

We simulate the Initialization Protocol called Protocol

for Unknown n: The No-Collision Detection Case in [7].

In the process of this Initialization protocol, every node

can send its ID without collision.

The network in [7], denoted by IN, differs from our

model in the following:

• IN is sigle-hop (IN is an n-node complete graph).

• Each node can receive its own message (if no colli-

sion).

• Each node has no ID.

Suppose that the nodes in a subset P transmit. Each node

v in IN gets in each round as follows:

• |P| = 1 (including the case that v ∈ P).

• |P| = 0 or |P| ≥ 2.

that is, (i) only v transmits or (ii) other node transmits or

(iii) two or more nodes transmits or no node transmit.

Our network can simulate one round of the IN in two

rounds. In other words, it can determine whether “|P| = 1

(even whether v ∈ P or not)” or “|P| = 0 or |P| ≥ 2”.

Let new be a joining node. Each round in IN is simulated

as follows (Fig 9):

simulate IN

1. v ∈ P sends v.id;

2. if new receive ID i in previous round then

new sends i;

else

new waits;

Fig. 9. simulation of IN

Each node v can determine whether “|P| = 1 (including

the case that v ∈ P)” or “|P| = 0 or |P| ≥ 2” according

to the message received in the second step in Fig 9.

Case1: v received its own ID. Then, |P|=1 and v∈P.

Case2: v received other’s ID. Then, |P|=1 and v / ∈ P.

Case3: v received no message. Then, |P|=0 or |P|≥2.

Thus, it is sufficient to simulate IN in two rounds.

REFERENCES

[1] B.S. Chlebus, L. Ga ¸sieniec, A.M. Gibbons, A. Pelc, and W. Rytter.

Deterministic broadcasting in ad hoc radio networks. Distributed

Computing 15, pages 27–38, 2002.

[2] D. Dubhashi, A .Mei, A. Panconesi, J. Radhakrishnan, A. Srini-

vasan, Fast distributed algorithms for (weakly) connected dominat-

ing sets and linear-size skeletons, Proceedings of the 14th Annual

ACM-SIAM Symposium on Discrete Algorithms, pp. 717–724, 2003.

[3] F. Kuhn, T. Moscibroda, T. Wattenhofer, Initializing Newly De-

ployed Ad Hoc and Sensor Networks, in Proceedings of 10 An-

nual International Conference on Mobile Computing and Network-

ing(MOBICOM), 2004.

[4] I. Chlamtac, A. Farago., A new approach to the design and analysis

of peer-to-peer mobile networks, Wireless Networks, vol. 5, no. 3,

pp. 149–156, 1999.

[5] J. Wu and H. Li, On calculating connected dominating set for

efficient routing in ad hoc wireless networks, Telecommunication

Systems, vol. 18, no. 1/3, pp. 13–36, 2001.

[6] Jiro Uchida, Islam A.K.M. Muzahidul, Yoshiaki Katayama, Wei

Chen, and Koichi Wada, Construction and Maintenance of a Cluster-

based Architecture for Sensor Networks, Dept. of Computer Science

and Engineering, Nagoya Institute of Technology, Wada-Inuzuka

Lab, TR2005-01, 2005.

[7] K. Nakano and S. Olariu. Randomized initialization protocols

for radio networks. Handbook of wireless networks and mobile

computing, pp.195–218, 2002.

[8] P.-J. Wan, K. M. Alzoubi, and O. Frieder, Distributed construction

of connected dominating sets in wireless ad networks, ACM/Kluwer

Mobile Networks and Applications, MONET, bol. 9, no.2, pp. 141–

149, 2004.

[9] R. Bar-Yehuda, O. Goldreich, and A. Itai, On the time-complexity of

broadcast in radio networks: an exponential gap between determin-

ism and randomization, Journal of Computer and System Science,

no. 45, pp. 104–126, 1992.

[10] S. Basagni, Distributed clustering for ad hoc networks, Proceedings

of the 1999 International Symposium on Parallel Architectures,

Algorithms, and Network, pp. 310–315, 1999.

[11] S. Basagni, M. Mastrogiovanni, C. Petrioli, A performance com-

parison of protocols for clustering and backbone formation in large

scale ad hoc networks, The 1st Internatinal Conderence on Mobile

Ad-hoc and Sensor Systems, pp.70-79, 2005.

Proceedings of the 39th Hawaii International Conference on System Sciences - 2006

10