\documentclass[11pt,twoside]{article}\makeatletter

\IfFileExists{xcolor.sty}%
  {\RequirePackage{xcolor}}%
  {\RequirePackage{color}}
\usepackage{colortbl}
\usepackage{wrapfig}
\usepackage{ifxetex}
\ifxetex
  \usepackage{fontspec}
  \usepackage{xunicode}
  \catcode`⃥=\active \def⃥{\textbackslash}
  \catcode`❴=\active \def❴{\{}
  \catcode`❵=\active \def❵{\}}
  \def\textJapanese{\fontspec{Noto Sans CJK JP}}
  \def\textChinese{\fontspec{Noto Sans CJK SC}}
  \def\textKorean{\fontspec{Noto Sans CJK KR}}
  \setmonofont{DejaVu Sans Mono}
  
\else
  \IfFileExists{utf8x.def}%
   {\usepackage[utf8x]{inputenc}
      \PrerenderUnicode{–}
    }%
   {\usepackage[utf8]{inputenc}}
  \usepackage[english]{babel}
  \usepackage[T1]{fontenc}
  \usepackage{float}
  \usepackage[]{ucs}
  \uc@dclc{8421}{default}{\textbackslash }
  \uc@dclc{10100}{default}{\{}
  \uc@dclc{10101}{default}{\}}
  \uc@dclc{8491}{default}{\AA{}}
  \uc@dclc{8239}{default}{\,}
  \uc@dclc{20154}{default}{ }
  \uc@dclc{10148}{default}{>}
  \def\textschwa{\rotatebox{-90}{e}}
  \def\textJapanese{}
  \def\textChinese{}
  \IfFileExists{tipa.sty}{\usepackage{tipa}}{}
\fi
\def\exampleFont{\ttfamily\small}
\DeclareTextSymbol{\textpi}{OML}{25}
\usepackage{relsize}
\RequirePackage{array}
\def\@testpach{\@chclass
 \ifnum \@lastchclass=6 \@ne \@chnum \@ne \else
  \ifnum \@lastchclass=7 5 \else
   \ifnum \@lastchclass=8 \tw@ \else
    \ifnum \@lastchclass=9 \thr@@
   \else \z@
   \ifnum \@lastchclass = 10 \else
   \edef\@nextchar{\expandafter\string\@nextchar}%
   \@chnum
   \if \@nextchar c\z@ \else
    \if \@nextchar l\@ne \else
     \if \@nextchar r\tw@ \else
   \z@ \@chclass
   \if\@nextchar |\@ne \else
    \if \@nextchar !6 \else
     \if \@nextchar @7 \else
      \if \@nextchar (8 \else
       \if \@nextchar )9 \else
  10
  \@chnum
  \if \@nextchar m\thr@@\else
   \if \@nextchar p4 \else
    \if \@nextchar b5 \else
   \z@ \@chclass \z@ \@preamerr \z@ \fi \fi \fi \fi
   \fi \fi  \fi  \fi  \fi  \fi  \fi \fi \fi \fi \fi \fi}
\gdef\arraybackslash{\let\\=\@arraycr}
\def\@textsubscript#1{{\m@th\ensuremath{_{\mbox{\fontsize\sf@size\z@#1}}}}}
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\def\abbr{}
\def\corr{}
\def\expan{}
\def\gap{}
\def\orig{}
\def\reg{}
\def\ref{}
\def\sic{}
\def\persName{}\def\name{}
\def\placeName{}
\def\orgName{}
\def\textcal#1{{\fontspec{Lucida Calligraphy}#1}}
\def\textgothic#1{{\fontspec{Lucida Blackletter}#1}}
\def\textlarge#1{{\large #1}}
\def\textoverbar#1{\ensuremath{\overline{#1}}}
\def\textquoted#1{‘#1’}
\def\textsmall#1{{\small #1}}
\def\textsubscript#1{\@textsubscript{\selectfont#1}}
\def\textxi{\ensuremath{\xi}}
\def\titlem{\itshape}
\newenvironment{biblfree}{}{\ifvmode\par\fi }
\newenvironment{bibl}{}{}
\newenvironment{byline}{\vskip6pt\itshape\fontsize{16pt}{18pt}\selectfont}{\par }
\newenvironment{citbibl}{}{\ifvmode\par\fi }
\newenvironment{docAuthor}{\ifvmode\vskip4pt\fontsize{16pt}{18pt}\selectfont\fi\itshape}{\ifvmode\par\fi }
\newenvironment{docDate}{}{\ifvmode\par\fi }
\newenvironment{docImprint}{\vskip 6pt}{\ifvmode\par\fi }
\newenvironment{docTitle}{\vskip6pt\bfseries\fontsize{22pt}{25pt}\selectfont}{\par }
\newenvironment{msHead}{\vskip 6pt}{\par}
\newenvironment{msItem}{\vskip 6pt}{\par}
\newenvironment{rubric}{}{}
\newenvironment{titlePart}{}{\par }

\newcolumntype{L}[1]{){\raggedright\arraybackslash}p{#1}}
\newcolumntype{C}[1]{){\centering\arraybackslash}p{#1}}
\newcolumntype{R}[1]{){\raggedleft\arraybackslash}p{#1}}
\newcolumntype{P}[1]{){\arraybackslash}p{#1}}
\newcolumntype{B}[1]{){\arraybackslash}b{#1}}
\newcolumntype{M}[1]{){\arraybackslash}m{#1}}
\definecolor{label}{gray}{0.75}
\def\unusedattribute#1{\sout{\textcolor{label}{#1}}}
\DeclareRobustCommand*{\xref}{\hyper@normalise\xref@}
\def\xref@#1#2{\hyper@linkurl{#2}{#1}}
\begingroup
\catcode`\_=\active
\gdef_#1{\ensuremath{\sb{\mathrm{#1}}}}
\endgroup
\mathcode`\_=\string"8000
\catcode`\_=12\relax

\usepackage[a4paper,twoside,lmargin=1in,rmargin=1in,tmargin=1in,bmargin=1in,marginparwidth=0.75in]{geometry}
\usepackage{framed}

\definecolor{shadecolor}{gray}{0.95}
\usepackage{longtable}
\usepackage[normalem]{ulem}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{marginnote}

\renewcommand{\@cite}[1]{#1}


\renewcommand*{\marginfont}{\itshape\footnotesize}

\def\Gin@extensions{.pdf,.png,.jpg,.mps,.tif}

  \pagestyle{fancy}

\usepackage[pdftitle={},
 pdfauthor={}]{hyperref}
\hyperbaseurl{}

	 \paperwidth210mm
	 \paperheight297mm
              
\def\@pnumwidth{1.55em}
\def\@tocrmarg {2.55em}
\def\@dotsep{4.5}
\setcounter{tocdepth}{3}
\clubpenalty=8000
\emergencystretch 3em
\hbadness=4000
\hyphenpenalty=400
\pretolerance=750
\tolerance=2000
\vbadness=4000
\widowpenalty=10000

\renewcommand\section{\@startsection {section}{1}{\z@}%
     {-1.75ex \@plus -0.5ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large\bfseries}}
\renewcommand\subsection{\@startsection{subsection}{2}{\z@}%
     {-1.75ex\@plus -0.5ex \@minus- .2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large}}
\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
     {-1.5ex\@plus -0.35ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\large}}
\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
     {-1ex \@plus-0.35ex \@minus -0.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\normalsize}}
\renewcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
     {1.5ex \@plus1ex \@minus .2ex}%
     {-1em}%
     {\reset@font\normalsize\bfseries}}


\def\l@section#1#2{\addpenalty{\@secpenalty} \addvspace{1.0em plus 1pt}
 \@tempdima 1.5em \begingroup
 \parindent \z@ \rightskip \@pnumwidth 
 \parfillskip -\@pnumwidth 
 \bfseries \leavevmode #1\hfil \hbox to\@pnumwidth{\hss #2}\par
 \endgroup}
\def\l@subsection{\@dottedtocline{2}{1.5em}{2.3em}}
\def\l@subsubsection{\@dottedtocline{3}{3.8em}{3.2em}}
\def\l@paragraph{\@dottedtocline{4}{7.0em}{4.1em}}
\def\l@subparagraph{\@dottedtocline{5}{10em}{5em}}
\@ifundefined{c@section}{\newcounter{section}}{}
\@ifundefined{c@chapter}{\newcounter{chapter}}{}
\newif\if@mainmatter 
\@mainmattertrue
\def\chaptername{Chapter}
\def\frontmatter{%
  \pagenumbering{roman}
  \def\thechapter{\@roman\c@chapter}
  \def\theHchapter{\roman{chapter}}
  \def\thesection{\@roman\c@section}
  \def\theHsection{\roman{section}}
  \def\@chapapp{}%
}
\def\mainmatter{%
  \cleardoublepage
  \def\thechapter{\@arabic\c@chapter}
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \pagenumbering{arabic}
  \setcounter{secnumdepth}{6}
  \def\@chapapp{\chaptername}%
  \def\theHchapter{\arabic{chapter}}
  \def\thesection{\@arabic\c@section}
  \def\theHsection{\arabic{section}}
}
\def\backmatter{%
  \cleardoublepage
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \setcounter{secnumdepth}{2}
  \def\@chapapp{\appendixname}%
  \def\thechapter{\@Alph\c@chapter}
  \def\theHchapter{\Alph{chapter}}
  \appendix
}
\newenvironment{bibitemlist}[1]{%
   \list{\@biblabel{\@arabic\c@enumiv}}%
       {\settowidth\labelwidth{\@biblabel{#1}}%
        \leftmargin\labelwidth
        \advance\leftmargin\labelsep
        \@openbib@code
        \usecounter{enumiv}%
        \let\p@enumiv\@empty
        \renewcommand\theenumiv{\@arabic\c@enumiv}%
	}%
  \sloppy
  \clubpenalty4000
  \@clubpenalty \clubpenalty
  \widowpenalty4000%
  \sfcode`\.\@m}%
  {\def\@noitemerr
    {\@latex@warning{Empty `bibitemlist' environment}}%
    \endlist}

\def\tableofcontents{\section*{\contentsname}\@starttoc{toc}}
\parskip0pt
\parindent1em
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\newenvironment{reflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemsep}{0pt}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\itshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{sansreflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\itemsep}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\upshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{specHead}[2]%
 {\vspace{20pt}\hrule\vspace{10pt}%
  \phantomsection\label{#1}\markright{#2}%

  \pdfbookmark[2]{#2}{#1}%
  \hspace{-0.75in}{\bfseries\fontsize{16pt}{18pt}\selectfont#2}%
  }{}
      \def\TheFullDate{2016 2016-01-15 (revised: 7 Year 2016 15 January 2016)}
\def\TheID{\makeatother }
\def\TheDate{2016 2016-01-15}
\title{}
\author{}\makeatletter 
\makeatletter
\newcommand*{\cleartoleftpage}{%
  \clearpage
    \if@twoside
    \ifodd\c@page
      \hbox{}\newpage
      \if@twocolumn
        \hbox{}\newpage
      \fi
    \fi
  \fi
}
\makeatother
\makeatletter
\thispagestyle{empty}
\markright{\@title}\markboth{\@title}{\@author}
\renewcommand\small{\@setfontsize\small{9pt}{11pt}\abovedisplayskip 8.5\p@ plus3\p@ minus4\p@
\belowdisplayskip \abovedisplayskip
\abovedisplayshortskip \z@ plus2\p@
\belowdisplayshortskip 4\p@ plus2\p@ minus2\p@
\def\@listi{\leftmargin\leftmargini
               \topsep 2\p@ plus1\p@ minus1\p@
               \parsep 2\p@ plus\p@ minus\p@
               \itemsep 1pt}
}
\makeatother
\fvset{frame=single,numberblanklines=false,xleftmargin=5mm,xrightmargin=5mm}
\fancyhf{} 
\setlength{\headheight}{14pt}
\fancyhead[LE]{\bfseries\leftmark} 
\fancyhead[RO]{\bfseries\rightmark} 
\fancyfoot[RO]{}
\fancyfoot[CO]{\thepage}
\fancyfoot[LO]{\TheID}
\fancyfoot[LE]{}
\fancyfoot[CE]{\thepage}
\fancyfoot[RE]{\TheID}
\hypersetup{citebordercolor=0.75 0.75 0.75,linkbordercolor=0.75 0.75 0.75,urlbordercolor=0.75 0.75 0.75,bookmarksnumbered=true}
\fancypagestyle{plain}{\fancyhead{}\renewcommand{\headrulewidth}{0pt}}

\date{}
\usepackage{authblk}

\providecommand{\keywords}[1]
{
\footnotesize
  \textbf{\textit{Index terms---}} #1
}

\usepackage{graphicx,xcolor}
\definecolor{GJBlue}{HTML}{273B81}
\definecolor{GJLightBlue}{HTML}{0A9DD9}
\definecolor{GJMediumGrey}{HTML}{6D6E70}
\definecolor{GJLightGrey}{HTML}{929497} 

\renewenvironment{abstract}{%
   \setlength{\parindent}{0pt}\raggedright
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
   \textcolor{GJBlue}{\large\bfseries\abstractname\space}
}{%   
   \vskip8pt
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
}

\usepackage[absolute,overlay]{textpos}

\makeatother 
      \usepackage{lineno}
      \linenumbers
      
\begin{document}

             \author[1]{Mevlut  Bulut}

             \affil[1]{  University of Alabama at  Birmingham}

\renewcommand\Authands{ and }

\date{\small \em Received: 15 December 2015 Accepted: 31 December 2015 Published: 15 January 2016}

\maketitle


\begin{abstract}
        


space, computational overhead, and number of accessed memory locations.For all the graphical descriptions, only Complete Binary Tree (CBT) structures will be used throughout the article, however the introduced concepts can be applied to other types of trees as well.The bottom-up update mechanism can simply be described as a unilateral traversing of the nodes from a leaf host to the root. Unlike the bilateral update mechanism, which is based upon comparing two sister node contents followed by the registration of the winner in the parent node, the unilateral update mechanism requires that the overall winner of the previously done consecutive comparisons should be compared to the content of the parent node. If the parent node content is not the winner of this comparison, then the consecutive parent nodes are checked until a parent node content wins, at which point the winner item and the parent node content are swapped. The iteration of this procedure goes on until the root node is reached, where the global winner is registered.This article introduces a modified bottom-up update mechanism which differs from the previously suggested unilateral implementations [2] in terms of the required auxiliary memory space, the initial update technique, and the overhead reduction during the update operations thanks to the elimination of the redundant nodes from CBTs. As a result, the overall implementation of a bottom-up update operation gets simpler, lighter, and faster. II.

\end{abstract}


\keywords{data structure, complete binary tree, CBT, sCBT, unilateral update, bottom-up update, replacement selection.}

\begin{textblock*}{18cm}(1cm,1cm) % {block width} (coords) 
\textcolor{GJBlue}{\LARGE Global Journals \LaTeX\ JournalKaleidoscope\texttrademark}
\end{textblock*}

\begin{textblock*}{18cm}(1.4cm,1.5cm) % {block width} (coords) 
\textcolor{GJBlue}{\footnotesize \\ Artificial Intelligence formulated this projection for compatibility purposes from the original article published at Global Journals. However, this technology is currently in beta. \emph{Therefore, kindly ignore odd layouts, missed formulae, text, tables, or figures.}}
\end{textblock*}


\let\tabcellsep& 	 	 		 
\section[{I. Introduction}]{I. Introduction}\par
t the center of the modern programming paradigm rises the art of obtaining the maximum performance out of a given computer system with limited resources, e.g. computational power, memory or I/O operation capabilities. In designing comparison based algorithms such as searching and sorting, in order to circumvent these limitations, tree formation was suggested a long time ago \hyperref[b0]{[1]} and it has been widely used since then. The main idea of forming a tree or treating a given array as a tree is to minimize the number of comparisons as close to the theoretical minimum as possible. Although there are many different techniques for the formation (or branching), setup (usage of nodes and node hierarchy), traversing (topdown, bottom-up; preorder, in order, etc.), and initialization of trees (recursive and iterative) new attempts are still being made to improve the efficiencies of these algorithms by optimizing the usage of the limited resources.\par
As explained in the next section, a new definition for the root node together with a new geometric interpretation of tree formation is proposed. Although the introduced novelties do not change the number of comparisons for the basic tree operations, it brings considerable reduction in required memory A Bottom-Up Update Mechanism for Re-Structured Complete Binary Trees Abstract-This paper introduces a bottom-up update mechanism together with a non-recursive initial update procedure that reduces the required extra memory space and computational overhead. A new type of tree is defined based on a different geometrical interpretation of Complete Binary Trees. The new approach paves the way for a special and practical initialization of the tree, which is a prerequisite for an implementation of unilateral update operation. The details of this special initialization and the full update procedures are made between the introduced update method and the bilateral update methods in terms of different performance related metrics.\par
given for Complete Binary Trees. In addition, a comparison is Analogous to real trees, the definition of an abstract tree with a stem is suggested (Figure \hyperref[fig_0]{-1}).The zeroth node is placed at the end of the stem and utilized as the root of the tree. A CBT with such a structure can be called a stemmed CBT (like most of the trees in the real world). Any Stemmed CBT (sCBT) can be decomposed into smaller sCBTs. In this regard, the smallest sCBT shell encompass two nodes, one of which characterizes the body of the tree and the other one is the root. This definition leads to a new way to compose and decompose a given tree. Figure-2depicts how two minimal sCBTs are combined together. One can decompose a given sCBT along a path from a leaf node to the root. In cases, the sCBT is utilized for replacement selection \hyperref[b2]{[3]} or priority queue applications \hyperref[b3]{[4]} then the logic dictates the path of the overall winner to be chosen as the decomposition path. The decomposition will be outlined in the 'initial update' section. 
\section[{Global Journal of Computer Science and Technology}]{Global Journal of Computer Science and Technology}\par
Volume XVI Issue III Version I    
\section[{III. Unilateral Update Versus Bilateral Update}]{III. Unilateral Update Versus Bilateral Update}\par
A CBT setup with loser elements rather than winner elements was first suggested by \hyperref[b4]{[5]} with a coined name 'loser tree', as opposed to 'winner tree', based upon the fact that each and every key appearing in an internal node is a loser exactly once, champion being the only exception. Although they are all losers exactly once, they are the winners of all comparisons up to their current levels. This property is not so different from the case of so called 'winner tree' setup. The logic is the same: both of them promote the winner towards the root. Therefore, there is no point for calling one of them a 'loser tree' and the other one a 'winner tree'. The difference between these two tree setups is that their geometries are different. The difference is dictated by the geometry not by the selection procedure. Therefore, 'winner tree' and 'loser tree' naming convention is abandoned here, instead CBT and sCBT are used to imply the two different geometries and the corresponding bilateral and unilateral update mechanisms respectively. The comparison operation can be regarded as a procedure to compose two sub-trees.  IV. Initial Update The new idea about initializing an sCBT is that the global tree can be thought of as a composition of already initialized smaller sCBTs. There are two different ways an initialized sCBT can be achieved:\par
1. Start with the maximum number (N/4) of minimal sCBTs at the lowest level of the tree; grow them independently while merging them as necessary.\par
2. Start with a minimal sCBT, enlarge it by adding two new leaves and update the obtained sCBT, and repeat this operation until the targeted sCBT size is reached.\par
update, the root (the zeroth node) contains the index of the winner element of the given key array and all the by the color coded update paths. Initializing an sCBT consisting of just two nodes requires only one comparison between the two leaves hanging from the only body node of this sCBT. After the comparison, the loser is stored in the lower node, while the winner is stored in the upper node. When all depth-1(below the root node, there is only one node) sCBTs are initialized, then the initialization of depth-2 sCBTs starts. To initialize a depth-2 sCBT, we start comparing the two new leaves that come into the picture when we grow the previously initialized depth-1 sCBT into a depth-2 sCBT. The loser of this comparison is stored into the first parent of these leaves and the winner is kept at hand to be compared to the content of the next parent node (which was the winner of the depth-1 sCBT). If it loses the comparison against the content of the next parent An sCBT is said to be properly initialized only if every node along the winner path hosts the winner of the corresponding sub-sCBT (a node can be the root of either the left or the right block; whichever side hosts the content of the root constitutes the body of the sub-sCBT) and every sub-sCBT also exhibits this same property. Figure-5 depicts the way we can see a properly initialized sCBT. We regard the initialized sCBT as consisted of smaller sCBTs along the path of the winner key, from the winner leaf to the root. All the node contents that lose against the winner are the winners of their own sub-sCBTs. other nodes contain the indexes of the winner elements of their own sub-sCBTs. Figure \hyperref[fig_6]{-6}  
\section[{visualizes this method}]{visualizes this method}\par
In the first way, initialization starts with the noninterfering minimal sCBTs at the bottom of the sCBT and proceeds upward by growing and/or combining them until the whole tree size is reached. Following the initial  The advantage of the second technique is that all sub sCBTs can be processed in a single loop. Depending on the node hierarchy being used, there are some cases where this second technique becomes faster and easier to implement. However, for the simple node hierarchy used throughout this article, the implementation of the first technique proves to be more efficient. 
\section[{Global Journal of Computer Science and Technology}]{Global Journal of Computer Science and Technology}\par
Volume XVI Issue III Version I node, they are swapped and the one next parent node will host the winner leaf index of the whole depth-2 sCBT (green update paths inFigure-6). Then the procedure goes on to depth-3, depth-4, and so on until the whole tree is initialized.\par
In this way, all sub-sCBTs with the same depth can be handled in a sub-loop, allowing any depth specific variable to be calculated faster. One such variable is the index of the root node of a givensubthe leftmost bottom node of that sub-sCBT until the least significant bit disappears. Here is a suggested C++ code to find the root index for a given leftmost node: unsigned long level; \textunderscore Bit Scan Forward(\&level, leftmost Node); root= leftmostNode>> (level+1); example, Figure-7 depicts an sCBT with 12 lexical leaves. By following the sub-figures from a) to d), the initialization of this sCBT can be followed step by-step.\par
The second way for initial update requires the initialization of sub-sCBTs starting from rightmost depth -1 sCBT and growing/going to the left while initializing the next available size/initializable sCBT on the way. Figure \hyperref[fig_6]{-6} shows the sequence of these consecutive update paths by ordinal numbers from zero to five for the initialization of the depicted sCBT.\par
sCBT, which can be found by right shifting the index of Figure \hyperref[fig_7]{7}: A lexical array of size 12 is used as the leaves of the sCBT in order to demonstrate the introduced initial update procedure using the first of the two suggested methods. a) Only the sub-trees with a depth of one are initialized, in b) the ones with a depth of two and in c) with a depth of four (which is the whole sCBT) are initialized.\par
Here there is no sub-sCBT with a depth of three. In d) the decomposition of the sCBT along the winner path is visualized by using different colors for each sub-sCBT. 
\section[{V. Redundant Tree Nodes}]{V. Redundant Tree Nodes}\par
If a tree node is written but never read, then writing that node is considered redundant. In the case of combination, the bottom nodes, or in other words, the immediate parent nodes of the leaves are all redundant. This is because they host the loser keys not the winner Figure  {\ref 8} : Leaving out the redundant tree nodes. During the proposed unilateral update procedure, the lowest level tree nodes are not read at all, therefore there is no point of using them to write the indexes of the looser leaves. This reduces the number of required nodes to implement an sCBT to N/2. 
\section[{Global Journal of Computer Science and Technology}]{Global Journal of Computer Science and Technology}\par
Volume XVI Issue III Version I 11 Year 2016 ( ) 
\section[{VI. Update Mechanism}]{VI. Update Mechanism}\par
When an update is required after a new key is assigned to the winner leaf, a unilateral update procedure is implemented: First, the new key is compared to its sister, and then the winner of this comparison is kept at hand as the new winner candidate. Then this new candidate is compared to the hosted keys along the winner path. Wherever the key at hand loses the comparison, it is registered there and the previously registered key in that node is taken as the new winner candidate.This procedure goes on until the root node is reached, where the final winner is registered.\par
The following is a working C++ code for the proposed initial update and the proposed unilateral update methods. Initial update method follows the first technique explained in'Initial Update'section. Although sCBT and the proposed unilateral update mechanism ones. Thus, we can implement the sCBT and the proposed update mechanism by using only N/2 tree nodes. After comparing the sister leaves, we register only the winner to the grandparent node (we can think of the immediate parent node as a ghost node).  
\section[{VII. Results and Discussion}]{VII. Results and Discussion}\par
The benefits of the introduced unilateral update mechanism compared to the bilateral update mechanism can be itemized as follows: 1. Every key index appears in the tree at most once.\par
More precisely, half of the key indexes will appear in the tree only once, while other half will not have any appearance in the reduced sCBT approach. If there is a necessity for a specific application, sCBT can also be formed using N nodes, in which case, the entire key indexes will appear in the tree once and only once. In the bilateral update, some leaves are registered as many as log N times while some others are not registered at all. 2. Except for the computation (or identification) of a leaf level sister, neither is there a need for any sister node computation nor a need for accessing its content. \} \} //w: winner, it was the index of the previous winner key, when a new value is assigned//to the winner key, the sCBT // should be updated accordingly. This update procedure will provide the index of the new winner key. voidUpdate\textunderscore sCBT() index of a node in order to avoid re-storing the index which is already there. But this will bring extra overhead of log N integer index comparisons. 5. The required number of tree nodes is reduced by 50\% in comparison to the required number of nodes for the bilateral update mechanism implemented on a CBT.  In terms of initial update cost, there is not much difference between the unilateral and the bilateral update methods. Both of them require exactly N comparisons. However, the number of accessed nodes, writes, and reads are different. In the case of a bilateral update on a CBT, N nodes are accessed, N reads and N writes are implemented. On the other hand, the initial update of an sCBT accesses N/2 nodes, and implements N/2 reads and a minimum of N/2 writes ( in the worst case scenario, number of writes can be equal  to N if all the comparisons require the swapping of node content and the winner candidate at hand). Table-2 summarizes these quantities. 
\section[{Global}]{Global} 
\section[{VIII. Numerical Comparisons}]{VIII. Numerical Comparisons}\par
A test run for a given number of keys was repeated 10 times but only the averages were used for maximum encountered error (standard deviation divided by average) was less than 3\%. The computer used for the presented results was a Dell OptiPlex 790 with an Intel Core i5-2400 CPU @3.10 GHz and 8GB RAM. The operating system of the test computer was Windows 7 enterprise 64-bit edition. For coding, Visual C++ 2010 programming environment was used. The compilations A uniform distribution (0.0<x<1.0) was used to generate random key values for the hold model[6]. CBTs were constructed using the given number of initial keys. Then a loop of N hold operations was performed for timing. Timing was achieved by counting the total number of CPU cycles between the beginning and the were done with SSE2 and maximize-speed options enabled.\par
end of the computational block by using the CPU clock register. The accumulated number of CPU cycles was divided by number of given keys to get an average cost graphing. For the obtained numerical results, the for one hold operation. The presented empirical results have been scaled to the scores of the implementations running on the same test system based on reference CBT that Marin used [6]. [Fig. 10] presents the obtained results for the test system in two categories: Initial update comparisons and full update comparisons. In the case of initial update comparisons, introduced unilateral initial update performs at least 20\% better than bilateral initial update except when the number of keys is very small. This should be because of the smaller footprint of the bilateral initial update code as can be seen in the fallowing lines compared to the code for unilateral initial update given earlier.\par
//intN; //the size of the keys array. //float *Keys; // the given array containing the keys. 
\section[{Global Journal of Computer Science and Technology}]{Global Journal of Computer Science and Technology}\par
Volume XVI Issue III Version I Full update comparisons show that the superiority of unilateral update gets better as the number of keys increases and it stabilizes around 20\%for cases the bulk of the data remains outside the cache memory. 
\section[{IX. Conclusion}]{IX. Conclusion}\par
A new graphical formation of binary trees is introduced. As a result of this formation, binary trees can be decomposed or composed without adding or\begin{figure}[htbp]
\noindent\textbf{1}\includegraphics[]{image-2.png}
\caption{\label{fig_0}Figure 1 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2}\includegraphics[]{image-3.png}
\caption{\label{fig_1}Figure 2 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{3}\includegraphics[]{image-4.png}
\caption{\label{fig_2}Figure 3 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-5.png}
\caption{\label{fig_3}}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{4}\includegraphics[]{image-6.png}
\caption{\label{fig_4}Figure 4 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{5}\includegraphics[]{image-7.png}
\caption{\label{fig_5}Figure 5 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{6}\includegraphics[]{image-8.png}
\caption{\label{fig_6}Figure 6 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{7}\includegraphics[]{image-9.png}
\caption{\label{fig_7}Figure- 7}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-10.png}
\caption{\label{fig_8}}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-11.png}
\caption{\label{fig_9}}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{9}\includegraphics[]{image-12.png}
\caption{\label{fig_10}Figure 9 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-13.png}
\caption{\label{fig_11}}\end{figure}
   \begin{figure}[htbp]
\noindent\textbf{} \par 
\begin{longtable}{P{0.85\textwidth}}
//int offset=N,*sCBT=new int[(N+1)>>1];//"+1" is necessary for odd N cases.\\
//sCBT:auxiliary integer array used for the formation of stemmed complete binary tree.\\
// int max ID= N-1;\\
Void Initial Update ()\\
\{\\
Int h = N-1; //h: host, immediate parent node for a pair of leaves.\\
If (N\&1) \{sCBT[h>>1]= h; h--; offset++;\} // (**)\\
For (int jump = 2, UpNode = h>>1, Tail= maxID>>1; ;UpNode --)\\
\{\\
Int w= 2*h -offset; if(Keys[w\textasciicircum 1] < Keys[w]) w \textasciicircum = 1;\\
For (int n= h>>1; n >UpNode; n>>= 1)\\
if (Keys[sCBT [n]] < Keys[w]) swap(sCBT[n],w);\\
sCBT [UpNode]= w;\\
h-= jump; if(h > Tail) continue;\\
h<<= 1;\\
if(UpNode> 1) jump<<=1; else\{ if(UpNode ==0) break; if(h < Tail) h <<= 1;\}\\
\}\\
\{\\
int w= *sCBT;\\
if((w\textasciicircum 1)!=N) // (w\textasciicircum 1)==N can happen only ifN is odd. (**)\\
if(Keys[w\textasciicircum 1] <Keys[w]) w \textasciicircum = 1;//loser doesn't need to be registered anywhere.\\
for(int node= (w + offset)>>2; node> 0 ;node >>= 1)\\
\{\\
Int const guest= sCBT [node];//guest: index of the registered key in the node.\\
if (Keys[guest] <Keys[w])\{sCBT [node]= w; w= guest;\}\\
\}\\
*sCBT= w;\end{longtable} \par
 
\caption{\label{tab_1}}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{-} \par 
\begin{longtable}{}
\end{longtable} \par
 
\caption{\label{tab_2}Table - 1}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{1} \par 
\begin{longtable}{P{0.21137566137566136\textwidth}P{0.01798941798941799\textwidth}P{0.10793650793650793\textwidth}P{0.16190476190476188\textwidth}P{0.049470899470899464\textwidth}P{0.1349206349206349\textwidth}P{0.11693121693121693\textwidth}P{0.049470899470899464\textwidth}}
Type of Update\tabcellsep \#of\tabcellsep Required Tree Nodes\tabcellsep \multicolumn{2}{l}{Comparisons Accessed Nodes}\tabcellsep Sister Node Computations\tabcellsep writes\tabcellsep reads\\
\multicolumn{2}{l}{Unilateral Update}\tabcellsep N/2\tabcellsep Log N\tabcellsep Log N\tabcellsep 0\tabcellsep \multicolumn{2}{l}{1? ?Log N Log N}\\
\multicolumn{2}{l}{Bilateral Update}\tabcellsep 2N\tabcellsep Log N\tabcellsep 2Log N\tabcellsep Log N\tabcellsep Log N\tabcellsep 2Log N\end{longtable} \par
 
\caption{\label{tab_3}Table 1 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2} \par 
\begin{longtable}{P{0.4546511627906976\textwidth}P{0.02635658914728682\textwidth}P{0.18449612403100774\textwidth}P{0.02635658914728682\textwidth}P{0.09883720930232558\textwidth}P{0.059302325581395345\textwidth}}
Type\tabcellsep \#of\tabcellsep \multicolumn{2}{l}{Comparisons Accessed Nodes}\tabcellsep writes\tabcellsep reads\\
OfInitial Update\tabcellsep \tabcellsep \tabcellsep \tabcellsep \\
\multicolumn{2}{l}{Unilateral Initial Update}\tabcellsep N\tabcellsep N/2\tabcellsep N/2? ? N\tabcellsep N/2\\
\multicolumn{2}{l}{Bilateral Initial Update}\tabcellsep N\tabcellsep N\tabcellsep N\tabcellsep N\end{longtable} \par
 
\caption{\label{tab_4}Table 2 :}\end{figure}
 			\footnote{© 2016 Global Journals Inc. (US)} 			\footnote{© 2016 Global Journals Inc. (US) Bottom-Up Update Mechanism for Re-Structured Complete Binary Trees} 			\footnote{© 2016 Global Journals Inc. (US) 1} 		 		\backmatter  			 \par
deleting any nodes regardless of their leaf and node hierarchies. This new formation leads to a unilateral bottom-up update mechanism that promises acceleration by reducing computational overhead, auxiliary memory field, and memory operations. When the suggested sCBT structure is used to produce the initial runs for external sorting [7], it will increase the average length of the runs, since larger size trees can be established in a given amount of cache memory thanks to the elimination of redundant tree nodes. 			 			  				\begin{bibitemlist}{1}
\bibitem[Marín and Cordero ()]{b3}\label{b3} 	 		‘An empirical assessment of priority queues in event-driven molecular dynamics simulation’.  		 			M Marín 		,  		 			P Cordero 		.  	 	 		\textit{Comput Phys Commun}  		1995. 92 p. .  	 
\bibitem[Friend ()]{b2}\label{b2} 	 		‘Sorting on electronic computer systems’.  		 			E H Friend 		.  	 	 		\textit{J ACM}  		1956. 3 p. .  	 
\bibitem[Sahni ()]{b1}\label{b1} 	 		\textit{Structures, algorithms, and applications in C++},  		 			S Sahni 		.  		2005. Summit, NJ, USA: Silicon Press.  	 	 (2nd ed.) 
\bibitem[Knuth ()]{b4}\label{b4} 	 		\textit{The art of computer programming},  		 			D E Knuth 		.  		1998. San Francisco, CA, USA: Addison-Wesley.  	 	 (2nd ed) 
\bibitem[Kirchhoff ()]{b0}\label{b0} 	 		‘Ueber die auflösung der gleichungen auf welche man bei der untersuchung der linearen vertheilung galvanischer ströme geführt wird’.  		 			G Kirchhoff 		.  	 	 		\textit{Ann Phys}  		1847. 148 p. .  	 
\end{bibitemlist}
 			 		 	 
\end{document}
