Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 26d81c0

Browse files
Create JavaEE003.md
1 parent 9bb660a commit 26d81c0

File tree

1 file changed

+359
-0
lines changed

1 file changed

+359
-0
lines changed

‎JavaAppLesson003/JavaEE003.md

Lines changed: 359 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,359 @@
1+
```java
2+
/*----------------------------------------------------------------------------------------------------------------------
3+
CommandLineUtil sınıfı ve test kodu
4+
----------------------------------------------------------------------------------------------------------------------*/
5+
package org.csystem.app;
6+
7+
import org.csystem.util.CommandLineUtil;
8+
import org.csystem.util.Console;
9+
10+
import java.util.Random;
11+
12+
class App {
13+
public static void main(String [] args)
14+
{
15+
CommandLineUtil.checkForLengthEqual(args, 3, "usage:<program> <n> <min> <max>");
16+
17+
var n = Integer.parseInt(args[0]);
18+
var min = Integer.parseInt(args[1]);
19+
var max = Integer.parseInt(args[2]);
20+
var random = new Random();
21+
22+
for (int i = 0; i < n; ++i)
23+
Console.writeLine(random.nextInt(max - min) + min);
24+
25+
Console.writeLine("Copyleft C and System Programmers Association");
26+
}
27+
}
28+
```
29+
```java
30+
/*----------------------------------------------------------------------------------------------------------------------
31+
CommandLineUtil sınıfı
32+
----------------------------------------------------------------------------------------------------------------------*/
33+
package org.csystem.app;
34+
35+
import org.csystem.util.CommandLineUtil;
36+
import org.csystem.util.Console;
37+
import org.csystem.util.StringUtil;
38+
39+
class App {
40+
public static void main(String [] args)
41+
{
42+
var arg = CommandLineUtil.getCommandLineArgsJoin(args, "Input your text:");
43+
44+
Console.writeLine(StringUtil.isPalindrome(arg) ? "Palindrome" : "Not a palindrome");
45+
Console.writeLine("Copyleft C and System Programmers Association");
46+
}
47+
}
48+
```
49+
```java
50+
/*----------------------------------------------------------------------------------------------------------------------
51+
Özyineleme (recursion), özyinelemeli algoritmalar ve özyinelemeli metotlar:
52+
Bir olgunun kendisine çok benzer bir olguyu içermesi durumuna özyineleme (recursion) denir. Örneğin bir
53+
dizin (directory) ağacını dolaşmak isteyelim. Dizin içerisindeki bir girişin bir dizin belrttiği durumda tekrar
54+
o dizin için de aynı işlemlerin yapılması gerekir. Yani karşımıza benzer yapı çıkmıştır. O zaman dizin yapısı
55+
özyineleme içermektedir.
56+
57+
Özyineleme içeren algoritmalara özyinelemeli algoritmaları (recursive algorithms) denilmektedir.
58+
Eğer bir algoritmayı çözmek için ilerlerken bir noktaya geldiğimizde, bu geldiğimiz noktadabaşladığımız noktaya
59+
çok benzer bir durumla karşılaşıyorsak muhtemelen bu algoritma özyinelemeli bir algoritmadır. Özyinelemeli
60+
algoritmlar tipik olarak kendi kendini çağıran metotlarla (recursive methods) gerçekleştirilmektedir. Tabi özyinelemeli
61+
bir algoritmanın başka biçimlerde de çözümleri olabilir.
62+
63+
Yazılım dünyasında karşımıza çıkan tipik özyinelemeli algoritmalardan bazıları şunlardır:
64+
- Dizin ağacının dolaşılması
65+
- Ağaçlar ve graflar gibi veri yapılarının dolaşılması ve bu veri yapılarında arama yapılması
66+
- Parsing algoritmaları
67+
- Özel bazı problemler (örneğin 8 vezir problemi)
68+
- Bazı sort işlemleri (quick sort, merge sort, heap sort vb)
69+
- Matematiksel bazı algoritmalar
70+
- Bazı optimizasyon algoritmaları
71+
72+
Algoritmik problemleri özyineleme bakımından üç gruba ayırabiliriz:
73+
1. Hem özyinelemesiz hem de özyinelemeli olarak gerçekleştirilebilecek problemler
74+
2. Yalnızca özyinelemeli olarak gerçekleştirilebilecek problemler
75+
3. Yalnızca özyinelemesiz olarak gerçekleştirilebilcek problemler
76+
77+
Birinci gruptaki algoritmalarda hangisinin daha verimli olacağı probleme göre değişebilmektedir.
78+
79+
Bilindiği gibi bir metodun parametre değişkenleri ve yerel değişkenler stack'de yaratılırlar. Ayrıca ayrıca aşağı
80+
seviyede bir metot çağrısında parametre değişkenleri ve yerel değişkenler dışında da stack'de yer ayrılması.Yani bir
81+
metot çağrısı stack'de belirli miktarda yer ayrılması anlamına gelir. Bu işlem çok fazla yapıldığında stack artık
82+
yetmez duruma gelebilir (stack overflow). Tabi bazı programlama ortamları stack taşması durumlarını mümkün
83+
olduğunda engellemeye yönelik çalışırlar. Örneğin Java'da diziler stack'de yaratılamaz. Dolayısıyla çok büyük
84+
sayıda eleman içeren diziler için stack'in taşması gibi bir durum oluşmaz.
85+
86+
Aslında bir metodun kendini çağırmasıyla başka bir metodu çağırması arasında hiç bir fark yoktur. Örneğin:
87+
88+
public static void bar()
89+
{
90+
int a;
91+
92+
....
93+
}
94+
95+
public static void foo()
96+
{
97+
int a;
98+
99+
...
100+
bar();
101+
...
102+
}
103+
104+
Burada bar çağrıldığında bar'ın içerisinde yine a değişkeni stack'de yaratılacaktır. bar sona erdiğinde akış çağrılan
105+
yerden devam edecektir. Metot kendi kendini çağırması da tamamen bu biçimde gerçekleşir:
106+
107+
public static void foo()
108+
{
109+
int a;
110+
111+
...
112+
foo();
113+
...
114+
}
115+
116+
Şüphesiz bri metodun kendi kendini çağırması durumunda belli bir noktaya kadar çağrı yapılmazsa yani çağrı
117+
durdurulmazsa sonsuz döngü oluşacak ve belli zaman sonra stack taşması olacaktır. Öyleyse kendi çağıran bir metodun
118+
belli bir noktadan sonra kendini çağırma işleminden vazgeçmesi gerekir
119+
----------------------------------------------------------------------------------------------------------------------*/
120+
```
121+
```java
122+
/*----------------------------------------------------------------------------------------------------------------------
123+
Aşağıdaki örnekte kendi kendini çağıran metot bu işlemi sürekli yaptığından StackOverflowException oluşur
124+
----------------------------------------------------------------------------------------------------------------------*/
125+
package org.csystem.app;
126+
127+
public class App {
128+
public static void main(String[] args)
129+
{
130+
Sample.foo();
131+
}
132+
}
133+
134+
class Sample {
135+
public static void foo()
136+
{
137+
foo();
138+
}
139+
}
140+
```
141+
```java
142+
/*----------------------------------------------------------------------------------------------------------------------
143+
Aşağıdaki örnekte metot kendini hep bir eksik değerle çağırmıştır. Parametre değişkeni olan n sıfır değerine
144+
geldiğinde artık kendini çağırma süreci sonlanmış ve çıkış süreci başlamıştır. Dikkat edilirse aşağıdaki
145+
örnekte bir tek foo(0) çağrısı return deyiminden dolayı sonlanır. Diğerleri ilgili çağrılar sonlandığından
146+
dolayı akışın ** ile belirtilen deyime gelmesinden dolayı sonlanma girmişlerdir. Örnekte foo(0) için
147+
"Çıkış:0" yazısının ekrana basılmadığına dikkat ediniz
148+
----------------------------------------------------------------------------------------------------------------------*/
149+
package org.csystem.app;
150+
151+
import org.csystem.util.Console;
152+
153+
public class App {
154+
public static void main(String[] args)
155+
{
156+
Sample.foo(3);
157+
}
158+
}
159+
160+
class Sample {
161+
public static void foo(int n)
162+
{
163+
Console.writeLine("Giriş:%d", n);
164+
165+
if (n == 0)
166+
return;
167+
168+
foo(n - 1);
169+
Console.writeLine("Çıkış:%d", n); //**
170+
}
171+
}
172+
```
173+
```java
174+
/*----------------------------------------------------------------------------------------------------------------------
175+
Faktoriyel hesaplayan metodun özyinelemesiz biçimi
176+
----------------------------------------------------------------------------------------------------------------------*/
177+
package org.csystem.app;
178+
179+
import org.csystem.samples.recurison.Util;
180+
import org.csystem.util.Console;
181+
182+
public class App {
183+
public static void main(String[] args)
184+
{
185+
FactorialTest.run();
186+
}
187+
}
188+
189+
class FactorialTest {
190+
public static void run()
191+
{
192+
for (int n = 0; n < 13; ++n)
193+
Console.writeLine("%d!=%d", n, Util.factorial(n));
194+
}
195+
}
196+
```
197+
```java
198+
/*----------------------------------------------------------------------------------------------------------------------
199+
Faktoriyel hesaplayan metodun özyinelemeli biçimi
200+
----------------------------------------------------------------------------------------------------------------------*/
201+
package org.csystem.app;
202+
203+
import org.csystem.samples.recurison.RecursionUtil;
204+
import org.csystem.util.Console;
205+
206+
public class App {
207+
public static void main(String[] args)
208+
{
209+
FactorialTest.run();
210+
}
211+
}
212+
213+
class FactorialTest {
214+
public static void run()
215+
{
216+
for (int n = -1; n < 13; ++n)
217+
Console.writeLine("%d!=%d", n, RecursionUtil.factorial(n));
218+
}
219+
}
220+
221+
package org.csystem.samples.recurison;
222+
223+
public class RecursionUtil {
224+
public static long factorial(int n)
225+
{
226+
long result;
227+
228+
if (n <= 0)
229+
return 1;
230+
231+
result = n * factorial(n - 1);
232+
233+
return result;
234+
}
235+
}
236+
```
237+
```java
238+
/*----------------------------------------------------------------------------------------------------------------------
239+
Faktoriyel hesaplayan metodun özyinelemeli biçimi
240+
----------------------------------------------------------------------------------------------------------------------*/
241+
package org.csystem.app;
242+
243+
import org.csystem.samples.recurison.RecursionUtil;
244+
import org.csystem.util.Console;
245+
246+
public class App {
247+
public static void main(String[] args)
248+
{
249+
FactorialTest.run();
250+
}
251+
}
252+
253+
class FactorialTest {
254+
public static void run()
255+
{
256+
for (int n = -1; n < 13; ++n)
257+
Console.writeLine("%d!=%d", n, RecursionUtil.factorial(n));
258+
}
259+
}
260+
```
261+
```java
262+
/*----------------------------------------------------------------------------------------------------------------------
263+
Bir yazıyı tersten yazdırma algoritmasının özyinelemesiz biçimi
264+
----------------------------------------------------------------------------------------------------------------------*/
265+
package org.csystem.app;
266+
267+
import org.csystem.samples.recurison.Util;
268+
import org.csystem.util.Console;
269+
270+
public class App {
271+
public static void main(String[] args)
272+
{
273+
WriteReverseTest.run();
274+
}
275+
}
276+
277+
class WriteReverseTest {
278+
public static void run()
279+
{
280+
for (;;) {
281+
var s = Console.read("Bir yazı giriniz:");
282+
283+
Util.writeReverse(s);
284+
Console.writeLine();
285+
286+
if (s.equals("quit"))
287+
break;
288+
}
289+
}
290+
}
291+
```
292+
```java
293+
/*----------------------------------------------------------------------------------------------------------------------
294+
Bir yazıyı tersten yazdırma algoritmasının özyinelemeli biçimi
295+
----------------------------------------------------------------------------------------------------------------------*/
296+
package org.csystem.app;
297+
298+
import org.csystem.samples.recurison.RecursionUtil;
299+
import org.csystem.util.Console;
300+
301+
public class App {
302+
public static void main(String[] args)
303+
{
304+
WriteReverseTest.run();
305+
}
306+
}
307+
308+
class WriteReverseTest {
309+
public static void run()
310+
{
311+
for (;;) {
312+
var s = Console.read("Bir yazı giriniz:");
313+
314+
RecursionUtil.writeReverse(s);
315+
Console.writeLine();
316+
317+
if (s.equals("quit"))
318+
break;
319+
}
320+
}
321+
}
322+
```
323+
```java
324+
/*----------------------------------------------------------------------------------------------------------------------
325+
Bir yazıyı tersyüz etme yazdırma algoritmasının özyinelemeli biçimi
326+
----------------------------------------------------------------------------------------------------------------------*/
327+
package org.csystem.app;
328+
329+
import org.csystem.samples.recurison.RecursionUtil;
330+
import org.csystem.util.Console;
331+
332+
public class App {
333+
public static void main(String[] args)
334+
{
335+
GetReverseTest.run();
336+
}
337+
}
338+
339+
class GetReverseTest {
340+
public static void run()
341+
{
342+
for (;;) {
343+
var s = Console.read("Bir yazı giriniz:");
344+
345+
var revStr = RecursionUtil.getReverse(s);
346+
347+
Console.writeLine(revStr);
348+
349+
if (s.equals("quit"))
350+
break;
351+
}
352+
}
353+
}
354+
355+
/*----------------------------------------------------------------------------------------------------------------------
356+
357+
----------------------------------------------------------------------------------------------------------------------*/
358+
```
359+

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /