二分探索法(バイナリサーチ)について

二分探索法は、探索の対象となるデータが、あらかじめ昇順または降順に整列されている場合に使うことができるアルゴリズムです。

このアルゴリズムは、次のような手順で目的の値の位置を調べていきます。

1. 探索する値とデータ列の真ん中にある要素の値を比較します。
2. その大小関係により、探索する値が、中央より前半または後半にあるか絞り込みます。
3. 探索する値と絞り込んだデータ列の真ん中にある要素の値を比較します。

このように探索する範囲を半分ずつ狭めていくことで、目的の値がある位置を特定していきます。

データ列の後方部分でも高速に探索できるので、データ数が多い探索にはリニアサーチよりも有利です。

しかし、データ数が少ない場合や、目的の値が先頭付近にある場合は、リニアサーチのほうが速く探索できます

また、整列されていないデータの探索にはバイナリサーチは使えません。

二分探索法のイメージ

以下の図は二分探索法を使ってデータを小さい順(昇順)に並べ替える様子のイメージです。

[二分探索法のイメージ]

サンプルコード

二分探索法のアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：binary-search.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 二分探索法(binary search:バイナリサーチ)

#  arr   : 数値リスト
# left   : 左端要素のindex
# right  : 右端要素のindex
# center : 中央要素のindex
# target : 探索値

array set arr {0 11 1 13 2 24 3 26 4 35
                5 37 6 46 7 49 8 54 9 68}
parray arr

puts -nonewline "探索値を入力する。: "
flush stdout

set target [gets stdin]

set left 0
set right [expr [array size arr] - 1]

while {$left <= $right} {
    set center [expr ($left + $right)/2]  ;# 要素の真ん中の位置
    if {$arr($center) == $target} {
        puts "探索値: $target は0から数えて $center 番目にあります。"
        exit
    } elseif {$arr($center) < $target} {
        set left [expr $center + 1]
    } else {
        set right [expr $center - 1]
    }
}
puts "探索値: $target は見つかりませんでした。"

[実行例]

$ ./binary-search.tcl
arr(0) = 11
arr(1) = 13
arr(2) = 24
arr(3) = 26
arr(4) = 35
arr(5) = 37
arr(6) = 46
arr(7) = 49
arr(8) = 54
arr(9) = 68
探索値を入力する。: 54
探索値: 54 は0から数えて 8 番目にあります。

$ ./binary-search.tcl
arr(0) = 11
arr(1) = 13
arr(2) = 24
arr(3) = 26
arr(4) = 35
arr(5) = 37
arr(6) = 46
arr(7) = 49
arr(8) = 54
arr(9) = 68
探索値を入力する。: 55
探索値: 55 は見つかりませんでした。

Python

[サンプル：binary-search.py]

#!/usr/bin/env python3

import sys

# 二分探索法(binary search:バイナリサーチ)

#  arr   : 数値リスト
#   n    : 要素数
# left   : 左端要素のindex
# right  : 右端要素のindex
# center : 中央要素のindex
# target : 探索値

arr = [11, 13, 24, 26, 35, 37, 46, 49, 54, 68]
print(arr)

target = input('探索値を入力する。: ')
target = int(target)    # 文字列から数値に変換

n = len(arr)
left = 0
right = n-1

while left <= right:
    center = (left + right) // 2    # 要素の真ん中の位置
    if arr[center] == target:
        print(f'探索値:{target} は0から数えて {center} 番目にあります。')
        sys.exit()
    elif  arr[center] < target:
        left = center + 1
    else:
        right = center - 1

print(f'探索値:{target} は見つかりませんでした。')

[実行例]

$ ./binary-search.py
[11, 13, 24, 26, 35, 37, 46, 49, 54, 68]
探索値を入力する。: 54
探索値:54 は0から数えて 8 番目にあります。

$ ./binary-search.py
[11, 13, 24, 26, 35, 37, 46, 49, 54, 68]
探索値を入力する。: 55
探索値:55 は見つかりませんでした。

線形探索法(リニアサーチ)について

線形探索法は、データ列の先頭から順番に調べて目的の要素を探すアルゴリズムです。

探索のイメージが一直線(linear)に探していく様子からリニアサーチと呼ばれています。

単純でわかりやすいアルゴリズムですが、探索の効率はよくありません。データ数が多くなればなるほど、後方部分の探索に時間がかかります。

線形探索法のイメージ

以下の図は線形探索法を使って探索値を探し出す様子のイメージです。

[線形探索法のイメージ]

サンプルコード

線形探索法のアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：linear-search.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 線形探索法(linear search:リニアサーチ)

#  arr   : 数値リスト
#   n    : 要素数
#   i    : 探索する要素の位置
# target : 探索値

array set arr {0 40 1 10 2 30 3 50 4 20}
set n [array size arr]

parray arr

puts -nonewline "探索値を入力する。: "
flush stdout

set target [gets stdin]

set i 0

while {$i < $n} {
    if {$arr($i) == $target} {
        puts "探索値: $target は0から数えて $i 番目にあります。"
        exit
    }
    incr i
}

puts "探索値: $target は見つかりませんでした。"

[実行例]

$ ./linear-search.tcl
arr(0) = 40
arr(1) = 10
arr(2) = 30
arr(3) = 50
arr(4) = 20
探索値を入力する。: 50
探索値: 50 は0から数えて 3 番目にあります。

$ ./linear-search.tcl
arr(0) = 40
arr(1) = 10
arr(2) = 30
arr(3) = 50
arr(4) = 20
探索値を入力する。: 80
探索値: 80 は見つかりませんでした。

Python

[サンプル：linear-search.py]

#!/usr/bin/env python3

import sys

# 線形探索法(linear search:リニアサーチ)

#  arr   : 数値リスト
#   n    : 要素数
#   i    : 探索する要素の位置
# target : 探索値

arr = [40, 10, 30, 50, 20]
n = len(arr)

print(arr)

# 探索する値を入力
target = input('探索値を入力する。: ')
target = int(target)    # 文字列から数値に変換

# 探索する(リニアサーチ)
i = 0

while i < n:
    if arr[i] == target:
        print(f'探索値: {target} は0から数えて {i} 番目にあります。')
        sys.exit()

    i += 1

print(f'探索値: {target} は見つかりませんでした。')

[実行例]

$ ./linear-search.py
[40, 10, 30, 50, 20]
探索値を入力する。: 50
探索値: 50 は0から数えて 3 番目にあります。

$ ./linear-search.py
[40, 10, 30, 50, 20]
探索値を入力する。: 80
探索値: 80 は見つかりませんでした。

単純挿入法(挿入ソート)について

単純挿入法は、未整列のデータの中から要素を順番に取り出して、整列済みのデータ列の適切な位置に挿入していくことで整列を行うアルゴリズムです。

挿入ソートの平均的な実行速度はバブルソートと大差はありませんが、ソートを行う前のデータが昇順や降順にある程度並んでいる場合には、高速な処理が期待できます。

挿入ソートは整列済みのデータに、新しい要素を追加して再び整列を行う場合などに使用します。

単純挿入法のイメージ

以下の図は単純挿入法を使ってデータを小さい順(昇順)に並べ替える様子のイメージです。

[単純挿入法のイメージ]

サンプルコード

単純挿入法のアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：insertion-sort.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 単純挿入法(insertion sort:挿入ソート)

#  arr  : 数値リスト
#   n   : 要素数
#   i   : 未整列データの先頭の位置
#  tmp  : 挿入する要素の値
# blank : 空き要素の位置

array set arr {0 40 1 10 2 30 3 50 4 20}
set n [array size arr]

set i 1    ;# 0番目は暫定で整列済みとするので1で初期化する。

while {$i < $n} {
    set tmp $arr($i)
    set blank $i

    # 右にシフトさせる。
    while {$blank > 0 && $arr([expr $blank -1]) > $tmp} {
        set arr($blank) $arr([expr $blank -1])
        incr blank -1
    }
    # シフト後の空スペースに要素を挿入する。
    set arr($blank) $tmp

    incr i
}
parray arr

[実行例]

$ ./insertion-sort.tcl
arr(0) = 10
arr(1) = 20
arr(2) = 30
arr(3) = 40
arr(4) = 50

[補足説明]

右にシフトせさるところは、

• blank(空き要素の位置)がゼロより大きい かつ
• arr[blank-1] > tmp の関係が続く間

arr[blank-1]の要素を右にシフトします。

イメージ図でいうところの整列済み(水色)の要素値をarr[blank-1] > tmpの関係が続く間、右に１つずつ移動させます。

イメージ図の４回目の部分を見て頂くとイメージしやすいと思います。

Python

[サンプル：insertion-sort.py]

#!/usr/bin/env python3

# 単純挿入法(insertion sort:挿入ソート)

#  arr  : 数値リスト
#   n   : 要素数
#   i   : 未整列データの先頭の位置
#  tmp  : 挿入する要素の値
# blank : 空き要素の位置

arr = [40, 10, 30, 50, 20]
n = len(arr)

print(arr)

i = 1           # 0番目は暫定で整列済みとするので1で初期化する。

while i < n:
    tmp = arr[i]
    blank = i

    # 右にシフトする。
    while blank > 0 and arr[blank-1] > tmp:
        arr[blank] = arr[blank-1]
        blank = blank-1

    # シフト後の空スペースに要素を挿入する。
    arr[blank] = tmp

    i += 1

print(arr)

[実行例]

$ ./insertion-sort.py
[40, 10, 30, 50, 20]
[10, 20, 30, 40, 50]

[補足説明]

右にシフトせさるところは、

• blank(空き要素の位置)がゼロより大きい かつ
• arr[blank-1] > tmp の関係が続く間

arr[blank-1]の要素を右にシフトします。

イメージ図でいうところの整列済み(水色)の要素値をarr[blank-1] > tmpの関係が続く間、右に１つずつ移動させます。

イメージ図の４回目の部分を見て頂くとイメージしやすいと思います。

単純選択法(選択ソート)について

単純選択法は、以下のような手順で並べ替えていくアルゴリズムです。

データ列の中から一番小さい値を選択し、それを0番目の要素と交換する。
次に、残りのデータ列の中から一番小さい値を選択し、それを1番目の要素と交換する。
これをデータの最後まで繰り返し行う事により、先頭から順に並べ替えていきます。

一番小さい値を選択しながら整列していくので、単純選択法は選択ソート(selection sort)と呼ばれています。

選択ソートはバブルソートと比較回数は同じですが、各ループでの交換回数が最大１回となっているので選択ソートの方が高速です。

単純選択法のイメージ

以下の図は単純選択法を使ってデータを小さい順(昇順)に並べ替える様子のイメージです。

[単純選択法のイメージ]

サンプルコード

単純選択法のアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：selection-sort.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 単純選択法(selection sort:選択ソート)

#      arr : 数値リスト
#        n : 要素数
#      i,j : 要素のindex
#      tmp : 交換用
# indexMin : 最小値の位置

array set arr {0 40 1 10 2 30 3 50 4 20}
set n [array size arr]

set i 0    ;# 外側のループカウンタ。

while {$i < $n - 1} {

    set indexMin $i        ;# i番目を暫定で最小値とする。
    set j [expr $i + 1]    ;# 内側のループカウンタ。

    # 最小値の位置を探す。
    # このループでindexMinには未整列中の最小値の位置がセットされる。
    while {$j < $n} {
        if {$arr($j) < $arr($indexMin)} {
            set indexMin $j
        }
        incr j
    }

    # 最小値とi番目の値を交換する。
    set tmp $arr($i)
    set arr($i) $arr($indexMin)
    set arr($indexMin) $tmp

    incr i
}
parray arr

[実行例]

$ ./selection-sort.tcl
arr(0) = 10
arr(1) = 20
arr(2) = 30
arr(3) = 40
arr(4) = 50

Python

[サンプル：selection-sort.py]

#!/usr/bin/env python3

# 単純選択法(selection sort:選択ソート)

#      arr : 数値リスト
#        n : 要素数
#      i,j : 要素のindex
#      tmp : 交換用
# indexMin : 最小値の位置

arr = [40, 10, 30, 50, 20]
print(arr)

n = len(arr)    # 要素数
i = 0           # 外側のループカウンタ。

while i < n-1:
    indexMin = i    # i番目を暫定で最小値とする。
    j = i+1         # 内側のループカウンタ。

    # 最小値の位置を探す。
    # このループでindexMinには未整列中の最小値の位置がセットされる。
    while j < n:
        if arr[j] < arr[indexMin]:
            indexMin = j

        j += 1

    # 最小値とi番目の値を交換する。
    tmp = arr[i]
    arr[i] = arr[indexMin]
    arr[indexMin] = tmp

    i += 1

print(arr)

[実行例]

$ ./selection-sort.py
[40, 10, 30, 50, 20]
[10, 20, 30, 40, 50]

単純交換法(バブルソート)について

単純交換法は、隣り合ったデータの大小を比較して交換するという作業を繰り返して行い、最終的にデータを昇順または降順に並べ替えるアルゴリズムです。

このアルゴリズムは、並べ替える様子が、水中から水面へ浮かび上がっていく泡のように見えることから、バブルソート(bubble sort)と呼ばれています。

バブルソートの説明を先頭の要素から順番に比較する方法で説明しているサイトや本がありますが、泡のイメージを出す為に水の底(末尾)から水面(先頭)に向かって順番に比較する方法で説明します。

小さい数字を上へ持ち上げていくイメージです。

どちらの方法も考え方は同じですが、末尾の要素から先頭の要素に向かって順番に比較していく方法を説明しているものが多いように思います。

単純交換法のイメージ

以下の図は単純交換法を使ってデータを小さい順(昇順)に並べ替える様子のイメージです。

[単純交換法のイメージ]

サンプルコード

単純交換法のアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：bubble-sort.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 単純交換法(bubble sort:バブルソート)

# arr : 数値リスト
#  n  : 要素数
#  i  : 要素のindex
# tmp : 交換用
# last: 確定した最小値を入れる位置

array set arr {0 40 1 10 2 30 3 50 4 20}
set n [array size arr]

set last 0

while {$last < $n - 1} {
    set i [expr $n - 1]
    while {$i > $last} {

         # 隣り合ったデータの大小を比較して交換する。
        if {$arr([expr $i -1]) > $arr($i)} {
            set tmp $arr([expr $i -1])
            set arr([expr $i -1]) $arr($i)
            set arr($i) $tmp
        }
        incr i -1
    }
    incr last
}
parray arr

[実行例]

$ ./bubble-sort.tcl
arr(0) = 10
arr(1) = 20
arr(2) = 30
arr(3) = 40
arr(4) = 50

Python

[サンプル：bubble-sort.py]

#!/usr/bin/env python3

# 単純交換法(bubble sort:バブルソート)

# arr : 数値リスト
#  n  : 要素数
#  i  : 要素のindex
# tmp : 交換用
# last: 確定した最小値を入れる位置

arr = [40, 10, 30, 50, 20]
n = len(arr)

print(arr)

last = 0

while last < n-1:
    i = n-1
    while i > last:

        # 隣り合ったデータの大小を比較して交換する。
        if arr[i-1] > arr[i]:
            tmp = arr[i-1]
            arr[i-1] = arr[i]
            arr[i] = tmp

        i -= 1

    last += 1

print(arr)

[実行例]

$ ./bubble-sort.py
[40, 10, 30, 50, 20]
[10, 20, 30, 40, 50]

素数について

素数とは、以下の条件を満たす数値です。

• 1より大きい数値　かつ
• 1と自分自身以外の数値では割れない数値。

例
「5」は1と5以外の数値で割れないので素数です。
「6」は1,2,3,6で割れるので素数ではない。

参考：素数の一覧

素数の判定をするアルゴリズム

素数を判定するアルゴリズムはいくつかありますが、単純なアルゴリズムを２つ紹介します。

すべてのパターンを試す判定方法

このアルゴリズムは入力した数値を2から入力した数値未満の数で順番に試し割りを行い、割り切れるかどうか確認する方法です。

割り切れた場合、「1と自分自身以外の数値では割れない数値」に合致しないので、素数ではないと判定できます。判定できた時点で反復処理を終了させます。

入力した数値未満の数で割り切れない場合は素数と判定します。

単純なアルゴリズムですが、割り切れるまで順番に試すので低速です。

偶数を除外する判定方法

奇数と偶数を判定するアルゴリズムで説明したように、偶数は2で割り切れることが分かっています。

よって2の倍数(2,4,6,8…)で割る処理を除外します。

2の倍数を除外するにはカウントアップ用の変数を3で初期化しておき+2ずつカウントアップするようにします。

偶数を除外することによりループ回数が半分になるので、その分速くなります。

サンプルコード

素数を判定するアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：prime-number.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 素数判定(すべてのパターンを試す)

#  num : 数値。
# flag : 素数判定。0:素数。 1:素数ではない。
#   i  : ループカウンタ。 

puts -nonewline "数値を入力してください : "
flush stdout
set num [gets stdin]

set flag 0    ;# 0で初期化。

if {$num < 2} {
    set flag 1        ;# 0,1は素数でない為、除外する。
}

# 2以上の数値を判定。

set i 2

while {$i < $num} {
    if {$num % $i == 0} {
        set flag 1    ;# 割り切れた。
        break         ;# ループを抜ける。
    }
    incr i
}

# 判定結果を出力する。

if {$flag == 0} {
    puts "$num は素数です。"
} else {
    puts "$num は素数ではありません。"
}

[実行例]

$ ./prime-number.tcl
数値を入力してください : 11
11 は素数です。

$ ./prime-number.tcl
数値を入力してください : 12
12 は素数ではありません。

[サンプル：prime-number2.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 素数判定(偶数を除外する)

#  num : 数値。
# flag : 素数判定。0:素数。 1:素数ではない。
#   i  : ループカウンタ。 

puts -nonewline "数値を入力してください : "
flush stdout
set num [gets stdin]

set flag 0    ;# 0で初期化。

# 0,1,2及び偶数の判定

if {$num < 2} {
    set flag 1         ;# 0,1は素数でない為、除外する。
} elseif {$num == 2} {
    set flag 0         ;# 2は素数。
} elseif {$num % 2 == 0} {
    set flag 1         ;# 偶数は素数でない為、除外する。
} 

# 3以上の奇数を判定する。

set i 3
while {$i < $num} {
    if {$num % $i == 0} {
        set flag 1    ;# 割り切れた。
        break         ;# ループを抜ける。
    }
    incr i +2
}

# 判定結果を出力する。

if {$flag == 0} {
    puts "$num は素数です。"
} else {
    puts "$num は素数ではありません。"
}

[実行例]

$ ./prime-number2.tcl
数値を入力してください : 11
11 は素数です。

$ ./prime-number2.tcl
数値を入力してください : 12
12 は素数ではありません。

Python

[サンプル：prime-number.py]

#!/usr/bin/env python3

# 素数判定(すべてのパターンを試す)

#  num : 数値。
# flag : 素数判定。0:素数。 1:素数ではない。
#   i  : ループカウンタ。 

num = input('数字を入力してください。: ')
num = int(num)    # 文字列から数値に変換

flag = 0    # 0で初期化。

if num < 2:
    flag = 1    # 0,1は素数でない為、除外する

# 2以上の数値を判定。

i = 2

while i < num:
    if num % i == 0:
        flag = 1    # 割り切れた。
        break       # ループを抜ける。

    i += 1

# 判定結果を出力する。

if flag == 0:
    print(num,'は素数です。')
else:
    print(num,'は素数ではありません。')

[実行例]

$ ./prime-number.py
数字を入力してください。: 11
11 は素数です。

$ ./prime-number.py
数字を入力してください。: 12
12 は素数ではありません。

[サンプル：prime-number2.py]

#!/usr/bin/env python3

# 素数判定(偶数を除外する)

#  num : 数値。
# flag : 素数判定。0:素数。 1:素数ではない。
#   i  : ループカウンタ。 

num = input('数字を入力してください。: ')
num = int(num)    # 文字列から数値に変換

flag = 0    # 0で初期化。

# 0,1,2及び偶数の判定

if num < 2:
    flag = 1    # 0,1は素数でないため除外する。
elif num == 2:
    flag = 0    # 2は素数。
elif num % 2 == 0:
    flag = 1    # 偶数は素数でないため除外する。

# 3以上の奇数を判定する。

i = 3

while i < num:
    if num % i == 0:
        flag = 1    # 割り切れた。
        break       # ループを抜ける。

    i += 2

# 判定結果を出力する。

if flag == 0:
    print(num,'は素数です。')
else:
    print(num,'は素数ではありません。')

[実行例]

$ ./prime-number2.py
数字を入力してください。: 11
11 は素数です。

$ ./prime-number2.py
数字を入力してください。: 12
12 は素数ではありません。

奇数と偶数の定義について

ゼロは偶数か？

奇数と偶数の定義にはゼロを含めるかどうかで２つの考え方があります。

＜その１＞

• 偶数は自然数の中で２で割り切れる数。
• 奇数は自然数の中で２で割り切れない数。

自然数とは、ゼロやマイナスの数ではなく１から始まる数（正の整数）の事です。

この定義だと、「ゼロは偶数でも奇数でもない」という事になります。

※自然数にゼロを含めるという考えもあるようです。

＜その２＞

• 偶数は２で割り切れる整数。
• 奇数は２で割り切れない整数。

この定義だと 「0÷2=0」となり割り切れるので「ゼロは偶数」という事になります。-2,-4も偶数です。

物理的に考えると「ゼロは何も無い(存在しない)」という事なので、物理的に存在しないものを割ることは出来ないので＜その１＞のほうが正解のように思えます。

しかし、数学的観点で考えると＜その２＞のほうが正解だそうです。

小学校の算数でもゼロは偶数と教えているそうです。

以上の事から、ゼロは偶数という定義をした場合の奇数と偶数を判定するアルゴリズムを紹介します。

奇数と偶数の判定方法

奇数か偶数か判定するには「%」演算子を使います。

「%」演算子は剰余(ジョウヨ)を計算します。剰余とは、割り算で割り切れなかった余りです。

2で割って余りが出たら奇数、割り切れたら偶数です。

サンプルコード

奇数と偶数を判定するアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：odd-even.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 奇数と偶数の判定

puts -nonewline stdout "数字を入力してください："
flush stdout

set num [gets stdin]

if {$num % 2 == 0} {
    puts "入力した数字は偶数です。"
} else {
    puts "入力した数字は奇数です。"
}

[実行例]

$ ./odd-even.tcl
数字を入力してください：11
入力した数字は奇数です。
$ ./odd-even.tcl
数字を入力してください：12
入力した数字は偶数です。
$ ./odd-even.tcl
数字を入力してください：0
入力した数字は偶数です。

Python

[サンプル：odd-even.py]

#!/usr/bin/env python3

# 奇数と偶数の判定

num = input('数字を入力してください。: ')
num = int(num)    # 文字列から数値に変換

if num % 2 == 0:
    print('入力した数字は偶数です。')
else:
    print('入力した数字は奇数です。')

[実行例]

$ ./odd-even.py
数字を入力してください。: 11
入力した数字は奇数です。

$ ./odd-even.py
数字を入力してください。: 12
入力した数字は偶数です。

$ ./odd-even.py
数字を入力してください。: 0
入力した数字は偶数です。

要素の中から最大値を探す

要素1, 要素2, 要素3, ・・・ 要素n

まずは、人間がn個の要素の中から最も大きい値を探すには、どのような手順で探すか考えてみましょう。

1. 最初に要素1と要素2を比較して大きい値の方を控える。
2. 次に控えた値と要素3を比較して大きい値の方を控える。
3. さらに2で控えた値と要素4を比較して大きい値の方を控える。

これを要素nまで繰り返すと一番大きい値を探し出せます。

このアルゴリズムでは、1つ目の処理と2つ目以降の処理に違いがあります。1つ目の処理では要素1と要素2を比較しています。2つ目以降の処理では控えた値と要素を比較しています。

2つ目以降の処理は同じ手続きなので、この部分を反復処理させれば要素の個数が増えても対応できそうですね。

プログラミングのアルゴリズムを考える場合、もう一工夫してアルゴリズムをすっきりさせます。

1. まず、要素1が最大値と仮定して変数maxに代入します。
2. 次に、変数maxと要素2を比較して要素2の値のほうが大きい場合、要素2の値を変数maxに代入します。

2の処理を要素nまで繰り返すと変数maxには最も大きい値がセットされます。

最小値を探す手順も、探す値が最大値か最小値かの違いだけで同じ手順になります。

アルゴリズムのイメージ

最大値を探すイメージは以下の図のようになります。

[最大値を探す]

要素値の範囲が2桁の整数値で構成されている等、要素の範囲が決まっている場合、さらにアルゴリズムをすっきりさせる事ができます。

例えば、最大値を0で初期化する、最小値を100で初期化するなど要素の範囲外の値をセットする。

[最大値を探す2]

foreachなど便利な制御構造をサポートしているプログラミング言語では最大値を0で初期化するやり方のほうがすっきり記述できると思います。

サンプルコード

最大値を探すアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：max.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# n個の要素の中から最大値を探す。

# arr : 数値リスト
#  n  : 要素数
#  i  : 要素のindex
# max : 最大値

array set arr {0 31 1 22 2 53 3 14 4 45}
set n [array size arr]

set max $arr(0)    ;# 要素0の値を暫定で最大値とする
set i 1            ;# 1で初期化

while {$i < $n} {
    if {$arr($i) > $max} {
        set max $arr($i)
    }
    incr i
}

parray arr
puts "一番大きい値は $max です。"

[実行例]

$ ./max.tcl
arr(0) = 31
arr(1) = 22
arr(2) = 53
arr(3) = 14
arr(4) = 45
一番大きい値は 53 です。

[リスト、foreachを使った例：max2.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# n個の要素の中から最大値を探す。

# lst : 数値リスト
# max : 最大値

set lst {31 22 53 14 45}

set max 0    ;# 数値0を暫定で最大値とする

foreach x $lst {
    if {$x > $max} {
        set max $x
    }
}


puts "数値リスト: $lst"
puts "一番大きい値は $max です。"

[実行例]

$ ./max2.tcl
数値リスト: 31 22 53 14 45
一番大きい値は 53 です。

Python

[サンプル：max.py]

#!/usr/bin/env python3

# n個の要素の中から最大値を探す。

# lst : 数値リスト
#  n  : 要素数
#  i  : 要素のindex
# max : 最大値

lst = [31, 22, 53, 14, 45]
n = len(lst)

max = lst[0] # 要素0の値を暫定で最大値とする
i = 1        #  1で初期化

while i < n:
    if lst[i] > max:
        max = lst[i]

    i += 1

print(lst)
print('一番大きい値は {0} です。'.format(max))

[実行例]

$ ./max.py
[31, 22, 53, 14, 45]
一番大きい値は 53 です。

[forを使った例：max2.py]

#!/usr/bin/env python3

# n個の要素の中から最大値を探す。

# lst : 数値リスト
# max : 最大値

lst = [31, 22, 53, 14, 45]

max = 0    # 数値0を暫定で最大値とする

for x in lst:
    if x > max:
        max = x

print(lst)
print('一番大きい値は {0} です。'.format(max))

[実行例]

$ ./max2.py
[31, 22, 53, 14, 45]
一番大きい値は 53 です。

数値の合計を計算する

複数の数値を合計するには、以下のように単純に数値を足し算すれば計算できます。

sum = 値1+値2+値3+値4+値5

これでも構わないのですが、数が100個、1000個のように多くなれば、足し算する処理を書くのに手間がかかり大変です。

そこで、足し算する処理に反復処理を使います。

例えば、人間が合計を計算する場合、どのような手順で計算するか考えてみましょう。

1. まず、値1と値2を足し算します。その値を控えます。
2. 次に、控えた値と値3の足し算をして、その値を控えます。
3. さらに2で控えた値と値4を足し算して、その値を控えます。

これを最後の数値まで繰り返すと合計を求める事ができます。

この手順と同じように反復処理を使って足し算を繰り返し計算するアルゴリズムを考えます。

合計を計算するイメージ

反復処理を使って合計を計算するイメージは以下の図のようになります。

[n個の数値を合計する]

配列のインデックスは0から始まるのでn個の要素を繰り返し参照するには以下のように指定します。

• インデックス用の変数iを0で初期化する。
• 繰り返し条件は(i < n)にする。

繰り返し条件の比較を要素数ではなくインデックス番号で指定する場合は、(i <= n-1)のように指定します。

平均値を計算する

平均値(Average)を計算するには、合計した値を個数で割った値になります。

サンプルコード

合計と平均値を計算するアルゴリズムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[配列を使った例：avg.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 合計と平均値を計算する

# arr : 数値リスト
#  n  : 要素数
#  i  : 要素のindex
# sum : 合計
# avg : 平均値(Average)

array set arr {0 11 1 12 2 13 3 14 4 15}
set n [array size arr]

set sum 0
set   i 0

while {$i < $n} {
    set sum [expr $sum + $arr($i)]
    incr i
}

set avg [expr $sum.0 / $n]
puts "合計：$sum　平均値：$avg"

[実行例]

$ ./avg.tcl
合計：65　平均値：13.0

[リスト、foreachを使った例：avg2.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# 合計と平均値を計算する

# lst : 数値リスト
#  n  : 要素数
# sum : 合計
# avg : 平均値(Average)

set lst {11 12 13 14 15}
set n [llength $lst]

set sum 0

foreach x $lst {
    set sum [expr $sum + $x]
}

set avg [expr $sum.0 / $n]
puts "合計：$sum　平均値：$avg"

[実行例]

$ ./avg2.tcl
合計：65　平均値：13.0

Python

[whileを使った例：avg.py]

#!/usr/bin/env python3

# 合計と平均値を計算する

# lst : 数値リスト
#  n  : 要素数
#  i  : 要素のindex
# sum : 合計
# avg : 平均値(Average)

lst = [11, 12, 13, 14, 15]
n = len(lst)

sum = 0
i = 0

while i < n:
    sum = sum + lst[i]
    i += 1

avg = sum/n
print('Total   = ', sum)
print('Average = ', avg)

[実行例]

$ ./avg.py
Total   =  65
Average =  13.0

[forを使った例：avg2.py]

#!/usr/bin/env python3

# 合計と平均値を計算する

# lst : 数値リスト
#  n  : 要素数
# sum : 合計
# avg : 平均値(Average)

lst = [11, 12, 13, 14, 15]
n = len(lst)

sum = 0

for num in lst:
    sum = sum + num

avg = sum/n
print('Total   = ', sum)
print('Average = ', avg)

[実行例]

$ ./avg2.py
Total   =  65
Average =  13.0

２つの変数の値を交換する

プログラミングにおいて変数aと変数bの値を交換するにはどのような手順を行えばいいでしょうか？

変数の値を交換する手順は、プログラミングの経験者に取っては、「出来て当たり前」なぐらい超簡単なことですが、プログラミング初心者に取っては、意外と難しかったりします。

「まずは変数aの値を変数bに入れて、今度は変数bの値を変数aに入れて…」なんてことを考えていませんか？

これだと、どちらの変数にも同じ値が代入されてしまいます。

２つの変数の値を交換するには、一時的に退避させる変数tmpを用意して、変数a、変数b、変数tmpを三角交換の形で入れ替えします。

交換のイメージ

２つの変数の値を交換する手順を図で表すと以下の図のようなイメージになります。

[変数データの入れ替え]

サンプルコード

２つの変数の値を交換するアルゴリスムを以下のプログラミング言語で紹介します。

• Tcl
• Python

Tcl

[サンプル：swap.tcl]

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" "$@"

# ２つの変数の値を交換して結果を出力する。

set a 10
set b 20

# 変数a,bの値を交換する。

set tmp $a
set   a $b
set   b $tmp

# 変数a, bの値を出力する。

puts "a = $a b = $b"

[実行例]

$ ./swap.tcl
a = 20 b = 10

Python

[サンプル：swap.py]

#!/usr/bin/env python3

# ２つの変数の値を交換して結果を出力する。

a = 10
b = 20

# 変数a,bの値を交換する。

tmp = a
a = b
b = tmp

# 変数a, bの値を出力する。

print(f'a = {a} b = {b}')

[実行例]

$ ./swap.py
a = 20 b = 10