Jekyll2024-01-02T19:09:21+00:00http://sherxon.com/feed.xmlAlgo & DSI am Sherali Obidov, This is my blog about algorithms, data structures, web development and Java. You can also find common algorithmic problems with their solutions and
implementation of Data Structures in Java.
Dasturlashni nimadan boshlasam ekan?2020-01-25T00:00:00+00:002020-01-25T00:00:00+00:00http://sherxon.com/blog/beginners-guide<strong>Background</strong>
<br/>
Mendan ohirgi bir yilda 100 dan ko'pro odam, dasturlashni nimadan boshlasam buladi deb surashdi. Kopchilikda qiziqish bor hali
umuman code yozmagan bazilari esa boshlab quygan kurslarga borishni yoki mustaqil urganishni. Uzimga yoqqani uchun yordam
berish, <a href="https://t.me/sheraliobidov">telegramda</a> savollariga qulimdan kelgancha javob beryapman. Lekin shu bitta savolni qayta qayta suraladi social sitelar
orqali yoki tanishla bilan gaplashib qolganimda.
<br/>
<br/>
<strong>Ingliz Tili</strong>
<br/>
Birinchi o'rinda yoshiz nechada bulishiga qaramasdan, ingliz tilini urganishni maslahat beraman. IELTS dan 6 oladigan darajada
bilimiz bulsa yetarli. Internetdagi malumolarni <a href="https://www.internetworldstats.com/stats7.htm">yarmidan koprog'i</a> ingliz tilida.
Bu statistics aynan dasturlashga tegishli malumotlarni ulushiga ham to'g'ri keladi. Ingliz tili dasturlashni ko'proq va
tezroq urganish uchun ancha yordam beradi. Eng yaxshi online kursla va maqolala ingliz tilida chiqariladi birinchi
ex: MIT programmingga oid yuzlab <a href="https://ocw.mit.edu/index.htm">kurslarini</a> tekinga urganish uchun internetda quyib quygan.
<br/>
Ingliz tilini va programming ni bir paytda uqish qiyinro, ingliz tilini onlineda mustaqil o'rgana oladigan darajaga
chiqib keyin programmingni boshlash yaxshi idea.
<br/>
<br/>
<strong>Dasturlash tili</strong>
<br/>
Uzizga yoqqan dasturlash tilidan boshlasaiz buladi urganishni, agar u mainstream dasturlash tillaridan biri bulsa(Java, C++,
Python, Javascript, C# ...). Bitta tilni bilgandan keyin ikkinchisini urganish juda oson buladi, 2-3 oyda urgansa buladi
ikkinchisini bir biriga uxshash bulgani uchun. Shuni uchun 6 oy qaysi tilni urganay deb o'ylanib yurmang.
Umuman habari yuq urganuvchilar uchun, webni urganishni yani HTML, CSS, Javascriptdan boshlashni maslahat beraman.
Front end, backend va database ishlatishni ham oson davom ettirib ketsa buladi javascriptdan keyin.
Dasturlash bu faqat programming language ni bilishdan tashqari juda kop boshqa skillarni bilishni talab qiladi.</br>
Mana bazi foydali linklar davom ettirish uchun: </br>
<a href="https://teachyourselfcs.com/">https://teachyourselfcs.com</><br>
<a href="https://www.bottomupcs.com/index.xhtml">https://www.bottomupcs.com/index.xhtml</a></br>
<a href="https://github.com/ossu/computer-science">https://github.com/ossu/computer-science</a></br>Background Mendan ohirgi bir yilda 100 dan ko'pro odam, dasturlashni nimadan boshlasam buladi deb surashdi. Kopchilikda qiziqish bor hali umuman code yozmagan bazilari esa boshlab quygan kurslarga borishni yoki mustaqil urganishni. Uzimga yoqqani uchun yordam berish, telegramda savollariga qulimdan kelgancha javob beryapman. Lekin shu bitta savolni qayta qayta suraladi social sitelar orqali yoki tanishla bilan gaplashib qolganimda. Ingliz Tili Birinchi o'rinda yoshiz nechada bulishiga qaramasdan, ingliz tilini urganishni maslahat beraman. IELTS dan 6 oladigan darajada bilimiz bulsa yetarli. Internetdagi malumolarni yarmidan koprog'i ingliz tilida. Bu statistics aynan dasturlashga tegishli malumotlarni ulushiga ham to'g'ri keladi. Ingliz tili dasturlashni ko'proq va tezroq urganish uchun ancha yordam beradi. Eng yaxshi online kursla va maqolala ingliz tilida chiqariladi birinchi ex: MIT programmingga oid yuzlab kurslarini tekinga urganish uchun internetda quyib quygan. Ingliz tilini va programming ni bir paytda uqish qiyinro, ingliz tilini onlineda mustaqil o'rgana oladigan darajaga chiqib keyin programmingni boshlash yaxshi idea. Dasturlash tili Uzizga yoqqan dasturlash tilidan boshlasaiz buladi urganishni, agar u mainstream dasturlash tillaridan biri bulsa(Java, C++, Python, Javascript, C# ...). Bitta tilni bilgandan keyin ikkinchisini urganish juda oson buladi, 2-3 oyda urgansa buladi ikkinchisini bir biriga uxshash bulgani uchun. Shuni uchun 6 oy qaysi tilni urganay deb o'ylanib yurmang. Umuman habari yuq urganuvchilar uchun, webni urganishni yani HTML, CSS, Javascriptdan boshlashni maslahat beraman. Front end, backend va database ishlatishni ham oson davom ettirib ketsa buladi javascriptdan keyin. Dasturlash bu faqat programming language ni bilishdan tashqari juda kop boshqa skillarni bilishni talab qiladi. Mana bazi foydali linklar davom ettirish uchun: https://teachyourselfcs.com https://www.bottomupcs.com/index.xhtml https://github.com/ossu/computer-scienceGoogle ga software engineer bo’lib ishga kirish haqida2018-12-25T00:00:00+00:002018-12-25T00:00:00+00:00http://sherxon.com/blog/google-interviewGoogle ga qanday qilib kelib qoldim :)
<br/>
<br/>
<strong>Intro</strong>
<br/>
Bu blogimda doimgi mavzulardan tashqariga chiqib, qanday qilib,
Google ga software engineer bo'lib, ishga kirganim haqida yozmoqchiman.
Interview process haqida o'zbek tilida (bilmagan joylarimni ingliz tilada :)
yozib, to'liq ma'lumot berishim, O'zbekistonlik va boshqa o'zbek tili
so'zlovchilariga ozgina bo'lsa-da, motivatsiya bo'lishiga umid qilaman.
Iloji boricha, detailed yozishga harakat qilaman va agar yana savollaringiz bo'lsa,
bemalol yozib qoldirishingiz mumkin.
Imkoni boricha, javob berishga harakat qilaman.
<br/>
<br/>
<strong>Background</strong><br/>
Bundan 3-4 yil avval dasturchi do'stlarim bilan qat'iy qaror qildik:
o'z sohamizning yuqori cho'qqisiga chiqamiz! Maqsadga erishishdagi rejalarimiz ichida
eng yaxshi dasturchilar ishlaydigan kompaniyalardan biriga ishga kirish
va u yerdagi tajribali insonlar bilan birga ishlab, yanada rivojlanish ham bor edi.
<br/>
Shu niyatlar bilan 2016-yil
Toshkentdagi Xalqaro Westminster Universitetida bakalavrni bitirib,
shu yilning kuzida Amerikada magistratura o'qish uchun Iowa shtatidagi
Maharishi Management Universitetiga o'qishga keldim.
U yerda 1 yil universitet campusda full time o'qidim.
Ikkinchi yilni online o'qish imkoniyati borligidan foydalanib,
Chicagodagi bir kichikroq kompaniyada software engineer sifatida ish boshladim.
Maharishi Universiteti ishga kirish uchun juda katta yordam berdi:
kuchli o'qitiladigan fanlardan tashqari,
Amerikada ishga kirish jarayonlarini tushuntirib, ish ruhsatnomasini ham qilib berdi.
<br/>
Online o'qib yurgan paytlarimda ishlaganim uchun,
o'qish pulini to'lash unchalik qiyin bo'lmadi.
Ma'lumot uchun, masterga tuition fee 40,000$ atrofida ketdi.
<br/>
<br/>
<strong>Interview preparation</strong>
<br/>
Masterning birinchi yilida campus da o'qib yurgan vaqtimda,
asosan algorithm/data structure va system design ga oid mavzular
o'rgandim/masalalar yechib practice qildim.
Bunda Cracking the coding interview by McDowell,
Algorithm design manual by Skiena va Algorithms By Sedgwick katta yordam berdi.
Leetcode va hackerrank/timus dan similar problems yechib,
kitoblardan o'rgangan theoriyalar ustida shug'ullandim.
Interview da o'zimni qanday tutishni esa Pramp da mock intervyular qilib o'rgandim.
<br/>
<br/>
<strong>Interview process</strong>
<br/>
Google da interview process boshqa katta tech company larnikidan farq qiladi
va o'rtacha 3-6 oy vaqt oladi.
Men o'zimda bo'lgan process haqida yozaman.
Qaysi level/position ga apply qilinganiga qarab, ba'zida bundan sal farqli bo'lishi mumkin.
<br/>
<br/>
Birinchi step interview da, recruiter email yoki linkedin profilga message yozadi va
open position borligi haqida ma'lumot berish uchun telda gaplashishga vaqtingiz borligini so'raydi.
Online application topshirganlarga ham xuddi shunaqa steps bo'ladi.
Kelishilgan vaqtda telda gaplashib, qiziqish bor-yo'qligini va qachon ish boshlay olishingiz
mumkinligini so'raydi. Shundan keyin, candidate qiziqishiga qarab, ikkinchi stepga o'tiladi.
Ya'ni online/phone screening technical interview. O'rtacha 45 min bo'ladi.
Video yoki audio chat qilib, Google dagi biror software engineer bilan har xil coding problemalar
yechiladi. Mening holatimda 45 minut faqat technical savollar bo'ldi.
Behavioral savollar deyarli so'rashmaydi. 2-3 ta masala beriladi and/or common algorithms and
data structure concept larni tushuntirib berishingiz so'ralishi mumkin.
<br/>
<br/>
Bundan successful o'tilgandan keyin,
interviewer feedback iga qarab, yana boshqa screening interview bo'lishi
mumkin yoki directly onsite interview ga chaqirilishi mumkin.
Men bilan interview feedback yaxshi bo'lgani uchun, to'g'ri onsite ga kelishni taklif qilishdi.
Meni vaqtimga qarab, airplane tickets va inteview joyiga yaqin mehmonxonadan xona band qilishdi.
Bir kun oldin kelib, mountain view ga, ertasiga ertalab soat 10 da inteview uchun yetib bordim
va har biri 45 daqiqalik 5 round technical interview bo'ldi.
<br/>
<br/>
Uchinchi round interviewdan keyin orada tushlik uchun 1 soat ajratishadi.
Interview dagi aniq savollarni confidential bulgani uchun yozolmayman,
lekin mavzular: algorithms, data structures, system design doirasida bo'ldi.
O'rganishni maslahat berishim mumkin bo'lgan mavzular
all common data structures and algorithms:stack, queue, heap, list, hashtables,
trees and graphs; sorting and searching algos, graph and tree traversals and common related problems,
little bit knowledge of dynamic programming and bit manipulation.
Tepada eslatgan kitoblarimni o'qib, tushunilsa, bemalol yetarli bo'ladi va faqat qolgani
practice bilan interview ga kelsa bo'ladi.
System design uchun aniq bir kitob hozircha maslahat berolmayman.
Chunki men o'zim, asosan, online da article lardan va bloglardan o'qib o'rganganman.
Qiziqqanlar contact qilsa, system design uchun resource larimni yuboraman.
<br/>
<br/>
Onsite interview dan keyin, recruiter 1-2 haftada aniq javobni aytish uchun tel qiladi
va benefits/compensation/relocation packages haqida deal qilinadi.
Va undan keyin team matching boshlanadi: Google da resumeyingizni o'qib,
sizni o'z komandasiga olishga qiziqqan team manager lar bog'lanib,
ular bilan ishlashga fikringizni so'rashadi.
Bu step da candidate o'zi uchun qiziq bo'lgan savollar so'raydi:
komanda haqida, nima ish qilishi, project development process va career growth opportunities haqida.
<br/>
<br/>
Aniq sizga yoqadigan team va project/product topilgandan keyin, recruiter 1 haftalarda
official job offer yuboradi va background check boshlanadi.
Bu stepda resumeyingizda ko'rsatilgan experience va education lar haqiqiy
ekanligini tasdiqlash uchun ularga bog'lanib, confirmation olishadi.
<br/>
<br/>
<strong>Impression working here so far</strong>
<br/>
Birinchi 3 hafta training dan keyin komandada haqiqiy ish boshlandi.
Trainingda Google dagi muhitni va ishlatiladigan tool lar bilan tanishtirishdi.
Boshlaganimga endigina 2 oy bo'lgan bo'lsa ham, juda ko'p narsa o'rgandim.
Eng muhimi, o'rganish va o'rganganlaringizni amalda qo'llash uchun barcha imkoniyatlar yetarli.<br/>
<br/>
<br/>
Google ishchilar haqida juda care qiladi: 3 mahal ovqat, entertainment, gym/pool resources, flexible work life balance, great benefits package, yaxshigina oylik ham beradi. To'g'risini aytsam, perks ko'pligidan hali hammasini try qilib ko'rmadim.)
<br/>
<br/>
Engineerlar juda professional va tajribali. Manager larning ko'pchiligi engineer likdan boshlashgan va o'zlarini hali ham engineer deb bilishadi. Solution topishga va product delivery qilishga nisbatan ham boshqa companylarga qaraganda ancha farqli usullardan foydalanishadi. Yana bir-ikki yildan keyin, Google haqida ko'proq yoza oladigan bo'lganimda boshqa postda batafsil yozaman.
<br/>
<br/>
<strong>That's is it for now.</strong>
<br/>
O'zimda juda ko'p "qanday qilib" degan savollar bo'lardi. Savollar bo'lsa, istalgan vaqt facebookda contact qilinglar. Imkoni boricha javob beraman, Xudo xohlasa)<br/>
<br/>
PS. No judging on typos.Google ga qanday qilib kelib qoldim :) Intro Bu blogimda doimgi mavzulardan tashqariga chiqib, qanday qilib, Google ga software engineer bo'lib, ishga kirganim haqida yozmoqchiman. Interview process haqida o'zbek tilida (bilmagan joylarimni ingliz tilada :) yozib, to'liq ma'lumot berishim, O'zbekistonlik va boshqa o'zbek tili so'zlovchilariga ozgina bo'lsa-da, motivatsiya bo'lishiga umid qilaman. Iloji boricha, detailed yozishga harakat qilaman va agar yana savollaringiz bo'lsa, bemalol yozib qoldirishingiz mumkin. Imkoni boricha, javob berishga harakat qilaman. Background Bundan 3-4 yil avval dasturchi do'stlarim bilan qat'iy qaror qildik: o'z sohamizning yuqori cho'qqisiga chiqamiz! Maqsadga erishishdagi rejalarimiz ichida eng yaxshi dasturchilar ishlaydigan kompaniyalardan biriga ishga kirish va u yerdagi tajribali insonlar bilan birga ishlab, yanada rivojlanish ham bor edi. Shu niyatlar bilan 2016-yil Toshkentdagi Xalqaro Westminster Universitetida bakalavrni bitirib, shu yilning kuzida Amerikada magistratura o'qish uchun Iowa shtatidagi Maharishi Management Universitetiga o'qishga keldim. U yerda 1 yil universitet campusda full time o'qidim. Ikkinchi yilni online o'qish imkoniyati borligidan foydalanib, Chicagodagi bir kichikroq kompaniyada software engineer sifatida ish boshladim. Maharishi Universiteti ishga kirish uchun juda katta yordam berdi: kuchli o'qitiladigan fanlardan tashqari, Amerikada ishga kirish jarayonlarini tushuntirib, ish ruhsatnomasini ham qilib berdi. Online o'qib yurgan paytlarimda ishlaganim uchun, o'qish pulini to'lash unchalik qiyin bo'lmadi. Ma'lumot uchun, masterga tuition fee 40,000$ atrofida ketdi. Interview preparation Masterning birinchi yilida campus da o'qib yurgan vaqtimda, asosan algorithm/data structure va system design ga oid mavzular o'rgandim/masalalar yechib practice qildim. Bunda Cracking the coding interview by McDowell, Algorithm design manual by Skiena va Algorithms By Sedgwick katta yordam berdi. Leetcode va hackerrank/timus dan similar problems yechib, kitoblardan o'rgangan theoriyalar ustida shug'ullandim. Interview da o'zimni qanday tutishni esa Pramp da mock intervyular qilib o'rgandim. Interview process Google da interview process boshqa katta tech company larnikidan farq qiladi va o'rtacha 3-6 oy vaqt oladi. Men o'zimda bo'lgan process haqida yozaman. Qaysi level/position ga apply qilinganiga qarab, ba'zida bundan sal farqli bo'lishi mumkin. Birinchi step interview da, recruiter email yoki linkedin profilga message yozadi va open position borligi haqida ma'lumot berish uchun telda gaplashishga vaqtingiz borligini so'raydi. Online application topshirganlarga ham xuddi shunaqa steps bo'ladi. Kelishilgan vaqtda telda gaplashib, qiziqish bor-yo'qligini va qachon ish boshlay olishingiz mumkinligini so'raydi. Shundan keyin, candidate qiziqishiga qarab, ikkinchi stepga o'tiladi. Ya'ni online/phone screening technical interview. O'rtacha 45 min bo'ladi. Video yoki audio chat qilib, Google dagi biror software engineer bilan har xil coding problemalar yechiladi. Mening holatimda 45 minut faqat technical savollar bo'ldi. Behavioral savollar deyarli so'rashmaydi. 2-3 ta masala beriladi and/or common algorithms and data structure concept larni tushuntirib berishingiz so'ralishi mumkin. Bundan successful o'tilgandan keyin, interviewer feedback iga qarab, yana boshqa screening interview bo'lishi mumkin yoki directly onsite interview ga chaqirilishi mumkin. Men bilan interview feedback yaxshi bo'lgani uchun, to'g'ri onsite ga kelishni taklif qilishdi. Meni vaqtimga qarab, airplane tickets va inteview joyiga yaqin mehmonxonadan xona band qilishdi. Bir kun oldin kelib, mountain view ga, ertasiga ertalab soat 10 da inteview uchun yetib bordim va har biri 45 daqiqalik 5 round technical interview bo'ldi. Uchinchi round interviewdan keyin orada tushlik uchun 1 soat ajratishadi. Interview dagi aniq savollarni confidential bulgani uchun yozolmayman, lekin mavzular: algorithms, data structures, system design doirasida bo'ldi. O'rganishni maslahat berishim mumkin bo'lgan mavzular all common data structures and algorithms:stack, queue, heap, list, hashtables, trees and graphs; sorting and searching algos, graph and tree traversals and common related problems, little bit knowledge of dynamic programming and bit manipulation. Tepada eslatgan kitoblarimni o'qib, tushunilsa, bemalol yetarli bo'ladi va faqat qolgani practice bilan interview ga kelsa bo'ladi. System design uchun aniq bir kitob hozircha maslahat berolmayman. Chunki men o'zim, asosan, online da article lardan va bloglardan o'qib o'rganganman. Qiziqqanlar contact qilsa, system design uchun resource larimni yuboraman. Onsite interview dan keyin, recruiter 1-2 haftada aniq javobni aytish uchun tel qiladi va benefits/compensation/relocation packages haqida deal qilinadi. Va undan keyin team matching boshlanadi: Google da resumeyingizni o'qib, sizni o'z komandasiga olishga qiziqqan team manager lar bog'lanib, ular bilan ishlashga fikringizni so'rashadi. Bu step da candidate o'zi uchun qiziq bo'lgan savollar so'raydi: komanda haqida, nima ish qilishi, project development process va career growth opportunities haqida. Aniq sizga yoqadigan team va project/product topilgandan keyin, recruiter 1 haftalarda official job offer yuboradi va background check boshlanadi. Bu stepda resumeyingizda ko'rsatilgan experience va education lar haqiqiy ekanligini tasdiqlash uchun ularga bog'lanib, confirmation olishadi.How to write clean code2018-03-12T00:00:00+00:002018-03-12T00:00:00+00:00http://sherxon.com/blog/clean-codeIn this article, I am going to talk about a few key points on how to write clean code by avoiding
some common mistakes. The term clean code is very broad and subjective, but there are conventions, standards and points to consider in coding that makes it more human readable.
<br/>
Before starting talking about the key points to write clean code, I want to emphasize that It does
not take one or two days to be good at clean coding. You need to practice
until it becomes a second nature.
<br/>
<br/>
You are author and reader. While writing code, keep in mind that you are author and your target audience is not computer, it is you, your coworkers and millions of other developers in case it is open source.
Writing every line of code with this idea in mind helps you use your knowledge to its fullest.
<br/>
<br/>
Let's start with very simple one-naming convention. Depending on your programming language choice,
try to implement using only one (not mixed) naming convention across your team.
Most popular ones are <u>camelCase</u> favoured by Java, C# community and <u>snake_case</u> which is popular among php and python programmers.
<br/>
<br/>
The next step on appropriate naming is that you should start paying attention to naming variables.
The variable names should answer only one question with less word possible -
<b>what is the value of this variable to programmer.</b>
It should never answer why this variable is created or how this variable is used.
Here are couple of bad examples you have have seen.
<br/><br/>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="nl">Wrong:</span>
<span class="kd">protected</span> <span class="nc">Date</span> <span class="n">d</span><span class="o">;</span> <span class="c1">// orderDate</span>
<span class="kd">protected</span> <span class="nc">Date</span> <span class="n">theProductOrderedDate</span><span class="o">;</span>
<span class="kd">public</span> <span class="nc">Date</span> <span class="n">genymdhms</span><span class="o">;</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">data</span> <span class="o">=</span> <span class="n">readRecord</span><span class="o">();</span>
<span class="n">print</span><span class="o">(</span><span class="s">"ID: "</span><span class="o">,</span> <span class="n">data</span><span class="o">[</span><span class="s">"student_id"</span><span class="o">])</span>
<span class="nc">Right</span>
<span class="kd">protected</span> <span class="nc">Date</span> <span class="n">orderDate</span>
<span class="kd">public</span> <span class="nc">Date</span> <span class="n">generationTimestamp</span><span class="o">;</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">student</span> <span class="o">=</span> <span class="n">readRecord</span><span class="o">();</span>
<span class="n">print</span><span class="o">(</span><span class="s">"ID: "</span><span class="o">,</span> <span class="n">student</span><span class="o">[</span><span class="s">"student_id"</span><span class="o">])</span></code></pre></figure>
<br/>
<br/>
As you read, variable names with single letter, unpronounceable words or generic names such as
data and total are all very confusing when dealing with this variable.
These types of naming leads to assumptions when reading it and assumptions create bugs.
Sometimes, these bad naming comes from thinking too much about appropriate names eventually it loses its meaning.
<br/>
<br/>
When it comes to naming methods/functions, there is one simple rule.
We know that a function does one job. Similarly, the function name should only answer to one question-
<b>What does this function do?</b>
As you guess, it should have one verb and only tells about its purpose.
If you create a function with nice name and the function does more than it suggests on its name,
then you should reconsider renaming or moving extra logic into another function.
The more atomic functions you have, the less arguments they will have as those
functions do not need many arguments to do a single job. This makes code more beautiful and easy to reuse.
<br/>
<br/>
Next comes naming classes. You may think this is the easiest one because you usually have more options to name a class
compared to variable. This is not always true. One of the biggest issues with class naming is long sentence-like names.
Here are couple of examples
<br/>
<br/>
<a href="https://docs.spring.io/spring/docs/2.5.x/javadoc-api/org/springframework/aop/framework/AbstractSingletonProxyFactoryBean.html) https://docs.spring.io/spring/docs/2.5.x/javadoc-api/org/springframework/aop/config/SimpleBeanFactoryAwareAspectInstanceFactory.html">
SimpleBeanFactoryAwareAspectInstanceFactory
</a>
<br/>
<a href="http://grepcode.com/file/repository.springsource.com/org.aspectj/com.springsource.org.aspectj.weaver/1.6.3/org/aspectj/weaver/patterns/HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor.java">
HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor
</a>
<br/>
To avoid such names, you may try locating classes in right packages with concise documentation. Class names dont have to say anything about how/when/where to use.
The only question class name should concern is what this class is about.
<br/>
<br/>
Habitual class naming such as ending exceptions with Exception keyword is another big issue among programmers.
In most cases it completely makes sense to remove exception suffix from classes and
the meaning does not change.
<i>IllegalArgumentException</i>, <i>NullReferenceException</i> or <i>EntityNotFoundException</i> are nice examples that can be used without the exception suffix.
So, you may think about that not all big company libraries are appropriately named all the time.
<br/>
<br/>
White space is nice space. Often I see people writing smashed-up code without leaving any white space or line anywhere.
This makes really hard to read and my eyes get strained while reading such code.
If you’re implementing more logic in one block, and then try to separate the code chunks into logical pieces
with a white line break. Maybe have all of your code that use data fetching from database,
then a line of whitespace, and then write another chunk where you do process them.
Things like this might seem annoying at the time of writing, but are crucial when trying to quickly find something in a large section of unfamiliar code.
<br/>
<br/>
Commenting, it saves time for programmer and money for company. The easiest way of contributing to project success is by commenting existing code.
Sometimes, it seems daunting to write couple lines of comments after implementing performant algorithm or solving huge problem.
But the commenting this adds more value to the solution.
<br/>
<br/>
Here are some ways that can help you to make habit of writing clean code.
You can always download nice coding style
<a href="https://google.github.io/styleguide/">Google coding style guide</a> and integrate it your powerful IDE.
This makes sure that you have right naming convention and indentation to some extend.
<br/>
<br/>
Happy clean coding!In this article, I am going to talk about a few key points on how to write clean code by avoiding some common mistakes. The term clean code is very broad and subjective, but there are conventions, standards and points to consider in coding that makes it more human readable. Before starting talking about the key points to write clean code, I want to emphasize that It does not take one or two days to be good at clean coding. You need to practice until it becomes a second nature. You are author and reader. While writing code, keep in mind that you are author and your target audience is not computer, it is you, your coworkers and millions of other developers in case it is open source. Writing every line of code with this idea in mind helps you use your knowledge to its fullest. Let's start with very simple one-naming convention. Depending on your programming language choice, try to implement using only one (not mixed) naming convention across your team. Most popular ones are camelCase favoured by Java, C# community and snake_case which is popular among php and python programmers.Microservice Architecture Pattern using Spring Boot and netflix technologies and helpful hints2017-09-01T00:00:00+00:002017-09-01T00:00:00+00:00http://sherxon.com/blog/microservice-pocFile IO operation comparisons in Java2017-04-29T00:00:00+00:002017-04-29T00:00:00+00:00http://sherxon.com/blog/fastest-io-in-java<style>
.table-bordered {
border: 1px solid #ddd;
}
.table {
width: 100%;
max-width: 100%;
margin-bottom: 20px;
}
table {
background-color: transparent;
}
table {
border-spacing: 0;
border-collapse: collapse;
}
.table-bordered>tbody>tr>td, .table-bordered>tbody>tr>th, .table-bordered>tfoot>tr>td, .table-bordered>tfoot>tr>th, .table-bordered>thead>tr>td, .table-bordered>thead>tr>th {
border: 1px solid #ddd;
}
.table-condensed>tbody>tr>td, .table-condensed>tbody>tr>th, .table-condensed>tfoot>tr>td, .table-condensed>tfoot>tr>th, .table-condensed>thead>tr>td, .table-condensed>thead>tr>th {
padding: 5px;
}
.table>tbody>tr>td, .table>tbody>tr>th, .table>tfoot>tr>td, .table>tfoot>tr>th, .table>thead>tr>td, .table>thead>tr>th {
padding: 8px;
line-height: 1.42857143;
vertical-align: top;
border-top: 1px solid #ddd;
}
</style>
When I have free time, I attend contests in Online Judge websites just for fun. To get AC (passed all test cases
and accepted) result in these contests, your solution has to be time and memory efficient. Most of the problems have several
test cases to evaluate solutions. So, reading those test cases from file and outputting your results into another file to check
may take much time as File Input and Output (IO) operations are toooo slow compared to other operations in most programming languages.
<div style="margin: 10px"></div>
I decided to benchmark all possible ways of reading and writing data into files in Java. Now I present you some
results I found. Note that this post only shows results without any tuning disk file IO such as low level caching.
Here are some approaches in Java with explanations you can use for writing into
file and reading from it. These benchmarks are done using Intel® Core™ i3-3120M CPU @ 2.50GHz × 4 in 64-bit Ubuntu 14.04
with Java SE 1.8.0_20 on SSD. There are several factors(CPU, Hard disk and OS)
that can make these benchmark results different.
Hovewer, the relative difference is almost the same in all machines.
<div style="margin: 10px"></div>
<div style="margin: 20px"></div>
<table class="table table-condensed table-bordered">
<head>
<tr>
<td>JavaClass/FileSize</td>
<td> 1 MB </td>
<td> 10 MB </td>
<td> 100 MB </td>
<td> 1000 MB </td>
<td> Code </td>
</tr>
</head>
<tbody>
<td>FileInputStream</td>
<td> 600 ms </td>
<td> 4500 ms</td>
<td> 41200 ms </td>
<td> 425400 ms</td>
<td><a href="https://github.com/sherxon/AlgoDS/tree/master/src/oi">Link</a></td>
</tr>
<tr>
<td>BufferedInputStream</td>
<td> 30 ms </td>
<td> 350 ms</td>
<td> 3300 ms </td>
<td> 32100 ms</td>
<td><a href="https://github.com/sherxon/AlgoDS/tree/master/src/oi">Link</a></td>
</tr>
<tr>
<td>BufferedReader</td>
<td> 60 ms </td>
<td> 390 ms</td>
<td> 3400 ms </td>
<td> 32900 ms</td>
<td><a href="https://github.com/sherxon/AlgoDS/tree/master/src/oi">Link</a></td>
</tr>
<tr>
<td>Direct BufferedInputStream</td>
<td> 50 ms </td>
<td> 80 ms</td>
<td> 280 ms </td>
<td> 3300 ms</td>
<td><a href="https://github.com/sherxon/AlgoDS/tree/master/src/oi">Link</a></td>
</tr>
<tr>
<td>MappedByteBuffer</td>
<td> 20 ms </td>
<td> 25 ms</td>
<td> 160 ms </td>
<td> 1450 ms </td>
<td><a href="https://github.com/sherxon/AlgoDS/tree/master/src/oi">Link</a></td>
</tr>
</tbody>
</table>
<div style="margin: 20px"></div>
What the Difference! You may be wondering why the famous and mostly used input stream approach is so slow.
Main reason for this is that <a href="https://docs.oracle.com/javase/7/docs/api/java/io/FileInputStream.html">FileInputStream</a>
calls native read() method for each next 1 byte (raw octet, 8 bit) of the file content. When the file size is 1 MB, read() method is called
1048576 times that is 1024 x 1024. Now you can imagine how many times it is called for 1000MB. So, when working
with Files, the first rule that you need to consider to speed up your application is the number of method calls()
to underlying system and disk.
<div style="margin: 10px"></div>
<b>
Rule 1. Try to reduce number of method calls to underlying system and disk.
</b>
<div style="margin: 20px"></div>
To reduce those method calls in FileInputStream, we can read some amount of data (1 MB or 2 MB) from disk and
store it in memory then use this stored data. In this case, we dont make access to disk for each next byte.
As accessing to memory is much faster than accessing to disk, we can speed up our reading operation. BufferedInputStream
use the same strategy to make File IO faster by storing data in buffer (8192 bytes). When read() method is callled
in BufferedStreams, data is read from buffered array in memory and rarely accesses to undelying system.
<div style="margin: 10px"></div>
We can create our own buffer array with bigger size and speed up reading. The Direct BufferedInputStream appraoch
shows benchmark of using 2MB byte array as buffer. As you can see, that is nearly 10 times faster than Java's
default Bufferedstream usage when it comes to read data from 1000 MB file. You can buffer the whole file into byte
array as long as you have enough space in memory.
<div style="margin: 10px"></div>
<b>
Rule 2. Use your own buffer with certain size according to your business logic.
</b>
<div style="margin: 10px"></div>
If you pay attention above, we only discussed about reading bytes from file. Hovewer, there are many cases
that we want to read content of the file as characters. Unlike BufferedStreams, BufferedReader is all about
reading characters. In the background, it reads bytes (like streams) from disk and translates into characters.
You can see the BufferedReader works little slower than BufferedStreams because of translaton proccess.
<div style="margin: 10px"></div>
Next comes MemoryByteBuffer, which is Memory Mapped IO Class in Java. So, What is Memory Mapped file in Java?
Memory mapped files are new feature in Java nio package, which allows to access contents of file directly from
memory. This is achieved by mapping whole file or portion of file into memory and operating system takes care of
loading page requested and writing into file while application only deals with memory which results
in very fast IO operations. Memory used to load Memory mapped file is outside of Java heap Space. We use MappedByteBuffer
in Java to read and write from memory.
<div style="margin: 10px"></div>
Memory Mapped files are so fast that they are used when performance is very important. However, there are some
tradeoffs such as occurance of page faults if requested page is not in memory.
<div style="margin: 10px"></div>
If your application is dealing with small size of files, choosing MappedByteBuffer or BufferedStreams does
not make much difference. Hovewer, reading data from large files using and changing certain pages of the file
using multiple cores makes huge impact in performance. As Mapped Files loads the whole or some region of the file
into shared memory, every process does not have to load the file into memory.
<div style="margin: 10px"></div>
<script src="//platform.linkedin.com/in.js" type="text/javascript"> lang: en_US</script>
<script type="IN/Share" data-url="http://sherxon.com/blog/fastest-io-in-java" data-counter="top"></script>When I have free time, I attend contests in Online Judge websites just for fun. To get AC (passed all test cases and accepted) result in these contests, your solution has to be time and memory efficient. Most of the problems have several test cases to evaluate solutions. So, reading those test cases from file and outputting your results into another file to check may take much time as File Input and Output (IO) operations are toooo slow compared to other operations in most programming languages.Binary Tree Common Problems and Solutions2017-03-16T00:00:00+00:002017-03-16T00:00:00+00:00http://sherxon.com/blog/binary-treeIn this post you can learn about binary tree common problems and their solutions in Java. You can also find
interesting and elite problems solutions about Linked Lists in my <a href="linked-list-2">previous post.</a>
<br/>
<br/>
<h4>Short Introduction to Binary Trees.</h4>
Binary Trees are set of nodes in which one node is linked to two other nodes (left and right). Usually a reference or a pointer
to topmost node is stored as a root, which can be used to traverse through all other nodes. In most cases Binary
Trees are used as Binary Search Trees (BST) that have certain properties: the values in left sub tree is always
smaller than or equal to its parent node's value and the values in right sub tree is always larger than its parent's
value. Here is the illustration of BST.
<div style="margin: 10px"></div>
<div style="">
<span style="">
<img src="/assets/bst.png" style=" display: block; margin: auto;
overflow: hidden; width: 700px;">
</span>
</div>
<br/>
<br/>
<blockquote>1)Given Binary Tree, print node values in pre-order, in-order, post-order and level order.</blockquote>
Solution: <br/><br/>
Unlike linear data structures such as ArrayList, LinkedList, Queue and Stack, Binary Trees can be traversad in
several ways. Main traversal methods of Binary Trees are <br/>
<ul>
<li><b>Pre-order</b> - traversing starts from root and goes to left subtree then to right subtree</li>
<li><b>In-order</b> - traversing starts from left subtree and goes to root then to right subtree</li>
<li><b>Post-order</b> - traversing starts from left subtree and goes to right subtree then to root</li>
<li><b>Level-order</b> - traversing starts from root as level 1 and goes to every other level</li>
</ul>
Below are solution in Java for all 4 traversal methods. <br/><br/>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">public</span> <span class="kt">void</span> <span class="nf">postOrder</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">root</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">root</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span><span class="k">return</span><span class="o">;</span>
<span class="n">postOrder</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">left</span><span class="o">);</span> <span class="c1">// first left</span>
<span class="n">postOrder</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">right</span><span class="o">);</span> <span class="c1">// and right</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">val</span> <span class="o">+</span> <span class="s">" "</span><span class="o">);</span> <span class="c1">// then process</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">preOrder</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">root</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">root</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span><span class="k">return</span><span class="o">;</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">val</span> <span class="o">+</span> <span class="s">" "</span><span class="o">);</span> <span class="c1">// process first</span>
<span class="n">preOrder</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">left</span><span class="o">);</span> <span class="c1">// go to left</span>
<span class="n">preOrder</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">right</span><span class="o">);</span> <span class="c1">// then right</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">inOrder</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">root</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">root</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span><span class="k">return</span><span class="o">;</span>
<span class="n">inOrder</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">left</span><span class="o">);</span> <span class="c1">// first left</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">val</span> <span class="o">+</span> <span class="s">" "</span><span class="o">);</span> <span class="c1">// process</span>
<span class="n">inOrder</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">right</span><span class="o">);</span> <span class="c1">// then go to right</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">levelOrder</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">root</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">root</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="k">return</span><span class="o">;</span>
<span class="nc">Queue</span><span class="o"><</span><span class="nc">TreeNode</span><span class="o">></span> <span class="n">q</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">LinkedList</span><span class="o"><>();</span>
<span class="n">q</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">root</span><span class="o">);</span> <span class="c1">// add first level to queue</span>
<span class="kt">int</span> <span class="n">nodeCountInLevel</span> <span class="o">=</span> <span class="mi">1</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(!</span><span class="n">q</span><span class="o">.</span><span class="na">isEmpty</span><span class="o">())</span> <span class="o">{</span>
<span class="nc">TreeNode</span> <span class="n">x</span> <span class="o">=</span> <span class="n">q</span><span class="o">.</span><span class="na">remove</span><span class="o">();</span>
<span class="n">nodeCountInLevel</span><span class="o">--;</span>
<span class="k">if</span> <span class="o">(</span><span class="n">x</span><span class="o">.</span><span class="na">left</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span>
<span class="n">q</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">x</span><span class="o">.</span><span class="na">left</span><span class="o">);</span>
<span class="k">if</span> <span class="o">(</span><span class="n">x</span><span class="o">.</span><span class="na">right</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span>
<span class="n">q</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">x</span><span class="o">.</span><span class="na">right</span><span class="o">);</span>
<span class="c1">// move to next level when all nodes are processed in current level</span>
<span class="k">if</span> <span class="o">(</span><span class="n">nodeCountInLevel</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">&&</span> <span class="o">!</span><span class="n">q</span><span class="o">.</span><span class="na">isEmpty</span><span class="o">())</span> <span class="o">{</span>
<span class="n">nodeCountInLevel</span> <span class="o">+=</span> <span class="n">q</span><span class="o">.</span><span class="na">size</span><span class="o">();</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">q</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
</TreeNode>
<br/>
<br/>
<blockquote>2) Invert Binary Tree</blockquote>
Google: 90% of our engineers use the software you wrote (Homebrew),
but you can’t invert a binary tree on a whiteboard so fuck off.
<a href="https://twitter.com/mxcl/status/608682016205344768">Here is motivation to learn how to invert Binary Tree.</a>
<br/>
<br/>
Solution:<br/>
The inverse of an empty tree is the empty tree. The inverse of a tree with root <b>r</b> and subtrees
<b>left</b>b and <b>right</b> is a tree with root <b>r</b> whose right subtree is the inverse of <b>left</b>
and whose left subtree is the inverse of <b>right</b>. </br>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">public</span> <span class="nc">TreeNode</span> <span class="nf">invertTree</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">root</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">root</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
<span class="nc">TreeNode</span> <span class="n">tempRight</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="na">right</span><span class="o">;</span>
<span class="n">root</span><span class="o">.</span><span class="na">right</span> <span class="o">=</span> <span class="n">invertTree</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">left</span><span class="o">);</span>
<span class="n">root</span><span class="o">.</span><span class="na">left</span> <span class="o">=</span> <span class="n">invertTree</span><span class="o">(</span><span class="n">tempRight</span><span class="o">);</span>
<span class="k">return</span> <span class="n">root</span><span class="o">;</span>
<span class="o">}</span></code></pre></figure>
<br/>
Time Complexity is O(n), becuase each node is vitised only once. </br>
Space Complexity is O(n) because of recursion h (height) number of stack calls.</br>
<br/>
<br/>
<blockquote>3) Given two binary trees, check if they are structurally identical and the nodes have the same value. </blockquote>
<br/>
Solution:<br/>
To invert a Binary Tree, we do pre-order traverse both trees and check if values of the nodes in each tree is the same.
Iterative and recursive approach can be used to solve this problem. Below I presented my recursive solution.
<br/>
<br/>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kt">boolean</span> <span class="nf">isSameTree</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">p</span><span class="o">,</span> <span class="nc">TreeNode</span> <span class="n">q</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// base case</span>
<span class="k">if</span><span class="o">(</span><span class="n">p</span> <span class="o">==</span> <span class="kc">null</span> <span class="o">||</span> <span class="n">q</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span><span class="k">return</span> <span class="n">p</span> <span class="o">==</span><span class="n">q</span> <span class="o">;</span>
<span class="c1">// recursion, check if values are equal</span>
<span class="k">return</span> <span class="n">p</span><span class="o">.</span><span class="na">val</span> <span class="o">==</span> <span class="n">q</span><span class="o">.</span><span class="na">val</span> <span class="o">&&</span> <span class="n">isSameTree</span><span class="o">(</span><span class="n">p</span><span class="o">.</span><span class="na">left</span><span class="o">,</span> <span class="n">q</span><span class="o">.</span><span class="na">left</span><span class="o">)</span> <span class="o">&&</span> <span class="n">isSameTree</span><span class="o">(</span><span class="n">p</span><span class="o">.</span><span class="na">right</span><span class="o">,</span> <span class="n">q</span><span class="o">.</span><span class="na">right</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
Time Complexity is O(n), becuase each node is vitised only once. </br>
Space Complexity is O(n) because of recursion h (height) number of stack calls.</br>
<br/>
<br/>
<blockquote>4) Find Lowest Common Ancestor (LCA) of a Binary Search Tree</blockquote>
<i>According to <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor">WikiPedia definition </a>,
The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as
descendants (where we allow a node to be a descendant of itself).</i>
<br/>
<br/>
Solution:<br/>
We walk down the tree as long as both p and q are in the same sub tree, in which case their values
are both smaller than root's value or greater than root's value. Return when one of the p and q, are
larger than root's value and the other is smaller than root's value. <br/>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">public</span> <span class="nc">TreeNode</span> <span class="nf">lowestCommonAncestor</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">root</span><span class="o">,</span> <span class="nc">TreeNode</span> <span class="n">p</span><span class="o">,</span> <span class="nc">TreeNode</span> <span class="n">q</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">root</span><span class="o">==</span><span class="kc">null</span><span class="o">)</span><span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
<span class="k">if</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">val</span> <span class="o"><</span> <span class="n">p</span><span class="o">.</span><span class="na">val</span> <span class="o">&&</span> <span class="n">root</span><span class="o">.</span><span class="na">val</span> <span class="o"><</span> <span class="n">q</span><span class="o">.</span><span class="na">val</span><span class="o">)</span>
<span class="k">return</span> <span class="nf">lowestCommonAncestor</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">right</span><span class="o">,</span> <span class="n">p</span><span class="o">,</span> <span class="n">q</span><span class="o">);</span>
<span class="k">else</span> <span class="nf">if</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">val</span> <span class="o">></span> <span class="n">p</span><span class="o">.</span><span class="na">val</span> <span class="o">&&</span> <span class="n">root</span><span class="o">.</span><span class="na">val</span> <span class="o">></span> <span class="n">q</span><span class="o">.</span><span class="na">val</span><span class="o">)</span>
<span class="k">return</span> <span class="nf">lowestCommonAncestor</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">left</span><span class="o">,</span> <span class="n">p</span><span class="o">,</span> <span class="n">q</span><span class="o">);</span>
<span class="k">else</span> <span class="k">return</span> <span class="n">root</span><span class="o">;</span>
<span class="o">}</span></code></pre></figure>
<br/>
Time Complexity is O(n), becuase each node is vitised only once. </br>
<br/><br/>
<blockquote>5) Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.</blockquote>
<br/>
Solution:<br>
We subtract the value of current node from sum until it reaches a leaf node and the subtraction equals 0,
then we can make sure there is a path. Otherwise the subtraction at the end could not be 0.
<br/>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">hasPathSum</span><span class="o">(</span><span class="nc">TreeNode</span> <span class="n">root</span><span class="o">,</span> <span class="kt">int</span> <span class="n">sum</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">root</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span><span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="n">sum</span><span class="o">-=</span><span class="n">root</span><span class="o">.</span><span class="na">val</span><span class="o">;</span>
<span class="k">if</span><span class="o">(</span><span class="n">sum</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">&&</span> <span class="n">root</span><span class="o">.</span><span class="na">left</span> <span class="o">==</span> <span class="kc">null</span> <span class="o">&&</span> <span class="n">root</span><span class="o">.</span><span class="na">right</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="k">return</span> <span class="nf">hasPathSum</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">left</span><span class="o">,</span> <span class="n">sum</span><span class="o">)</span> <span class="o">||</span> <span class="n">hasPathSum</span><span class="o">(</span><span class="n">root</span><span class="o">.</span><span class="na">right</span><span class="o">,</span> <span class="n">sum</span><span class="o">);</span>
<span class="o">}</span></code></pre></figure>
<br/>
<br/>
<h4>Here are some other mostly encountered Binary Tree problems and Solutions</h4>
<ul>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/easy/MaximumDepthofBinaryTree.java">Maximum Depth of Binary Tree</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/easy/MinimumDepthofBinaryTree.java">Minimum Depth of Binary Tree</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/ConvertSortedListtoBinarySearchTree.java">Convert Sorted List to Binary Search Tree</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/ConvertSortedArraytoBinarySearchTree.java">Convert Sorted Array to Binary Search Tree</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/easy/SymmetricTree.java">Check If Binary Trees are symmetric</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/FlattenBinaryTreetoLinkedList.java">Flatten Binary Tree to Linked List</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/BinaryTreeRightSideView.java">Binary Tree Right Side View</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/DeleteNodeinaBST.java">Delete Node in a BST</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/ValidateBinarySearchTree.java">Validate Binary Search Tree</a></li>
</ul>
<br/><br/>
<script src="//platform.linkedin.com/in.js" type="text/javascript"> lang: en_US</script>
<script type="IN/Share" data-url="http://sherxon.com/blog/binary-tree" data-counter="top"></script>In this post you can learn about binary tree common problems and their solutions in Java. You can also find interesting and elite problems solutions about Linked Lists in my previous post. Short Introduction to Binary Trees. Binary Trees are set of nodes in which one node is linked to two other nodes (left and right). Usually a reference or a pointer to topmost node is stored as a root, which can be used to traverse through all other nodes. In most cases Binary Trees are used as Binary Search Trees (BST) that have certain properties: the values in left sub tree is always smaller than or equal to its parent node's value and the values in right sub tree is always larger than its parent's value. Here is the illustration of BST. 1)Given Binary Tree, print node values in pre-order, in-order, post-order and level order.LinkedList Common Problems and Solutions2017-02-25T00:00:00+00:002017-02-25T00:00:00+00:00http://sherxon.com/blog/linked-list-2This is my second blog on LinkedLists. In this blog, some of the most common problems and their
solutions are discussed. You can also read about types of linked lists and implementations in Java in
my prvious post, <a href="linked-list">LinkedList Implementation and Basic Operations</a>. To make a best use of this post,
please read the question first and do little brainstorm before moving on to the solution.
You can also try to implement solution once you are familiar with solution idea.
<div style="margin: 10px"></div>
<blockquote>1) Given a singly linked list, determine if it has a cycle in it.</blockquote>
<div style="margin: 10px"></div>
<div style="margin: 10px"></div>
Solution:
<div style="margin: 10px"></div>
a) We iterate the list and add each element into the hashtable until current element is null or
current element is already in the hashtable. This solution uses O(N) space to store list elements in hashtable.
Time complexity is also O(N).
<div style="margin: 10px"></div>
b) We can use two pointers: <b>slow</b> and <b>fast</b>.
<b>slow</b> pointer moves step by step while <b>fast</b> pointer moves two steps at a time. If the linked list has
a cycle <b>slow</b> and <b>fast</b> pointers meet at some point. This solution uses O(1) space, which is better
than previous solution.
<div style="margin: 10px"></div>
Here is implementation of solution in Java.
<div style="margin: 5px"></div>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kt">boolean</span> <span class="nf">hasCycle</span><span class="o">(</span><span class="nc">ListNode</span> <span class="n">head</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">head</span><span class="o">==</span><span class="kc">null</span> <span class="o">||</span> <span class="n">head</span><span class="o">.</span><span class="na">next</span><span class="o">==</span><span class="kc">null</span><span class="o">)</span><span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="nc">ListNode</span> <span class="n">slow</span><span class="o">=</span><span class="n">head</span><span class="o">;</span>
<span class="nc">ListNode</span> <span class="n">fast</span><span class="o">=</span><span class="n">head</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="k">while</span><span class="o">(</span><span class="n">slow</span><span class="o">!=</span><span class="kc">null</span> <span class="o">&&</span> <span class="n">fast</span><span class="o">!=</span><span class="kc">null</span> <span class="o">&&</span> <span class="n">fast</span><span class="o">.</span><span class="na">next</span><span class="o">!=</span><span class="kc">null</span><span class="o">){</span>
<span class="k">if</span><span class="o">(</span><span class="n">slow</span><span class="o">==</span><span class="n">fast</span><span class="o">)</span><span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="n">slow</span><span class="o">=</span><span class="n">slow</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="n">fast</span><span class="o">=</span><span class="n">fast</span><span class="o">.</span><span class="na">next</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="o">}</span></code></pre></figure>
<div style="margin: 20px"></div>
<blockquote>2) Given two singly linked lists, find the node at which the intersection of these
lists begins. Below given illustration of linked lists with intersection </blockquote>
<figure class="highlight"><pre><code class="language-html" data-lang="html">A: a1 → a2↘
c1 → c2 → c3
↗
B: b1 → b2 → b3</code></pre></figure>
<div style="margin: 10px"></div>
Solution:<br/>
a) The easy solution is adding all elements of the first linked list into Hashset and checking one by one if
an element of the second linked list is contained in the hashset.<br/>
Time Complexity is O(n+m) and Space Complecity is O(n)
<div style="margin: 10px"></div>
b) We iterate both lists and get length of each list. Then move pointer k steps forward on the longer list where
k is the difference between lengths of lists. Now we need to move two pointers in both lists starting from head
element in shorter list and kth element in longer list. We can find out intersection point the lists when
two pointers meet at some point. <br/>
Time Complexity is O(max(m,n)) and Space Complecity is O(1)
<div style="margin: 10px"></div>
c) We maintain two pointers x and y at the head of A and B lists respectively. Then we move pointers one node
at a time. When x reaches the end of a list, then redirect it to the head of B,
similarly when y reaches the end of a list, redirect it the head of A. If at any point x meets y,
then x/y is the intersection node.<br/>
Time Complexity is O(m+n) and Space Complecity is O(1)
<div style="margin: 10px"></div>
Below code snippet shows the third solution.
<div style="margin: 10px"></div>
<figure class="highlight"><pre><code class="language-java" data-lang="java"> <span class="nc">ListNode</span> <span class="nf">getIntersectionNode</span><span class="o">(</span><span class="nc">ListNode</span> <span class="n">headA</span><span class="o">,</span> <span class="nc">ListNode</span> <span class="n">headB</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">headA</span><span class="o">==</span><span class="n">headB</span><span class="o">)</span> <span class="k">return</span> <span class="n">headA</span><span class="o">;</span>
<span class="nc">ListNode</span> <span class="n">x</span><span class="o">=</span><span class="n">headA</span><span class="o">;</span>
<span class="nc">ListNode</span> <span class="n">y</span><span class="o">=</span><span class="n">headB</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(</span><span class="n">x</span><span class="o">!=</span><span class="n">y</span><span class="o">){</span>
<span class="n">x</span><span class="o">=</span> <span class="n">x</span><span class="o">==</span><span class="kc">null</span> <span class="o">?</span> <span class="n">headB</span> <span class="o">:</span> <span class="n">x</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="n">y</span><span class="o">=</span> <span class="n">y</span><span class="o">==</span><span class="kc">null</span> <span class="o">?</span> <span class="n">headA</span> <span class="o">:</span> <span class="n">y</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="n">x</span><span class="o">;</span>
<span class="o">}</span></code></pre></figure>
<div style="margin: 10px"></div>
<blockquote>3) Given a linked list, return the node where the cycle begins without modifying the list.
If there is no cycle, return null.</blockquote>
<div style="margin: 20px"></div>
Solution: <br/>
a) We iterate the list and add every node into Hashset, if element is already in the set we can return this element as
cycle starting point.<br/>
Time Complexity is O(n) and Space Complecity is O(n)
<div style="margin: 10px"></div>
b) This solution is combination of the first and the second problem solutions. We first find any point in the
cycle if there is. Then break the list by setting next pointer of node to null and find intersection point
of two lists. The intersection point is the point where cycle begins.<br/>
Time Complexity is O(n+m) and Space Complecity is O(1)
<div style="margin: 10px"></div>
<blockquote>4) Reverse a singly linked list.</blockquote>
<div style="margin: 10px"></div>
Solution:<br/>
a) We can reverse singly linked list in two ways, using recursion and iteration. The idea is to recur until tail
node is encountered and set current node as next element of returned element in recursion.
<div style="margin: 10px"></div>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">class</span> <span class="nc">Solution</span> <span class="o">{</span>
<span class="nc">ListNode</span> <span class="n">newHead</span><span class="o">;</span>
<span class="kd">public</span> <span class="nc">ListNode</span> <span class="nf">reverseList</span><span class="o">(</span><span class="nc">ListNode</span> <span class="n">head</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="n">head</span> <span class="o">==</span> <span class="kc">null</span> <span class="o">||</span> <span class="n">head</span><span class="o">.</span><span class="na">next</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span><span class="k">return</span> <span class="n">head</span><span class="o">;</span>
<span class="n">reverse</span><span class="o">(</span><span class="n">head</span><span class="o">);</span>
<span class="n">head</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="kc">null</span><span class="o">;</span>
<span class="k">return</span> <span class="n">newHead</span><span class="o">;</span>
<span class="o">}</span>
<span class="nc">ListNode</span> <span class="nf">reverse</span><span class="o">(</span><span class="nc">ListNode</span> <span class="n">current</span><span class="o">){</span>
<span class="k">if</span><span class="o">(</span><span class="n">current</span> <span class="o">==</span> <span class="kc">null</span> <span class="o">||</span> <span class="n">current</span><span class="o">.</span><span class="na">next</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="n">newHead</span> <span class="o">=</span> <span class="n">current</span><span class="o">;</span>
<span class="k">return</span> <span class="n">current</span><span class="o">;</span>
<span class="o">}</span>
<span class="nc">ListNode</span> <span class="n">prev</span> <span class="o">=</span> <span class="n">reverse</span><span class="o">(</span><span class="n">current</span><span class="o">.</span><span class="na">next</span><span class="o">);</span>
<span class="n">prev</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">current</span><span class="o">;</span>
<span class="k">return</span> <span class="n">current</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<div style="margin: 10px"></div>
<blockquote>5) Sort a singly linked list in O(n log n) time using constant space complexity.</blockquote>
<div style="margin: 10px"></div>
Solution:<br/>
We can use merge sort to sort linked list here. First we need to find mid element of the linked list using
two pointers as mentioned above. Then, we should break the link by setting null to the next of mid element.
In this case we can have have two lists; left linked list starts from head to mid and right linked list that starts from mid+1 to end
of the linked list. We divide linked list until it has only one element in both left and right lists.
Then starts merging of left and right lists into one sorted list. You can find solution below in Java
<div style="margin: 10px"></div>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">public</span> <span class="nc">ListNode</span> <span class="nf">sortList</span><span class="o">(</span><span class="nc">ListNode</span> <span class="n">head</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">head</span> <span class="o">==</span> <span class="kc">null</span> <span class="o">||</span> <span class="n">head</span><span class="o">.</span><span class="na">next</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="k">return</span> <span class="n">head</span><span class="o">;</span>
<span class="nc">ListNode</span> <span class="n">slow</span> <span class="o">=</span> <span class="n">head</span><span class="o">;</span>
<span class="nc">ListNode</span> <span class="n">fast</span> <span class="o">=</span> <span class="n">head</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(</span><span class="n">fast</span> <span class="o">!=</span> <span class="kc">null</span> <span class="o">&&</span> <span class="n">fast</span><span class="o">.</span><span class="na">next</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// slow in middle element</span>
<span class="n">slow</span> <span class="o">=</span> <span class="n">slow</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="n">fast</span> <span class="o">=</span> <span class="n">fast</span><span class="o">.</span><span class="na">next</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="nc">ListNode</span> <span class="n">start2</span> <span class="o">=</span> <span class="n">slow</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="n">slow</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="kc">null</span><span class="o">;</span> <span class="c1">// break the link</span>
<span class="nc">ListNode</span> <span class="n">start1</span> <span class="o">=</span> <span class="n">sortList</span><span class="o">(</span><span class="n">head</span><span class="o">);</span> <span class="c1">// sort first half</span>
<span class="nc">ListNode</span> <span class="n">start11</span> <span class="o">=</span> <span class="n">sortList</span><span class="o">(</span><span class="n">start2</span><span class="o">);</span> <span class="c1">// sort second half</span>
<span class="k">return</span> <span class="nf">merge</span><span class="o">(</span><span class="n">start1</span><span class="o">,</span> <span class="n">start11</span><span class="o">);</span> <span class="c1">// merge sorted arrays</span>
<span class="o">}</span>
<span class="nc">ListNode</span> <span class="nf">merge</span><span class="o">(</span><span class="nc">ListNode</span> <span class="n">a</span><span class="o">,</span> <span class="nc">ListNode</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">ListNode</span> <span class="n">root</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ListNode</span><span class="o">(</span><span class="mi">0</span><span class="o">);</span> <span class="c1">// helper node</span>
<span class="nc">ListNode</span> <span class="n">x</span> <span class="o">=</span> <span class="n">root</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(</span><span class="n">a</span> <span class="o">!=</span> <span class="kc">null</span> <span class="o">||</span> <span class="n">b</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">a</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="n">x</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">b</span><span class="o">;</span>
<span class="n">b</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">b</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="n">x</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">a</span><span class="o">;</span>
<span class="n">a</span> <span class="o">=</span> <span class="n">a</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">a</span><span class="o">.</span><span class="na">val</span> <span class="o"><=</span> <span class="n">b</span><span class="o">.</span><span class="na">val</span><span class="o">)</span> <span class="o">{</span>
<span class="n">x</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">a</span><span class="o">;</span>
<span class="n">a</span> <span class="o">=</span> <span class="n">a</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="n">x</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">b</span><span class="o">;</span>
<span class="n">b</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="n">root</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span></code></pre></figure>
<div style="margin: 10px"></div>
These are some other commonly asked questions in interviews.
<ul>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/easy/RemoveDuplicatesLinkedList.java">
Remove Duplicates from Sorted List
</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/easy/PalindromeLinkedList.java">
Palindrome Linked List
</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/RotateList.java">
Rotate List
</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/AddTwoNumbers2.java">
Add Two Numbers
</a></li>
<li><a href="https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/medium/MergekSortedLists.java">
Merge k Sorted Lists
</a></li>
</ul>
<br/>
<br/>
<script src="//platform.linkedin.com/in.js" type="text/javascript"> lang: en_US</script>
<script type="IN/Share" data-url="http://sherxon.com/blog/linked-list" data-counter="top"></script>This is my second blog on LinkedLists. In this blog, some of the most common problems and their solutions are discussed. You can also read about types of linked lists and implementations in Java in my prvious post, LinkedList Implementation and Basic Operations. To make a best use of this post, please read the question first and do little brainstorm before moving on to the solution. You can also try to implement solution once you are familiar with solution idea.LinkedList Implementation and Basic Operations2017-02-24T00:00:00+00:002017-02-24T00:00:00+00:00http://sherxon.com/blog/linked-listThis is the first blog on linked lists that contains implementations in Java and introduces basic
operation such as add, get and delete. You can also read about problems and their solutions on linked lists
on <a href="linked-list-2">LinkedList Common Problems and Solutions</a> post.
<div style="margin: 10px"></div>
Linked List is a sequence of data that are connected by links. Each list item is commonly referred as Node.
Every node stores certain data and a link to the next element. On the other hand, Linked lists can also have
two links (previous and next) to optimize some operations. They are called doubly linked lists.
<div style="margin: 10px"></div>
Here is a simple illastration of singly linked lists.
<div style="margin: 10px"></div>
<div style="">
<span style="">
<img src="/assets/linked-list.png" style=" display: block; margin: auto;
overflow: hidden; width: 400px;">
</span>
</div>
<div style="margin: 10px"></div>
and doubly linked list
<div style="margin: 10px"></div>
<div style="">
<span style="">
<img src="/assets/doubly-linked-list.png" style=" display: block; margin: auto;
overflow: hidden; width: 400px;">
</span>
</div>
<div style="margin: 10px"></div>
Here is simple implementation of singly linked list in Java
<div style="margin: 10px"></div>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">class</span> <span class="nc">LinkedList</span><span class="o"><</span><span class="no">E</span><span class="o">></span> <span class="o">{</span>
<span class="kd">private</span> <span class="nc">Node</span> <span class="n">head</span><span class="o">;</span> <span class="c1">// the first element</span>
<span class="kd">private</span> <span class="nc">Node</span> <span class="n">tail</span><span class="o">;</span> <span class="c1">// the last element</span>
<span class="kt">int</span> <span class="n">size</span><span class="o">;</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">add</span><span class="o">(</span><span class="no">E</span> <span class="n">element</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// tail and head are the same node when list has only one item</span>
<span class="k">if</span> <span class="o">(</span><span class="n">head</span> <span class="o">==</span> <span class="kc">null</span><span class="o">){</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">tail</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Node</span><span class="o">(</span><span class="n">element</span><span class="o">);</span>
<span class="o">}</span><span class="k">else</span> <span class="o">{</span>
<span class="c1">//assign new node to next of tail and make tail the last element</span>
<span class="n">tail</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Node</span><span class="o">(</span><span class="n">element</span><span class="o">);</span>
<span class="n">tail</span> <span class="o">=</span> <span class="n">tail</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="n">size</span><span class="o">++;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="no">E</span> <span class="nf">get</span><span class="o">(</span><span class="kt">int</span> <span class="n">index</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">index</span> <span class="o">>=</span> <span class="n">size</span> <span class="o">&&</span> <span class="n">index</span> <span class="o"><</span> <span class="mi">0</span><span class="o">)</span> <span class="c1">// check boundaries</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">NoSuchElementException</span><span class="o">();</span>
<span class="c1">// find element at given index</span>
<span class="nc">Node</span> <span class="n">node</span> <span class="o">=</span> <span class="n">head</span><span class="o">;</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">index</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span>
<span class="n">node</span> <span class="o">=</span> <span class="n">node</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="k">return</span> <span class="n">node</span><span class="o">.</span><span class="na">elem</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">delete</span><span class="o">(</span><span class="no">E</span> <span class="n">element</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Node</span> <span class="n">temp</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Node</span><span class="o">(</span><span class="kc">null</span><span class="o">,</span> <span class="n">head</span><span class="o">);</span> <span class="c1">// dummy element to avoid if checks</span>
<span class="nc">Node</span> <span class="n">dummy</span> <span class="o">=</span> <span class="n">temp</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(</span><span class="n">temp</span><span class="o">.</span><span class="na">next</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">temp</span><span class="o">.</span><span class="na">next</span><span class="o">.</span><span class="na">elem</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="n">element</span><span class="o">))</span> <span class="o">{</span>
<span class="c1">// if found node is last node of the list, need to change tail</span>
<span class="k">if</span> <span class="o">(</span><span class="n">temp</span><span class="o">.</span><span class="na">next</span> <span class="o">==</span> <span class="n">tail</span><span class="o">)</span> <span class="n">tail</span> <span class="o">=</span> <span class="n">temp</span><span class="o">;</span>
<span class="n">temp</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">temp</span><span class="o">.</span><span class="na">next</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="c1">// if found node is first node if the list, need to change head</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">dummy</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="n">size</span><span class="o">--;</span>
<span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="o">}</span>
<span class="n">temp</span> <span class="o">=</span> <span class="n">temp</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="o">}</span>
<span class="c1">// wrapper class for list elements</span>
<span class="kd">private</span> <span class="kd">class</span> <span class="nc">Node</span> <span class="o">{</span>
<span class="no">E</span> <span class="n">elem</span><span class="o">;</span>
<span class="nc">Node</span> <span class="n">next</span><span class="o">;</span>
<span class="kd">public</span> <span class="nf">Node</span><span class="o">(</span><span class="no">E</span> <span class="n">elem</span><span class="o">)</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span class="na">elem</span> <span class="o">=</span> <span class="n">elem</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="nf">Node</span><span class="o">(</span><span class="no">E</span> <span class="n">el</span><span class="o">,</span> <span class="nc">Node</span> <span class="n">node</span><span class="o">)</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span class="na">elem</span> <span class="o">=</span> <span class="n">el</span><span class="o">;</span>
<span class="k">this</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">node</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
</E>
<div style="margin: 10px"></div>
You can add addFirst and getFirst, addLast and getLast methods by changing references of
head and tail respectively. They are easy and constant operations.
<div style="margin: 10px"></div>
And here is implementaion of doubly linked list. Every node stores element data and two links: prev and next.
<div style="margin: 10px"></div>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">class</span> <span class="nc">DoublyLinkedList</span><span class="o"><</span><span class="no">E</span><span class="o">></span> <span class="o">{</span>
<span class="kd">private</span> <span class="nc">Node</span> <span class="n">head</span><span class="o">;</span> <span class="c1">// the first element</span>
<span class="kd">private</span> <span class="nc">Node</span> <span class="n">tail</span><span class="o">;</span> <span class="c1">// the last element</span>
<span class="kt">int</span> <span class="n">size</span><span class="o">;</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">add</span><span class="o">(</span><span class="no">E</span> <span class="n">element</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">element</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="k">throw</span> <span class="k">new</span> <span class="nc">AssertionError</span><span class="o">();</span>
<span class="c1">// tail and head are the same node when list has only one item</span>
<span class="k">if</span> <span class="o">(</span><span class="n">head</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">tail</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Node</span><span class="o">(</span><span class="n">element</span><span class="o">);</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="c1">//assign new node to next of tail and make tail the last element</span>
<span class="n">tail</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Node</span><span class="o">(</span><span class="n">element</span><span class="o">,</span> <span class="n">tail</span><span class="o">,</span> <span class="kc">null</span><span class="o">);</span>
<span class="n">tail</span> <span class="o">=</span> <span class="n">tail</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="n">size</span><span class="o">++;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">isEmpty</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="n">size</span> <span class="o">==</span> <span class="mi">0</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="nf">getSize</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="n">size</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="no">E</span> <span class="nf">get</span><span class="o">(</span><span class="kt">int</span> <span class="n">index</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">index</span> <span class="o">>=</span> <span class="n">size</span> <span class="o">&&</span> <span class="n">index</span> <span class="o"><</span> <span class="mi">0</span><span class="o">)</span> <span class="c1">// check boundaries</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">NoSuchElementException</span><span class="o">();</span>
<span class="c1">// find element at given index</span>
<span class="nc">Node</span> <span class="n">node</span> <span class="o">=</span> <span class="n">head</span><span class="o">;</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">index</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span>
<span class="n">node</span> <span class="o">=</span> <span class="n">node</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="k">return</span> <span class="n">node</span><span class="o">.</span><span class="na">elem</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">delete</span><span class="o">(</span><span class="no">E</span> <span class="n">element</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Node</span> <span class="n">temp</span> <span class="o">=</span> <span class="n">head</span><span class="o">;</span>
<span class="k">while</span> <span class="o">(</span><span class="n">temp</span> <span class="o">!=</span> <span class="kc">null</span> <span class="o">&&</span> <span class="o">!</span><span class="n">temp</span><span class="o">.</span><span class="na">elem</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="n">element</span><span class="o">))</span> <span class="o">{</span>
<span class="n">temp</span> <span class="o">=</span> <span class="n">temp</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="o">}</span>
<span class="c1">// no node with given element is found</span>
<span class="k">if</span> <span class="o">(</span><span class="n">temp</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="n">size</span><span class="o">--;</span>
<span class="c1">// if found node is head of the list, need to change to next element</span>
<span class="k">if</span> <span class="o">(</span><span class="n">temp</span> <span class="o">==</span> <span class="n">head</span><span class="o">)</span> <span class="o">{</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">head</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="o">}</span>
<span class="c1">// if found node is last node of the list, need to change tail</span>
<span class="k">if</span> <span class="o">(</span><span class="n">temp</span> <span class="o">==</span> <span class="n">tail</span><span class="o">)</span> <span class="o">{</span>
<span class="n">tail</span> <span class="o">=</span> <span class="n">temp</span><span class="o">.</span><span class="na">prev</span><span class="o">;</span>
<span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="o">}</span>
<span class="c1">// change links</span>
<span class="n">temp</span><span class="o">.</span><span class="na">prev</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">temp</span><span class="o">.</span><span class="na">next</span><span class="o">;</span>
<span class="n">temp</span><span class="o">.</span><span class="na">next</span><span class="o">.</span><span class="na">prev</span> <span class="o">=</span> <span class="n">temp</span><span class="o">.</span><span class="na">prev</span><span class="o">;</span>
<span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="o">}</span>
<span class="c1">// wrapper class for list elements</span>
<span class="kd">private</span> <span class="kd">class</span> <span class="nc">Node</span> <span class="o">{</span>
<span class="no">E</span> <span class="n">elem</span><span class="o">;</span>
<span class="nc">Node</span> <span class="n">next</span><span class="o">;</span>
<span class="nc">Node</span> <span class="n">prev</span><span class="o">;</span>
<span class="kd">public</span> <span class="nf">Node</span><span class="o">(</span><span class="no">E</span> <span class="n">elem</span><span class="o">)</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span class="na">elem</span> <span class="o">=</span> <span class="n">elem</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="nf">Node</span><span class="o">(</span><span class="no">E</span> <span class="n">elem</span><span class="o">,</span> <span class="nc">Node</span> <span class="n">prev</span><span class="o">,</span> <span class="nc">Node</span> <span class="n">next</span><span class="o">)</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span class="na">elem</span> <span class="o">=</span> <span class="n">elem</span><span class="o">;</span>
<span class="k">this</span><span class="o">.</span><span class="na">next</span> <span class="o">=</span> <span class="n">next</span><span class="o">;</span>
<span class="k">this</span><span class="o">.</span><span class="na">prev</span> <span class="o">=</span> <span class="n">prev</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
</E>
<div style="margin: 10px"></div>
This is the first blog about linked lists, you can read LinkedList Advanced Operations blog for
recursion, reversing and some other operation imlementations.
<br/>
<br/>
<script src="//platform.linkedin.com/in.js" type="text/javascript"> lang: en_US</script>
<script type="IN/Share" data-url="http://sherxon.com/blog/linked-list-2" data-counter="top"></script>This is the first blog on linked lists that contains implementations in Java and introduces basic operation such as add, get and delete. You can also read about problems and their solutions on linked lists on LinkedList Common Problems and Solutions post.