この連載では、新制度の擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、「 マージソート 」というアルゴリズムを取り上げます。

マージソートの基本的な手順

はじめに、マージソートの基本的な手順を説明します。

マージソートのマージ（merge）は、「結合する」という意味です。
マージソートは、2つのソート済みの配列を結合して、ソートされた1つの配列にします。

例として、図1を見てください。

昇順にソートされた配列Aと配列Bがあります。
これらを結合して、昇順にソートされた1つの配列Cにしてみましょう。

配列Aと配列Bは、昇順にソートされているのですから、それぞれの先頭の要素を比較して小さい方を取り出し、それを配列Cに格納することを繰り返せば、昇順にソートされた1つの配列になります。この手順を繰り返すと、配列Aの要素が先に無くなるので、配列Bに残った要素は、そのまま取り出して配列Cに格納します。

図2にマージソートが完了するまでの手順を示します。

図2　マージソートが完了するまでの手順

1つの配列をマージソートする方法

マージソートは、2つのソート済みの配列を結合することでソートしますが、1つの配列をソートすることもできます。そのためには、結合の前に分割の処理を行います。

例として、図3を見てください。

ソート前の配列には要素数が4個ありますが、これを要素数1個の4つの配列になるまで分解すれば、ソート済みの配列が4つになります（要素数が1個の配列は、ソートされているとみなせます）。
ソート済みの4つの配列を2つずつ結合すると、ソートされた2つの配列になります。
さらに、ソート済みの2つの配列を結合すると、ソートされた1つの配列になります。

マージソートのプログラムの例

マージソートのプログラムの例を示しましょう。

リスト1は、旧制度の平成22年度春期試験の問8に示された「マージソート」のプログラムを、現行制度の擬似言語の記述形式にしたものです。

リスト1　マージソートのプログラムの例（出典：H22春問8改）code

    
// 手続Sortの定義（ここから）
〇Sort(整数型の配列：list, 整数型：num)
  整数型の配列：slist1, slist2
  整数型：i, num1, num2
  // 配列listの要素数が1より大きいなら（分割可能なら）処理を行う
  if (num ＞ 1)
    // 配列listを配列slist1と配列slist2に分割する
    num1 ← num ÷ 2
    num2 ← num － num1
    for (iを0から、i ＜ num1である限り、1ずつ増やす)
      slist1[i] ← list[i]
    endfor
    for (iを0から、i ＜ num2である限り、1ずつ増やす)
      slist1[i] ← list[num1 ＋ i]
    endfor
    // 分割した前側の配列list1を手続Sortの再帰呼び出しで分割する
    Sort(slist1, num1)
    // 分割した後側の配列list2を手続Sortの再帰呼び出しで分割する
    Sort(slist2, num2)
    // 手続Mergeでlist1とlist2を結合してlist1に格納する
    Merge(slist1, num1, slist2, num2, list)
  endif
// 手続Sortの定義（ここまで）

// 手続Mergeの定義（ここから）
○Merge(整数型の配列slist1, 整数型：num1,
        整数型の配列slist2, 整数型：num2,
        整数型の配列：list)
  整数型：i, j
  i ← 0
  j ← 0
  // 配列slist1と配列slist2の先頭の要素を比較して小さい方を取り出し、
  // それを配列listに格納することを繰り返す
  while ((i ＜ num1) and (j ＜ num2))
    if (slist1[i] ＜ slist2[j])
      list[i + j] ← slist1[i]
      i ← i ＋ 1
    else
      list[i + j] ← slist2[j]
      j ← ｊ ＋ 1
    endif
  endwhile
  // 配列slist1に要素が残っていたら、要素を取り出して配列listに格納する
  while (i ＜ num1)
    list[i + num2] ← slist1[i]
    i ← i ＋ 1
  endwhile
  // 配列slist2に要素が残っていたら、要素を取り出して配列listに格納する
  while (j ＜ num2)
    list[j + num1] ← slist2[j]
    j ← j ＋ 1
  endwhile
// 手続Mergeの定義（ここまで）
    

手続Sortは、配列をマージソートします。
引数listにソートする配列を指定し、引数numに配列の要素数を指定します。
手続Mergeは、2つの配列を結合します。
引数slist1、num1、slist2、num2に結合する2つの配列とそれぞれの要素数を指定し、引数listに結合した要素を格納する配列を指定します。
ここでは、配列の大きさが省略されていますが、必要な領域が確保されているとします。
配列の要素番号は、0から始まるとします。

手続Sortの処理の中で、手続Mergeを呼び出しています。
手続Sortの処理の中で、手続Sortを呼び出している部分もあります。
これは、再帰呼び出し（関数や手続の処理の中で、同じ関数や手続を呼び出すことで繰り返しを実現する技法）です。
マージソートの分割や結合の繰り返しは、whileやforを使った表現で記述することが困難なのですが、再帰呼び出しで記述すれば容易です。

リスト1は、大雑把に説明すると以下のような手順です。

1. 手続Sortで配列listを配列slist1と配列slist2に分割する
2. 分割した前側の配列list1を手続Sortで分割する（再帰呼び出し）
3. 分割した後側の配列list2を手続Sortで分割する（再帰呼び出し）
4. 手続Mergeでlist1とlist2を結合してlist1に格納する

「こんな手順で上手く行くのだろうか？」と疑問に思うかも知れませんが、上手く行ってしまうのが、再帰呼び出しの便利で面白いところです。

マージソートのプログラムのトレースにチャレンジ

最後に、先ほどリスト1に示したプログラムのトレースにチャレンジしてみましょう（実際の試験問題にも、プログラムのトレースに関する設問がありました）。
トレースすれば、「こんな手順で上手く行くのだろうか？」という疑問が晴れるはずです。

ここでは、引数listに{3, 8, 2, 7, 5, 1}を、引数numに6を指定して、手続Sortを呼び出したとします。
図4にトレースの結果を示しますので、リスト1の内容と照らし合わせてください。
分割は、配列の前側、前側と進んで、前側の分割が終わったら、後側の分割に進みます。
前側と後側の要素が1つになったら結合が行われます。

マージソートのプログラムのトレースの結果

☆　　　☆　　　☆

今回は、「マージソート」というアルゴリズムを取り上げました。

この連載は、今回で最終回です。これまで記事をお読みいただいた読者の皆様に、この場をお借りして厚く御礼申し上げます。

それでは、またどこかでお会いしましょう！

The post マージソート｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

この連載では、新制度の擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。
受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、「 二分木 」というデータ構造と「 深さ優先探索 」「 幅優先探索 」というアルゴリズムを取り上げます。

二分木とは？ 深さ優先探索、幅優先探索とは？

「二分木」は、 1つの要素（データ）が2つの要素につながることを繰り返したデータ構造 です。二分木の形式には、探索を効率的に行える「二分探索木」や、整列を効率的に行える「ヒープ」などがありますが、この記事では、二分木のすべての要素をたどるアルゴリズムをテーマにします。

単純なデータ構造である1次元配列であれば、すべての要素をたどるのは、とても簡単です。1次元配列の先頭から末尾まで、要素番号の順に要素をたどればよいからです。
それに対して、二分木のすべての要素をたどるのは、やや困難です。様々なたどり方が考えられるからです。もしも、たどり方の手順に不備があると、いくつかの要素をたどれない場合もあります。

二分木のすべての要素を確実にたどるアルゴリズムには、
「 深さ優先探索（DFS＝Depth First Search） 」と「 幅優先探索（BFS＝Breadth First Search） 」があります。

深さ優先探索の例を図1に、幅優先探索の例を図2に示します。

1次元配列を図示するときは、要素を四角形で示しますが、二分木を図示するときは、慣例として要素を円で示します。円と円をつなぐ線で、要素のつながりを示します。
ここでは、A～Gが要素です。1～7は、要素をたどる順序です。

二分木の根元にある要素を「根」と呼びます。
深さ優先探索 では、根（A）から始めて、どんどん先の要素に（深い向きに）たどっていきます。左右の2つの要素がある場合は、先に左側をたどり、左側が末端になったら右側をたどります。
図1の場合は、左側にA→B→Dとたどって末端になり、右側のEにたどって末端になり、右側のCから左側のFにたどって末端になり、右側のGにたどります。

幅優先探索 では、根（A）から始めて、直接つながっている要素を左から右の横に（幅の向きに）たどっていきます。
図2の場合は、Aに直接つながっているA→B→Cとたどり、Bに直接つながっているD→Eとたどり、Cに直接つながっているF→Gをたどります。

深さ優先探索のプログラムを見てみよう

2022年12月に公開された科目Bサンプル問題セットの問9に、深さ優先探索を行うプログラムが示されています。
深さ優先探索を行うには、以下の2つの方法があります。
・再帰呼び出し（関数や手続の処理の中で、同じ関数や手続を呼び出して、繰り返しを実現するプログラミング技法）を使う
・スタック（後入れ先出し形式のバッファ）を使う

この問題では、再帰呼び出しを使っています。
深さ優先探索の具体例として、プログラムの内容を見てみましょう。以下に問題を示します。

問９

次の記述中のに入れる正しい答えを，解答群の中から選べ。ここで， 配列の要素番号は 1 から始まる。

手続 order は，図の2分木の，引数で指定した節を根とする部分木をたどりながら，全ての節番号を出力する。大域の配列 tree が図の2分木を表している。
配列 tree の要素は，対応する節の子の節番号を，左の子，右の子の順に格納した配列である。例えば，配列 tree の要素番号1の要素は，節番号1の子の節番号から成る配列であり，左の子の節番号2，右の子の節番号3を配列｛2，3｝として格納する。
手続 order を order(1)として呼び出すと，の順に出力される。

プログラムcode

    
大域: 整数型配列の配列: tree ← {{2, 3}, {4, 5}, {6, 7}, {8, 9},{10, 11}, {12, 13}, {14}, {}, {}, {}, {}, {}, {}, {}} // {}は要素数0の配列	

○order(整数型: n)
    if (tree[n]の要素数 が 2 と等しい) 
        order(tree[n][1]) 
        nを出力
        order(tree[n][2]) 
    elseif (tree[n]の要素数 が 1 と等しい) 
        order(tree[n][1]) 
        nを出力 
    else 
        nを出力 
    endif 
    

解答群
　ア 1，2，3，4，5，6，7，8，9，10，11，12，13，14
　イ 1，2，4，8，9，5，10，11，3，6，12，13，7，14
　ウ 8，4，9，2，10，5，11，1，12，6，13，3，14，7
　エ 8，9，4，10，11，5，2，12，13，6，14，7，3，1

問題に示されたプログラムは、大域の整数型の配列の配列（以下、2次元配列と呼びます）treeと、引数nで指定された要素を基点として深さ優先探索を行う手続orderから構成されています。
手続orderをorder(1)として呼び出すと、どのような順で要素が出力されるかを答えます。
配列の要素番号は1から始まるとしているので、order(1)は、二分木の根からすべての要素をたどります。この問題では、2次元配列の要素を「要素」と呼び、二分木の要素を「節」と呼んでいますが、これ以降の説明では、どちらも「要素」と呼びます。

問題の図に示された二分木と2次元配列treeの要素を見比べて、プログラムで二分木がどのように表現されているのかを理解してください（二分木の表現方法は、いろいろあります。このプログラムの表現方法は、その一例です）。
図の注記1から、2次元配列treeの要素番号が、図の二分木の円の中に示された数字に対応していることがわかります。2次元配列treeの個々の要素の1番目の要素の値（2次元配列は、要素が1次元配列であり、その１次元配列の中に要素の値があります）が、左側につながっている要素の要素番号を示し、2番目の要素が、右側につながっている要素の要素番号を示しています。

たとえば、2次元配列treeの1番目の要素は {2, 3} です。
これは、この要素が①に対応し、①の左側が②であり、①の右側が③であることを示しています。
｛7｝ のように、要素が1つだけの場合は、図の注記2から、左側の要素を示している（左側だけに要素がある）ことがわかります。要素がない { } は、その先につながる要素がないことを示しています。

手続orderは、再帰呼び出しで、深さ優先探索を行っています。
ここでは、すべての要素をたどるだけでなく、要素の値の出力も行っています（画面への出力なら表示されます）。手続orderの処理内容は、if文で3つに分けられています。

「tree[n]の要素が2と等しい」という条件が真なら、要素nの先に2つの要素がつながっています。
この場合には、左側の要素を意味するtree[n][1]を引数に指定して、手続orderを再帰呼び出しします。
これによって、左側にたどることになります。
左側がたどり終わったら、「nを出力」してから、右側の要素を意味するtree[n][2]を引数に指定して手続orderを再帰呼び出しします。これによって、右側にたどることになります。

「tree[n]の要素が1と等しい」という条件が真なら、要素nの先に1つの要素（左側の要素）だけがつながっています。
この場合には、左側の要素を意味するtree[n][1]を引数に指定して、手続orderを再帰呼び出しします。これによって、左側にたどることになります。
左側が終わったら「nを出力」します。右側には要素がないのですから、右側にはたどりません。

上記の2つの条件が真でないなら、要素nの先に要素がない、つまり、要素nが末端ということです。この場合には、「nを出力」するだけです。

手続orderの処理内容がわかったら、図に示された二分木の要素が、どういう順番で出力されるかがわかるでしょう。
問題の解答群を見ると、最初から3番目までに出力される要素がわかれば、答えを選べます。
まず、根の要素①から左側にたどって、末端の要素⑧が出力されます。
次に、⑧の上にある④が出力されてから、④の右側にたどって、
末端の⑨が出力されます。

ここまでの出力は、⑧、④、⑨であり、選択肢ウが正解です。

正解：ウ

VBScriptでプログラムを実行してみよう

擬似言語で示されたプログラムを見ただけでは、再帰呼び出しで深さ優先探索を実現するイメージがつかめない、という人もいらっしゃると思いますので、先ほどの問題に示されたプログラムと同様の機能のプログラムを、VBScript（Visual Basic Scripting Edition）で作成して実行してみましょう。
VBScriptは、Windowsパソコンであれば、何もツールをインストールせずに、すぐに実行できるプログラミング言語です。

リスト1に示したプログラムを、dfs.vbsというファイル名で任意のディレクトリに保存してください。ここでは、C:\testというディレクトリに保存しています。
Windowsのコマンドプロンプトを起動して、カレントディレクトリをC:\testに移動したら、「cscript dfs.vbs」と入力して「Enter」キーを押せば、プログラムを実行できます。
プログラムの実行結果の例を図3に示します。先ほどの問題の解答群の選択肢ウと同じ出力が得られました。

リスト1のポイントとなる部分（問題に示された擬似言語のプログラムと表現が大きく異なる部分）を説明しましょう。
VBScriptでは、Array関数の引数に要素をカンマで区切って指定して、配列を作成します。
ここでは、2次元配列なので、Array関数の引数でArray関数を使って、配列の配列を作成しています。引数がないArray関数は、要素がない配列を作成します。VBScriptでは、長い命令を途中で改行するときに、行の末尾にアンダースコア（ _ ）を置きます。

問題のプログラムでは、要素番号が1から始まりますが、VBScriptでは要素番号が0から始まるので、手続orderの中でidx = n – 1という処理を行い、変数idxにVBScript用の要素番号を得ています。UBound関数は、引数に指定された配列の末尾の要素の要素番号を返します。これに1を足すことで、要素数が得られます（VBScriptでは要素番号が0から始まるからです）。
擬似言語では、配列の要素番号を [ ] で囲みますが、VBScriptでは ( ) で囲みます。WScript.StdOut.Write(n & “, “)は、nの値とカンマを表示します（表示の末尾で改行しません）。WScript.StdOut.WriteLine()は、改行だけを行います。
その他の部分は、問題に示された擬似言語のプログラムと同様です。

☆　　　☆　　　☆

今回は、「二分木」というデータ構造と「深さ優先探索」「幅優先探索」というアルゴリズムを取り上げました。

次回も、シラバスに示されたアルゴリズムとデータ構造を解説します。
それでは、またお会いしましょう！

The post 二分木の深さ優先探索と幅優先探索｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

この連載では、新制度の擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、「 キュー 」と「 スタック 」のデータ構造を取り上げます。

キューとスタックの特徴

プログラムでは、すぐに処理しないデータを一時的に格納しておく配列が必要になる場合があります。このような配列をバッファ（buffer＝緩衝器）と呼びます。
今回のテーマであるキューとスタックは、どちらもバッファですが、配列へのデータの格納と取り出しの順序に違いがあります。キューとスタックを比べてみましょう。

キュー は、ごく普通のバッファであり、最初に格納したデータを最初に取り出します。これをFIFO（First In First Out＝先入れ先出し）形式と呼びます。

たとえば、”A”、”B”（ここでは、文字列データを格納するとします）の順にキューに格納したら、”A”、”B”の順に取り出します。
キュー（queue）は、「待ち行列」という意味です。日常生活において、何かの切符を買う窓口では、最初に列に並んだ人（First In）が、最初に列から出て（First Out）切符を買います。プログラムのキューも、これと同様です。
キューにデータを格納することをエンキュー（enqueue）、キューからデータを取り出すことをデキュー（dequeue）と呼びます（図1）。

スタック は、ちょっと変わったバッファであり、最後に格納したデータを最初に取り出します。これをLIFO（Last In First Out＝後入れ先出し）形式と呼びます。

たとえば、”A”、”B”の順にスタックに格納したら、”B”、”A”の順に取り出します。
スタック（stack）は、「干し草を積んだ山」という意味です。日常生活において、牧場で家畜に食べさせる草を積んだ山では、最後に積んだ草（Last In）を、最初に取り出します（First Out）。プログラムのスタックも、これと同様です。
スタックにデータを格納することをプッシュ（push）、スタックからデータを取り出すことをポップ（pop）と呼びます（図2）。

キューとスタックの大きな違いは、順序が入れ替わるかどうかです。
キュー では、”A”、”B”の順に格納すれば、”A”、”B”の順に取り出されるので、順序が入れ替わりません。
スタック では、”A”、”B”の順に格納すれば、”B”、”A”の順に取り出されるので、順序が入れ替わります。

キューとスタックをオブジェクトで実現する

プログラムでキューとスタックを実現するには、データを格納する配列と、その配列にデータの格納および取り出しを行う処理を用意することになります。

現時点で公開されている基本情報技術者試験の問題を見ると、これらの仕組みをオブジェクトとして実現しています。オブジェクトとは、内部にいくつかのデータと処理を持つモジュール（プログラムの構成要素）です。

基本情報技術者試験の擬似言語では、オブジェクトが持つデータをメンバ変数と呼び、オブジェクトが持つ処理をメソッドと呼びます。
キューやスタックを実現するオブジェクトは、メンバ変数として配列を持ち、その配列にデータを格納するメソッド、およびデータを読み出すメソッドを持つことになります。他にも、必要なメソッドがあれば用意します。

プログラムでは、オブジェクトをクラスとして定義します。
プログラムの実行時に、クラス一式（データと処理の一式）をメモリにロードしたものが、オブジェクト（クラスのインスタンスとも呼びます）です。
オブジェクトが持つメンバ変数やメソッドは、「オブジェクト名.メンバ変数名」や「オブジェクト名.メソッド名」という構文で使います。多くの場合に、オブジェクトを使う側は、オブジェクトが持つデータを直接操作せずに、オブジェクトが持つメソッドを使って間接的に操作します。

キューを実現するQueueクラスを作成したとしましょう。
このQueueクラスには、キューの実体となる配列、コンストラクタQueue、キューにデータを格納するenqueueメソッド、キューから取り出したデータを返すdequeueメソッド、およびキューに格納されているデータ数を返すsizeメソッドがあるとします。
これらは、後で示す試験問題のプログラムに似せたものです。
コンストラクタとは、クラス一式をメモリにロードする（オブジェクトを生成する）機能を持った特殊なメソッドです。多くのプログラミング言語で、コンストラクタの名前はクラスと同じにします。Queueクラスのコンストラクタの名前は、Queueです。

リスト1は、Queueクラスを使ったプログラムの例です。

ここでは、queueという名前のキューを生成し、キューに”A”と”B”というデータを格納して、キューからすべてのデータを取り出して表示しています。

キューは、FIFO形式なので、”A”、”B”の順に表示されます。
ここでは、「クラス名：オブジェクト名 ← コンストラクタ()」という構文で、オブジェクトを生成しています。これは、後で示す試験問題のプログラムに合わせたものです。
多くのプログラミング言語では、オブジェクトの生成にnewという命令を使いますが、擬似言語では使いません。

リスト1　Queueクラスを使ったプログラムの例code

    
// キューを生成する
Queue:queue ← Queue()

// キューにデータを格納する
queue.enqueue("A")
queue.enqueue("B")

// キューからすべてのデータを取り出す
while (queue.size() ＞ 0)
  queue.dequeue()の戻り値を表示する
endwhile
    

スタックを実現するStackクラスを作成したとしましょう。
このStackクラスには、スタックの実体となる配列、コンストラクタStack、スタックにデータを格納するpushメソッド、スタックから取り出したデータを返すpopメソッド、およびスタックに格納されているデータ数を返すsizeメソッドがあるとします。

リスト2は、Stackクラスを使ったプログラムの例です。

ここでは、stackという名前のスタックを生成し、スタックに”A”と”B”というデータを格納して、スタックからすべてのデータを取り出して表示しています。スタックは、LIFO形式なので、”B”、”A”の順に表示されます。

リスト2　Stackクラスを使ったプログラムの例code

    
// スタックを生成する
Stack:stack ← Stack()

// スタックにデータを格納する
stack.push("A")
stack.push("B")

// スタックからすべてのデータを取り出す
while (stack.size() ＞ 0)
  stack.pop()の戻り値を表示する
endwhile
    

基本情報技術者試験の問題にチャレンジ

試験対策として、2022年12月に公開された科目Bサンプル問題セットの問8にチャレンジしてみましょう。

これは、オブジェクトで実現したキューをテーマにした問題です。
このキューは、FIFO形式ですが、優先度付きであることに注意してください。
以下に問題を示します。

次の記述中のに入れる正しい答えを、解答群の中から選べ。

優先度付きキューを操作するプログラムである。優先度付きキューとは扱う要素に優先度を付けたキューであり，要素を取り出す際には優先度の高いものから順番に取り出される。クラス PrioQueue は優先度付きキューを表すクラスである。クラス PrioQueue の説明を図に示す。ここで，優先度は整数型の値1，2，3のいずれかであり，小さい値ほど優先度が高いものとする。

手続 prioSched を呼び出したとき，出力はの順となる。

プログラムcode

    
○prioSched()   
    PrioQueue: prioQueue ← PrioQueue()
    prioQueue.enqueue("A", 1)
    prioQueue.enqueue("B", 2)
    prioQueue.enqueue("C", 2)
    prioQueue.enqueue("D", 3)
    prioQueue.dequeue()  /* 戻り値は使用しない */
    prioQueue.dequeue()  /* 戻り値は使用しない */
    prioQueue.enqueue("D", 3)
    prioQueue.enqueue("B", 2)
    prioQueue.dequeue()  /* 戻り値は使用しない */
    prioQueue.dequeue()  /* 戻り値は使用しない */
    prioQueue.enqueue("C", 2)
    prioQueue.enqueue("A", 1)
    while (prioQueue.size() が 0 と等しくない)
        prioQueue.dequeue() の戻り値を出力
    endwhile
    

解答群

ア “A”，“B”，“C”，“D”
イ “A”，“B”，“D”，“D”
ウ “A”，“C”，“C”，“D”
エ “A”，“C”，“D”，“D”

dequeueメソッドで、キューから要素を取り出すときは、キュー内で最も優先度の高い要素が取り出されます。最も優先度の高い要素が複数ある場合は、それらのうち最初に格納された要素が取り出されます。

手続prioSchedで行われているキューへの格納と取り出しによって、キューの内容は以下のように変化します。ここでは、キューの1つの要素を[文字列データ, 優先度]で示しています。優先度は、値が小さいほど高いとされます。

    
prioQueue.enqueue("A", 1)	[A, 1]
prioQueue.enqueue("B", 2)	[A, 1][B, 2]
prioQueue.enqueue("C", 2)	[A, 1][B, 2][C, 2]
prioQueue.enqueue("D", 3)	[A, 1][B, 2][C, 2][D, 3]
prioQueue.dequeue() 		[B, 2][C, 2][D, 3]
prioQueue.dequeue()		[C, 2][D, 3]
prioQueue.enqueue("D", 3)	[C, 2][D, 3][D, 3]
prioQueue.enqueue("B", 2)	[C, 2][D, 3][D, 3][B, 2]
prioQueue.dequeue()		[D, 3][D, 3][B, 2]
prioQueue.dequeue()		[D, 3][D, 3]
prioQueue.enqueue("C", 2)	[D, 3][D, 3][C, 2]
prioQueue.enqueue("A", 1)	[D, 3][D, 3][C, 2][A, 1]
    

キューの内容が[D, 3][D, 3][C, 2][A, 1]となった後で、while文を使ってキューの要素数が0になるまで、キューからデータの取り出しと出力（何に出力するかは示されていませんが、画面に出力すれば表示されます）を繰り返しています。
[D, 3][D, 3][C, 2][A, 1]からは、[A, 1]、[C, 2]、前側の[D, 3]、後側の[D, 3]の順に取り出されるので、出力はA、C、D、Dの順になります。

したがって、選択肢エが正解です。

今回は、キューとスタックを取り上げました。
次回も、シラバスに示されたアルゴリズムとデータ構造を解説します。

それでは、またお会いしましょう！

The post 比べてわかるキューとスタックの仕組み｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

この連載では、新制度の擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、「リスト」というデータ構造を取り上げます。

リストとは？

試験のシラバスには、代表的なデータ構造として、配列、リスト、キュー、スタック、二分探索木、ヒープなどが示されていますが、どのデータ構造も、その実体は配列です。他のデータ構造は、配列の使い方にプログラムで様々な工夫を加えることで実現されています。
今回のテーマであるリスト（連結リストとも呼びます）は、配列の個々の要素が次の要素へのつながり情報を持ったものです。このつながり情報のことをポインタとも呼びます。次の要素を指し示す（ポイントする）ものだからです。

配列（リストではない通常の配列）とリストの違いを説明しましょう。

例として、東海道新幹線の東京から新大阪まで、のぞみ号が停車する駅名を、配列とリストで表してみます。
配列の場合は、要素番号（先頭の要素番号を1とします）の順に要素をたどるので、東京から新大阪までの駅名を要素番号の順に格納します（図1）。

「品川がない」と気づかれたと思いますが、後の説明の都合で入れていません。
リストの場合は、個々の要素が持つつながり情報（次の要素の要素番号やアドレス）で要素をたどるので、要素の格納順は任意で構いません（図2）。

配列と比べて、リストには、要素の挿入が効率的にできるという長所があります。

先ほど図1と図2に示した例に、品川を挿入してみましょう。

配列の場合は以下の手順です（図3）

1. 新横浜以降の要素を1つずつ後ろにずらす
2. a[2] の位置に品川を挿入

※要素をずらす処理に時間がかかります。

リストの場合は以下の手順です（図4）

1. 配列の末尾のa[6]に品川を追加
2. 東京の「次は4」を「次は6」に更新
3. 品川に「次は4」を設定

これだけで、東京と新横浜の間に品川を挿入できます。要素をずらす処理が不要なので時間がかかりません。
リストでは、要素の削除も、つながり情報の更新だけで済むので、配列より効率的です。

リストをプログラムで実現する方法

リストをプログラムで実現するには、データの値とつながり情報を要素とした配列を定義します。基本情報技術者試験のサンプル問題や公開問題では、これをクラスとして実現しています。クラスは、オブジェクトの定義であり、複数のデータと複数の処理をまとめたモジュール（プログラムの部品）です。

ここでは、駅のリストの要素を表すStationクラスを定義することにします。
擬似言語では、クラスが持つデータをメンバ変数と呼び、クラスが持つ処理をメソッドと呼びます。
Stationクラスには、駅名を示すメンバ変数name、次の要素のアドレスを格納するメンバ変数next、および新たな要素を作成するコンストラクタStationがあるとします。コンストラクタは、特殊なメソッドであり、クラス名と同名のメソッドにします。これまでの例では、要素番号をつながり情報としていましたが、ここでは、メモリ上に要素を新たに作成していくので、要素のメモリアドレスをつながり情報とします。

まず、品川なしで、東京→新横浜→名古屋→京都→新大阪というリストを作成しましょう。

以下にプログラムを示します。

プログラムcode

    
Station：listHead		// リストの先頭の要素のアドレスを格納する変数
Station：cur			// 現在の処理対象の要素のアドレス格納する変数
Station：temp			// 一時的にアドレスを格納する変数（後で使います）

cur ← Station("東京")		// 東京の要素を作成し処理対象とする
listHead ← cur			// 先頭の要素を東京とする

cur.next ← Station("新横浜")	// 新横浜の要素を作成し東京の次とする
cur ← cur.next			// 新横浜を処理対象とする

cur.next ← Station("名古屋")	// 名古屋の要素を作成し新横浜の次とする
cur ← cur.next			// 名古屋を処理対象とする

cur.next ← Station("京都")	// 京都の要素を作成し名古屋の次とする
cur ← cur.next			// 京都を処理対象とする

cur.next ← Station("新大阪")	// 新大阪の要素を作成し京都の次とする
cur ← cur.next			// 新大阪を処理対象とする
cur.next ← 未定義の値		// 新大阪の次を無し（未定義の値）とする
    

要素のアドレスを格納する変数のデータ型は、Stationクラスにします。
変数listHeadには、リストの先頭の要素のアドレスを格納します。
変数cur（current＝「現在の」という意味です）には、現在の処理対象となっている要素のアドレスを格納します。
個々の要素が持つメンバ変数は「要素名.メンバ変数名」という構文で指定します。
cur.nextは、次の要素のアドレス（つながり情報）を示します。
cur ← cur.nextは、現在の次の要素を、新たな処理対象にします

次に、東京と新横浜の間に品川を挿入してみましょう。

lishHeadから、つながり情報で要素をたどり、駅名が東京なら、その要素と次の要素の間に品川を挿入します。
コメントを参考にしながら、以下のプログラム（先ほどのプログラムの続きだとします）を読み取ってください。

プログラムcode

    
cur ← listHead			// リストの先頭の要素を処理対象とする

while (cur.next ≠ 未定義の値)	// 末尾の要素まで繰り返す
    if (cur.name ＝ "東京")	// 現在の要素が東京なら品川を挿入する
        temp ← cur.next	// 東京の次のアドレスをtempに逃がしておく
        cur.next ← Station("品川")  // 品川の要素を作成し東京の次とする
        cur ← cur.next		// 品川を処理対象とする
        cur.next ← temp	// 逃がしておいたアドレスを品川の次に設定する
        繰り返し処理を抜ける	// 繰り返しを抜ける
    endif
   cur ← cur.next		// 次の要素を処理対象とする
endwhile
    

ここでは、繰り返し処理を抜ける処理を「繰り返し処理を抜ける」という日本語の文章で示しています。サンプル問題や公開問題でも、同様の表現が使われているからです。

基本情報技術者試験の公開問題にチャレンジ

最後に、試験対策として、2022年4月に公開（8月に一部改訂）された科目Bサンプル問題の問3にチャレンジしてみましょう。

これは、リストへの要素の追加をテーマにした問題です。
リストに要素を追加する手続appendの処理内容を読み取ってください。問題文の中にある「インスタンスの参照」とは、要素のアドレスという意味です。

問３　次のプログラムの中の［　a　］と［　b　］に入れる正しい答えの組み合わせを、解答群の中から選べ。

手続 append は，引数で与えられた文字を単方向リストに追加する手続である。単方向リストの各要素は，クラス ListElement を用いて表現する。クラス ListElement の説明を図に示す。ListElement 型の変数はクラス ListElement のインスタンスの参照を格納するものとする。大域変数 listHead は，単方向リストの先頭の要素の参照を格納する。リストが空のときは，listHead は未定義である。

大域変数（プログラムのどこからでも利用できる変数）listHeadには、初期値として、未定義の値が格納されています。これは、リストが空の状態であるということです。

手続appendは、引数qValの値を持つ要素をリストに追加します。
appendの最初の処理として、引数qValを格納した要素を新たに作成し、そのアドレスを変数currに格納しています。
次に、もしもlistHeadの値が空欄aなら、大域変数listHeadに変数currを代入しています。これは、新たに作成した要素をリストの先頭にする処理なので、最初の要素を挿入する場合です。listHeadの値が未定義の値なら、最初の要素だと判断できるので、空欄aは、未定義の値です。これで、正解を解答群の選択肢ア、イ、ウに絞り込めました。

空欄bがあるelseブロックは、最初の要素でない場合の処理なので、リストの末尾の要素の次に、新たに作成した要素を追加します。
そのために、変数prev（previous＝「前の」という意味です）に大域変数listHeadの値を格納し、「prev.nextが未定義でない」という条件のwhileブロックで繰り返し処理を行います。この処理では、変数prevにprev.nextを格納して、リストをたどっています。これが「prev.nextが未定義でない」という条件が真である限り繰り返されるので、繰り返しを抜けたときには、変数prevに既存のリストの末尾の要素のアドレスが得られます。
その要素の次を意味するメンバ変数prev.nextに、新たに作成した要素のアドレスを格納すれば、リストに要素を追加できるので、空欄bはcurrです。
以上のことから、選択肢アが正解です。

解答：ア

☆　　　☆　　　☆

今回は、リストを取り上げました。
次回以降も、シラバスに示されたアルゴリズムとデータ構造を学んでいきます。

それでは、またお会いしましょう！

The post 「リスト」というデータ構造｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

この連載では、新制度で採用された新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。 受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、サーチのアルゴリズムの 3 つめとして「ハッシュ表探索法」を取り上げます。

info_outline他のサーチアルゴリズムの記事

サーチのアルゴリズム (1) 線形探索法
サーチのアルゴリズム (2) 二分探索法

計算量が O(1) になる理由

計算量を表すオーダー表記

アルゴリズムの良し悪しを示す尺度として「計算量」というものがあります。

計算量には、いくつかの表記方法がありますが、よく使われるのは「オーダー表記」と呼ばれるものです。 これは、データ数の増加に対して処理回数がどのように増えるかを「 O( n の式) 」
という表記で示したものです。この O は、 order （次数、規模）の頭文字です。

たとえば、単純なループ（一重のループ）を使う線形探索法の計算量は、

O(n)

です。 n の 1 次式なので、線形探索法の処理回数は、データが 10 倍になれば 10 倍になり、 100 倍になれば 100 倍になります。

多重ループ（二重のループ）を使うバブルソートの計算量は、

O(n2)

です。 n の 2 次式なので、バブルソートの処理回数は、データが 10 倍になれば 100 倍になり、 100 倍になれば 10000 倍になります。

ハッシュ表探索法の計算量

それでは、今回のテーマであるハッシュ表探索法の計算量はいくつなのかというと、理想的には

O(1)

です。

この 1 は、ハッシュ表探索法の処理回数は、データ数に関わらず 1 回であることを意味しています。 「理想的には」と但し書きを入れているのは、 1 回より多くなる場合もあり得るからです。それに関しては、後で説明します。

ハッシュ表探索法では、データの値からデータの格納場所を決める「ハッシュ関数」を用意しておきます。

たとえば、要素数 10 個の配列 a[1] ～ a[10] （後でチャレンジする公開問題に合わせて、配列の要素番号は 1 から始まるとします）に、正の整数データを格納するなら、

データの値 mod 10 + 1

というハッシュ関数を用意し、このハッシュ関数で得られた値（「ハッシュ値」と呼びます）をデータの格納場所にします。 データの値 mod 10 + 1 で得られる値は 1 ～ 10 になるので、格納場所は配列 a[1] ～ a[10] の範囲に収まります。

たとえば、 45 というデータは、

45 mod 10 + 1 = 6

なので a[6] に格納します。

78 というデータは、

78 mod 10 + 1 = 9

なので a[9] に格納します。

このようにしてデータを格納した表を「ハッシュ表」と呼び、ハッシュ表を使った探索を「ハッシュ表探索法」と呼ぶのです。 ハッシュ（ hash ）は、「切り刻む」や「ごった混ぜにする」という意味です。

このハッシュ表から、たとえば 45 というデータを探索するには、

45 mod 10 + 1 = 6

なので a[6] をチェックします。 a[6] には 45 が格納されているので 1 回の処理で見つかります。

同様に、 78 というデータを探索するには、

78 mod 10 + 1 = 9

なので a[9] をチェックして 1 回の処理で見つかります。 これが、ハッシュ表探索法で計算量が

O(1)

になる理由です。

なお、データが格納されていない要素には、それがわかるように、通常のデータではないことを意味する値を入れておきます。 ここでは、データが正の整数なので、 0 や -1 などを入れておけばよいでしょう（図 1 ）。

シノニムに対処する方法

ハッシュ表探索法の計算量は、理想的に O(1) です。 ここで、理想的というのは、ハッシュ表に格納するデータ群の中に、同じハッシュ値になるデータ（これを「シノニム（ synonym = 同義語、類義語）」と呼びます）がない場合です。

もしも、シノニムがあると、それに対処するための処理が必要になり、 1 回ではデータが見つかりません。

たとえば、先ほど図 1 の 3 に示したハッシュ表に、 95 を格納するとしましょう。 95 のハッシュ値は、

95 mod 10 + 1 = 6

であり、すでに a[6] に格納されている 45 と同じになります。 95 はシノニムであり、ハッシュ値の a[6] に格納できません。

シノニムに対処する方法は、いくつか考えられますが、単純な方法は、ハッシュ値で得た格納場所より先（末尾を超えた場合は先頭に戻る）で最初に空いている場所に格納する方法です。

ここでは、 a[6] より先で最初に空いている（ -1 が格納されている）のが a[7] なので、そこに 95 を格納します。 この場合には、 95 は 1 回では見つかりません（図 2 ）。

基本情報技術者試験の公開問題にチャレンジ

最後に、試験対策として「令和 5 年度 基本情報技術者試験 科目 B 公開問題」の問 4 にチャレンジしてみましょう。

ハッシュ表探索をテーマにした問題であり、シノニムの対処もあります。

大域: 整数型の配列: hashArray

○論理型: add(整数型: value)
 整数型: i ← calcHash1(value)
 if (hashArray[i] = -1)
 hashArray[i] ← value
 return true
 else
 i ← calcHash2(value)
 if (hashArray[i] = -1)
 hashArray[i] ← value
 return true
 endif
 endif
 return false

○整数型: calcHash1(整数型: value)
 return (value mod hashArrayの要素数) + 1

○整数型: calcHash2(整数型: value)
 return ((value + 3) mod hashArrayの要素数) + 1

○test()
 hashArray ← {5 個の -1}
 add(3)
 add(18)
 add(11)

プログラムの内容を説明しましょう。

ここでは、要素数 5 個の整数型の配列 hashArray がハッシュ表であり、そこに正の整数 value を格納します。

• hashArray のすべての要素には、初期値として、データが格納されていないことを意味する -1 が格納されています
• 関数 test では、引数 value の値を 3 、 18 、 11 として、ハッシュ表にデータを格納する関数 add を 3 回呼び出しています
• ハッシュ関数は、 2 つ用意されています
  • 関数 calcHash1 は value mod 5 + 1 という計算でハッシュ値を得ます
  • 関数 calcHash2 は (value + 3) mod 5 + 1 という計算でハッシュ値を得ます
• 関数 add は、関数 calcHash1 で得た場所が空いているなら、そこに value を格納して true を返し、空いていないなら、関数 calcHash2 で得た場所が空いているなら、そこに value を格納して true を返し、そこも空いていないなら、 false を返します。
  関数 add の戻り値は、データを格納できたら true であり、格納できなかったら false です

擬似言語の表記で示すと、初期状態のハッシュ表の内容は

{-1, -1, -1, -1, -1}

です。

最初の 3 は、関数 calcHash1 で得た

3 mod 5 + 1 = 4

の場所が空いてるので、そこに格納され、ハッシュ表の内容は

{-1, -1, -1, 3, -1}

になります。

次の 18 は、関数 calcHash1 で得た 18 mod 5 + 1 = 4 の場所が空いていないので、そこには格納せず、関数 calcHash2 で得た

(18 + 3) mod 5 + 1 = 2

の場所が空いてるので、そこに格納され、ハッシュ表の内容は

{-1, 18, -1, 3, -1}

になります。

最後の 11 は、関数 calcHash1 で得た 11 mod 5 + 1 = 2 の場所が空いていないので、そこには格納せず、関数 calcHash2 で得た

(11 + 3) mod 5 + 1 = 5

の場所が空いてるので、そこに格納され、ハッシュ表の内容は

{-1, 18, -1, 3, 11}

になります。

以上のことから、選択肢エが正解です。

今回は、ハッシュ表探索法を取り上げました。

次回以降も、シラバスに示されたアルゴリズムとデータ構造を学んでいきます。

それでは、またお会いしましょう！

The post サーチのアルゴリズム (3) ハッシュ表探索法のアルゴリズム｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

この連載では、新制度で採用された新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。 受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

前回は 再帰呼び出し を取り上げました。 今回は、再帰呼び出しを使った クイックソート を取り上げます。

クイックソートのアルゴリズム

クイックソートは、配列をソートするアルゴリズムの一種です。 クイックソートのアルゴリズムは以下です。

グループ分けすることでソートの対象となる配列の要素数が徐々に少なくなることと、プログラムで繰り返しを実現するときに再帰呼び出し（関数や手続の処理の中で、同じ関数や手続を呼び出すことで、繰り返しを実現するプログラミング技法）を使うことが、クイックソートの特徴です。

図 1 は、要素数 7 個の配列（要素番号は 1 から始まるとします）を昇順にクイックソートする手順の例を示したものです。

ここでは、ソート対象となる配列の真ん中の要素を基準値としています。

真ん中の要素の要素番号は、

(左端の要素の要素番号 + 右端の要素の要素番号) ÷ 2

という計算で求められます。 要素番号は、整数型のデータなので、除算結果の小数点以下はカットされます。

初期状態（図 1 の【手順 1 】）では、ソート対象となる配列が a[1] ～ a[7] なので、

(1 + 7) ÷ 2 = 4

となり、 a[4] に格納されている 4 が基準値です。

配列の先頭から基準値より大きい値を探索し、配列の末尾から基準値より小さい値を探索して、大きい値と小さい値を交換することを繰り返すと、基準値との大小関係で配列のグループ分けができます。

同じ手順を、グループ分けしたそれぞれのグループで繰り返します。 グループの要素数が 1 個になったら繰り返しを終了します。 すべてのグループの繰り返しが終了したら、配列全体のソートが完了します。

クイックソートのプログラム

リスト 1 は、クイックソートのプログラムの例です。

これは、 2023 年 7 月 6 日に情報処理推進機構から公開された「令和 5 年度 基本情報技術者試験 科目 B 公開問題」の問 3 に示されたプログラムに、若干のアレンジを加えたものです。

手続 sort は、配列を昇順にクイックソートします。
引数 a は、ソート対象の配列です。
引数 first は、ソート対象の先頭の要素番号です。
引数 last は、ソート対象の末尾の要素番号です。
配列の要素番号は、 1 から始まるとします。

swipeプログラムは横スクロールできます

○sort(整数型の配列: a, 整数型: first, 整数型: last)
  整数型 pivot, i, j, temp

  /* 配列の真ん中の要素を基準値とし
     基準値の要素番号を pivot に設定する */
  pivot ← a[(first + last) ÷ 2]

  /* 配列の先頭の要素番号を i に設定する */
  i ← first

  /* 配列の末尾の要素番号を j に設定する */
  j ← last

  /* 無限ループで繰り返す */
  while (true)
    /* 配列の先頭から pivot 以上の要素を探索し、見つかった位置を i に得る */
    while (a[i] < pivot)
      i ← i + 1
    endwhile

    /* 配列の末尾から pivot 以下の要素を探索し、見つかった位置を j に得る */
    while (pivot < a[j])
      j ← j - 1
    endwhile

    /* 探索の範囲を超えているなら */
    if (i ≧ j)
      /* グループ分けが完了しているので無限ループを抜ける
         breakは、繰り返しを抜けるメールだとする */
      break
    endif

    /* 基準値の前側にある基準値以上の a[i] と
       基準値の後側にある基準値以下の a[j] を交換する*/
    temp ← a[i]
    a[i] ← a[j]
    a[j] ← temp
  endwhile

  /* グループ分けした前側の要素数が 2 個以上なら */
  if (first < i - 1)
    /* 再帰呼び出しで、前側で同じ処理を繰り返す */
    sort(a, first, i - 1)
  endif

  /* グループ分けした後側の要素数が 2 個以上なら */
  if (j + 1 < last)
    /* 再帰呼び出しで、後側で同じ処理を繰り返す */
    sort(a, j + 1, last)
  endif

プログラムに多くのコメントを入れてあります。 コメントを参考にして、プログラムの処理内容を読み取ってください。

注目してほしいのは、再帰呼び出しで繰り返しを行っている部分です。 手続 sort は、

「基準値を決め、ソート対象の配列を基準値との大小関係でグループ分けする」

という処理を行います。

この処理を、グループ分けされた前側と後側で繰り返すので、 sort( ソート対象の配列 ) の処理の中で、 sort( 前側のグループ ) と sort( 後側のグループ ) を呼び出すのです。 この部分が、再帰呼び出しです。

グループの要素数が 1 個になるまで（ 2 個以上である限り）、この再帰呼び出しを繰り返します。

基本情報技術者試験の公開問題にチャレンジ

最後に、試験対策として「令和 5 年度 基本情報技術者試験 科目 B 公開問題」の問 3 にチャレンジしてみましょう。

基本情報技術者試験の科目 B 試験では、 100 分で 20 問を解きます。 1 問当たりの解答時間の目安は、

100 分 ÷ 20 問 = 5 分

です。

この問題の中には「クイックソート」という言葉はありませんが、クイックソートのプログラムを学んだ経験があれば「あっ！ これはクイックソートだ」とすぐにわかり、 5 分程度ですんなり問題を解けるでしょう。 逆に、クイックソートのプログラムを学習した経験がないと、相当な時間がかかるか、まったくお手上げでしょう。

この問題から、試験対策として、シラバスに示されたアルゴリズムとデータ構造をきちんと学ぶことの重要性を感じてください。 「きちんと学ぶ」とは、単にアルゴリズムを理解するだけでなく、実際のプログラムでどのような処理になるのかを経験することです。

　次の記述中のに入れる正しい答えを，解答群の中から選べ。 ここで，配列の要素番号は 1 から始まる。

　次の手続 sort は，大域の整数型の配列 data の，引数 first で与えられた要素番号から引数 last で与えられた要素番号までの要素を昇順に整列する。ここで， first
< last とする。 手続 sort を sort(1, 5) として呼び出すと， /*** α ***/ の行を最初に実行したときの出力は “” となる。

プログラムcode

大域: 整数型の配列: data ← {2, 1, 3, 5, 4}

○sort(整数型: first, 整数型: last)
 整数型: pivot, i, j
 pivot ← data[(first + last) ÷ 2 の商]
 i ← first
 j ← last

 while (true)
  while (data[i] < pivot)
    i ← i + 1
  endwhile
  while (pivot < data[j])
    j ← j - 1
  endwhile
  if (i ≧ j)
    繰返し処理を終了する
  endif
  data[i] と data[j] の値を入れ替える
  i ← i + 1
  j ← j - 1
 endwhile
 data の全要素の値を要素番号の順に空白区切りで出力する /*** α ***/
 if (first < i - 1)
   sort(first, i - 1)
 endif
 if (j + 1 < last)
   sort(j + 1, last)
 endif

解答群
ア　1 2 3 4 5
イ　1 2 3 5 4
ウ　2 1 3 4 5
エ　2 1 3 5 4

先ほどリスト 1 に示したプログラムでは、ソート対象の配列を手続 sort の引数で指定していましたが、公開問題のプログラムでは、大域の配列（プログラムのどこからでも使える配列）としています。 これは、プログラムの内容をシンプルにするためでしょう。

このプログラムの処理内容は、リスト 1 に示したプログラムと同様です。 ここでは、

data ← {2, 1, 3, 5, 4}

という配列を最初にグループ分けした後で、 data の全要素の値を要素番号の順に空白区切りで出力した結果を、解答群の中から選びます。

最初のグループ分けでは、

{2, 1, 3, 5, 4}

の 3 を基準値として、配列全体をグループ分けします。

{2, 1, 3, 5, 4}

は、 3 の前に 3 より小さい値があり、 3 の後に 3 より大きい値があるので、要素の値の交換は行われず、このままでグループ分けが完了しています。

したがって、

2 1 3 5 4

と表示されます。 選択肢エが正解です。

今回は、クイックソート取り上げました。

次回以降も、シラバスに示されたアルゴリズムとデータ構造を学んでいきます。

それでは、またお会いしましょう！

info_outline関連記事

新制度・基本情報技術者試験の過去問（公開問題）からわかる難易度と対策

The post クイックソートのアルゴリズム｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/similar_programming/recursive/ Mon, 05 Jun 2023 23:30:17 +0000 https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/?post_type=similar_programming&p=7830 基本情報技術者試験は、 2023 年 4 月から新制度で実施されています。 この連載では、新制度で採用された新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験にお […]

The post 再帰呼び出しのアルゴリズム｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> 基本情報技術者試験は、 2023 年 4 月から新制度で実施されています。

この連載では、新制度で採用された新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。 受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は 再帰呼び出し を取り上げます。

再帰呼び出しとは？

再帰呼び出し（ recursive call ）とは、「関数の処理の中で同じ関数を呼び出すことで繰り返しを実現する」というプログラミング・テクニックです。

プログラムで繰り返しを実現するには、 while 文や for 文を使う方法がありますが、それらとは別に再帰呼び出しという方法もあるのです。

 

再帰呼び出しの仕組みを説明するための代表的な例として、「引数で指定した数の階乗を返す関数」があります。 階乗とは、その数から 1 までのすべての数を掛けた値です。

たとえば、 5 の階乗は、
5 × 4 × 3 × 2 × 1 = 120
です。 数学の約束で、 0 の階乗は 1 と決められています。

リスト 1 は、引数 n （ 0 以上だとします）の階乗を返す factorial 関数の定義です。 factorial は、「階乗」という意味です。 factorial 関数の処理の中で同じ factorial 関数を呼び出していることに注目してください。 これが再帰呼び出しです。

swipeプログラムは横スクロールできます

○整数型: factorial(整数型: n)
  if (n = 0)
    return 1
  else
    return n × factorial(n - 1) // これが再帰呼び出し
  endif

リスト 1 では、
「 n の階乗は、 n × (n – 1) の階乗である」
という考えで、階乗を求めています。 たとえば、 5 の階乗は、
5 × 4 × 3 × 2 × 1
ですが、これは
5 × ( 4 の階乗)
と考えることができます。

階乗を求める処理の中で、階乗を求める処理を使うことが、再帰呼び出しになるのです。

n × factorial(n - 1)

の部分は、
「 n の階乗は、n × (n – 1) の階乗である」
という考えをプログラムで表しています。

再帰呼び出しの仕組み

それでは、どうして再帰呼び出しで繰り返しが実現されるのでしょうか？ それは、関数を呼び出すと、関数の入り口から処理が行われるからです。

図 1 に示したように、 factorial 関数の処理の中で同じ factorial 関数を呼び出すと、 factorial 関数の処理が繰り返されます。

リスト 1 には、もう 1 つ注目してほしい部分があります。 それは、再帰呼び出しによる繰り返しが終わる部分です。

  if (n = 0)
    return 1

関数の処理の中で同じ関数を呼び出すというだけでは、永遠に処理が繰り返される無限ループになってしまいます。 そこで、 factorial 関数では、 if 文を使って、もしも引数 n が 0 なら再帰呼び出しを行わずに return 1 で戻り値として 1 を返しています（数学の約束で、 0 の階乗は 1 と決められているからです）。 これによって、再帰呼び出しによる繰り返しが終わるのです。

このように、再帰呼び出しを使うプログラムは、多くの場合に、 if 文を使って、ある条件なら同じ関数を呼び出して繰り返しを行い、ある条件なら同じ関数を呼び出さずに繰り返しを終える、という内容になります。

再帰呼び出しの処理の流れ

ここまでの説明で、再帰呼び出しの仕組みが何となくわかったと思いますが、 factorial 関数で引数 n の階乗が得られるまでの処理の流れがピンと来ないでしょう。

具体例として、引数 n = 3 のときの処理の流れをトレースしてみましょう。 3 の階乗は、
3 × 2 × 1 =6
です。

以下に、 factorial(3) を呼び出したときの処理の流れを示します。

手順 counter_1

factorial(3) が呼び出される。

手順 counter_2

return 3 × factorial(2) が行われ、 factorial(2) が呼び出される。

手順 counter_3

return 2 × factorial(1) が行われ、 factorial(1) が呼び出される。

手順 counter_4

return 1 × factorial(0) が行われ、 factorial(0) が呼び出される。

手順 counter_5

1 が返される。

手順 counter_6

return 1 × factorial(0) が return 1 × 1 となって 1 が返される。

手順 counter_7

return 2 × factorial(1) が return 2 × 1 となって 2 が返される。

手順 counter_8

return 3 × factorial(2) が return 3 × 2 となって 6 が返される。

上記の処理の流れのポイントは、

  return n × factorial(n - 1)

において、すぐには戻り値を返す処理が行われずに（処理は保留になります）、 factorial(n - 1) という再帰呼び出しが行われることです。 この再帰呼び出しによる繰り返しは、引数が 0 になったときに return 1 で 1 という戻り値を返すことで終わり、その後は、保留になっていた戻り値を返す処理が繰り返されます。

つまり、
関数を呼んで → 呼んで → 呼んで、と繰り返し、
戻り値を返して → 返して → 返して、と繰り返すのです。

3 の階乗は、 3 × 2 × 1 = 6 ですが、 1 の階乗を求めるときの 1 × (0 の階乗 ) において
1 × 1
という計算が行われるので、 3 × 2 × 1 × 1 = 6 で 6 が求められます。

再帰呼び出しの穴埋め問題にチャレンジする

試験対策として、プログラムの穴埋め問題にチャレンジしてみましょう。

これまでに例として示したプログラムと同じ内容ですが、再帰呼び出しの定番の例なので、確実に覚えてください。

リスト 2 は、引数 n の階乗を返す factorial 関数の定義です。 プログラム中の に入る正しい答えの組合せを解答群の中から選んでください。 引数 n は、 0 以上だとします。

○整数型: factorial(整数型: n)
  if (n = 0)
    return a
  else
    return b
  endif

解答群

	a	b
ア	0	factorial(n – 1)
イ	0	n × factorial(n – 1)
ウ	1	factorial(n – 1)
エ	1	n × factorial(n – 1)

空欄 a は、引数 n が 0 のときの処理です。 0 の階乗は 1 なので、 return 1 という処理を行い、再帰呼び出しを行いません（再帰呼び出しによる繰り返しが終了します）。

空欄 b は、引数 n が 0 でないときの処理です。 ここでは、「 n の階乗は、 n × (n – 1) の階乗である」という考えで、 n × factorial(n - 1) という処理を行います。

したがって、正解は、選択肢エです。

今回は、再帰呼び出しを取り上げました。

次回以降も、シラバスに示されたアルゴリズムとデータ構造を学んでいきます。

それでは、またお会いしましょう！

The post 再帰呼び出しのアルゴリズム｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/similar_programming/binary_search/ Mon, 08 May 2023 23:30:49 +0000 https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/?post_type=similar_programming&p=7752 基本情報技術者試験は、 2023 年 4 月から新制度で実施されています。 この連載では、新制度で採用された新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験にお […]

The post サーチのアルゴリズム (2) 二分探索法｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> 基本情報技術者試験は、 2023 年 4 月から新制度で実施されています。

この連載では、新制度で採用された新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。 受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、効率的なサーチアルゴリズムである 二分探索法 を取り上げます。

二分探索法のアルゴリズム

図 1 に示したように、裏返された状態で 7 枚のトランプが並んでいるとします。 これらの中から、マークは何でもよいので 5 のカードを見つけるとしたら、どうしますか？ 「先頭（左端が先頭だとします）から順に 1 枚ずつめくって 5 かどうかをチェックする」と考えたなら、それで正解です。 そのアルゴリズムは、第 4 回の記事で紹介した「線形探索法」です。

それでは、これら 7 枚のトランプが昇順（小さい順）にソートされているとしたら、どうしますか？ 線形探索法より効率的なアルゴリズムがありますので、ちょっと考えてみてください。 ポイントは、最初にどこをめくるかです。

勘のいい人は「真ん中のカードをめくって、その値から探索対象を前側か後ろ側に絞り込む」というアルゴリズムを思い付いたでしょう。 それで正解です。 そのアルゴリズムを「二分探索法」と呼びます。

トランプ（プログラムでは配列）がランダムに並んでいたら、線形探索法を使うことになりますが、ソートされているなら二分探索法を使った方が効率的です。 7 枚のトランプがある場合には、線形探索法では最大で 7 回カードをめくりますが、二分探索法では最大で 3 回カードをめくるだけで済みます。

図 2 に二分探索法で目的の値が見つかるまでの手順の例を示します。

7 枚のカードの探索対象は、 7 枚 → 3 枚 → 1 枚 と二分割されていきます。 だから二分探索と呼ぶのです。

ここでは、最後の 1 枚で見つかっていますが、その前の段階で見つかることも、最後までチェックして見つからないこともあります。

二分探索法のプログラムの例

リスト 1 は、二分探索法のプログラムの例です。 要素数 7 個の整数型の配列 a （昇順にソートされていて、要素番号は 0 から始まるとします）の中から変数 x と同じ値を見つけます。

二分探索法のプログラムには、決まりきった書き方があります。 これを、空手の型のように、プログラムの型として覚えてください。

なお、第 4 回の記事で説明したサーチアルゴリズムの基本である

format_quote

「見つかった場合は、見つかった位置（要素番号）を探索の結果とする」
「見つかった場合は、その時点で探索を終了する」
「見つからなかった場合は、配列の要素番号としてあり得ない -1 を探索の結果とする」

format_quote

は、二分探索法でも同様です。 繰り返しを中断するのに、 break 文を使うことも使わないこともできるのも、線形探索法と同様です。 リスト 1 では、 break 文を使っていません。

swipeプログラムは横スクロールできます

整数型の配列 a ← { 1, 2, 5, 6, 8, 10, 12 }
整数型 x, pos, left, mid, right

// 変数に初期値を設定する
x ← 5		// 見つける値
pos ← -1	// 探索の結果
left ← 0	// 探索対象の左端の要素番号
right ← 6	// 探索対象の右端の要素番号

// まだ探索対象があり、かつ、まだ見つかってない限り、探索を繰り返す
while (left ≦ right and pos = -1)
mid ← (left + right) ÷ 2	// 真ん中の要素の要素番号を得る
  if (a[mid] = x)		// 真ん中の要素が見つける値と同じ場合
    pos ← mid			// 探索の結果に見つかった位置を設定する
  elseif (a[mid] > x)		// 真ん中の要素が見つける値より大きい場合
    right ← mid - 1		// 真ん中より前側に探索対象を絞り込む
  else				// 真ん中の要素が見つける値より小さい場合
    left ← mid + 1		// 真ん中より後側に探索対象を絞り込む
  endif
endwhile

// 探索の結果を表示する
print(pos)

リスト 1 の内容を詳しく説明しましょう。

配列 a から変数 x と同じ値を見つけます。 探索の結果は、変数 pos に格納します。 ここでは、変数 x に 5 を設定しています。 変数 pos は、見つからなかったことを意味する -1 で初期化しています。

探索によって、 5 は a[2] に見つかるので、変数 pos の値は 2 で上書きされます。 最後にある print は、引数の値を画面に表示する手続だとします。 print(pos) によって、探索の結果が画面に表示されます。ここまでは、第 4 回で紹介した線形探索のプログラムと同様です。

二分探索法の型

変数 left 、 mid 、 right は、探索対象の左端、真ん中、左端の要素番号です。 これら 3 つの変数を使うことが、二分探索法の型です。 最初は、配列全体が探索対象なので、変数 left に先頭の要素番号の 0 を設定し、変数 right に末尾の要素番号の 6 を設定します。

 

二分探索法では、 while 文を使った繰り返しを行います。 while 文のカッコの中に記述する

left ≦ right and pos = -1

という条件も、二分探索法の型です。 これは、「まだ探索対象があり、かつ、まだ見つかってない」という条件を意味しています。

pos = -1 が「まだ見つかっていない」という条件であることはわかると思いますが、どうして left ≦ right が「まだ探索対象がある」という条件になるか、わかりますか？

leftの初期値は配列の先頭であり、 right の初期値は配列の末尾なので

left < right

です。 while文の繰り返しで、徐々に探索対象を狭めていくと、最後の 1 個の要素をチェックするときに

left = right

になります。 したがって、 left < right から left = right までは探索対象があるので、これらをまとめて記述して

left ≦ right

になるのです。

 

while 文で繰り返される処理の内容も、二分探索法の型です。

まず

mid ← (left + right) ÷ 2

で、現在の探索対象の真ん中の要素番号を変数 mid に得ています。 真ん中は (left + right) ÷ 2 という計算で得られます。 変数 left とright は、整数型なので、割り算の小数点以下はカットされます。

次に、 if 文で真ん中の a[mid] と変数 x の値を比べて、処理を 3 つに分岐させます。

looks_one もしも、真ん中の要素が見つける値と同じ場合 a[mid] = x

arrow_forward 探索の結果に見つかった位置を設定します pos ← mid

looks_two そうではなく、もしも、真ん中の要素が見つける値より大きい場合 a[mid] > x

arrow_forward 真ん中より前側に探索対象を絞り込みます right ← mid - 1

looks_3 そうではない場合 else

arrow_forward 真ん中の要素が見つける値より小さい場合なので、真ん中より後側に探索対象を絞り込みます left ← mid + 1

二分探索法の穴埋め問題にチャレンジする

試験対策として、二分探索法の穴埋め問題にチャレンジしてみましょう。

リスト 2 は、要素数 10 個（これまでの例より要素数が多くなっていることに注意してください）の配列 a から変数 x と同じ値を二分探索法で見つけるプログラムです。 プログラム中の に入る正しい答えの組合せを解答群の中から選んでください。 配列は、昇順にソートされていて、要素番号は 0 から始まるとします。

整数型の配列 a ← { 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 13 }
整数型 x, pos, left, mid, right

x ← 8
pos ← -1
left ← 0
right ← a

while (b)
mid ← (left + right) ÷ 2
  if (a[mid] = x)
    pos ← mid
  elseif (a[mid] > x)
    right ← mid - 1
  else
    left ← mid + 1
  endif
endwhile

print(pos)

解答群

	a	b
ア	9	left ≦ right and pos = -1
イ	9	right ≦ left and pos = -1
ウ	10	left ≦ right and pos = -1
エ	10	right ≦ left and pos = -1

空欄 a は、探索対象の右端の要素番号に、配列の末尾の要素番号を設定する処理です。 ここでは、配列の要素数が 10 個で、要素番号は 0 から始まるので、末尾の要素番号は 9 です。

空欄 b は、探索を繰り返す条件です。 ここには、「まだ探索対象があり、かつ、まだ見つかってない」を意味する

left ≦ right and pos = -1

を指定します。 したがって、選択肢アが正解です。

今回は、効率的なサーチアルゴリズムである二分探索法を取り上げました。

次回は、再帰のアルゴリズムを取り上げる予定です。

それでは、またお会いしましょう！

The post サーチのアルゴリズム (2) 二分探索法｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/similar_programming/sequential_search/ Tue, 04 Apr 2023 09:00:25 +0000 https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/?post_type=similar_programming&p=7736 基本情報技術者試験は、 2023 年 4 月から新制度で実施されます。 この連載では、新制度で採用される新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における […]

The post サーチのアルゴリズム (1) 線形探索法｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> 基本情報技術者試験は、 2023 年 4 月から新制度で実施されます。

この連載では、新制度で採用される新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。 受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、サーチアルゴリズムである 線形探索法 を取り上げます。

サーチアルゴリズムの基本

サーチ（ search = 探索）アルゴリズムは、配列の中から目的の値を見つけるアルゴリズムです。

基本情報技術者試験のシラバスには、サーチアルゴリズムとして、

• 線形探索法
• 二分探索法
• ハッシュ表探索法

が示されています。 今回は、線形探索法を取り上げます。 他のサーチアルゴリズムは、今後の記事の中で取り上げます。

 

線形探索法からサーチアルゴリズムの基本を知ることができます。

例として、図 1 に示した配列 a （要素番号は 0 から始まるとします）から、変数 x と同じ値を見つけるとしましょう。

線形探索法のアルゴリズムは、とてもシンプルです。 配列の先頭から末尾に向かって要素を 1 つずつ順番に取り出して、変数 x と同じ値かどうかをチェックするだけです。 先頭から末尾まで一直線にチェックするので、線形探索法と呼ぶのです。

図 1 では、変数 x と同じ値が a[2] に見つかります。 この場合には、見つかった位置の 2 を探索の結果とします。 これは、サーチアルゴリズムの基本です。 そして、見つかったら、その時点で探索を終了します。 これも、サーチアルゴリズムの基本です。

もしも、変数 x と同じ値が見つからなかった場合は、配列の要素番号としてあり得ない -1 という値を探索の結果とします（他の値でも構いませんが、多くの場合に -1 とします）。 これも、サーチアルゴリズムの基本です。

線形探索法のプログラムの例

リスト 1 は、先ほど図 1 に示した線形探索法の例を、擬似言語のプログラムにしたものです。 配列 a から変数 x と同じ値を探索します。

変数 pos には、探索の結果を格納します。 変数 pos の初期値を、見つからなかったことを意味する -1 にしていることに注目してください。 この後にある for 文による繰り返しで、 a[0] ～ a[4] を順番にチェックし、もしも見つかったら

(a[i] = x)

なら変数 pos の値を見つかった位置の i で上書きします。 こうすれば、変数 pos の値は、見つからなければ -1 のままであり、見つかれば見つかった位置になります。

このように、探索の結果を「見つからなかった」を意味する -1 で初期化することも、サーチアルゴリズムの基本です。

swipeプログラムは横スクロールできます

整数型の配列: a ← { 56, 34, 90, 78, 12 }
整数型: x, pos, i
x ← 90
pos ← -1

for ( i を 0 から 4 まで 1 ずつ増やす)
  if (a[i] = x)
    pos = i
    break
  endif
endfor
print(pos)

if 文の処理の中にある break は、繰り返し処理を中断する命令です。 擬似言語の記述形式を示した資料に break 命令はありませんが、 C 言語、 Java 、 Python など多くのプログラミング言語に break 命令があり、旧制度の試験問題でも break 命令が使われたことがあったので、新制度の試験問題でも break 命令が使われるでしょう。

プログラムの最後にある print は、引数の値を画面に表示する手続だとします。 print(pos) によって、探索の結果が画面に表示されます。

break 文を使わずに繰り返しを中断するテクニック

先ほどのリスト 1 では、 break 命令を使いましたが、 break 命令を好まない出題者もいるでしょう。 リスト 2 は、リスト 1 と同じ機能のプログラムを、 break 命令を使わずに記述した例です。 リスト 1 では繰り返し処理に for 文を使っていましたが、リスト 2 では while 文を使っています。

整数型の配列: a ← { 56, 34, 90, 78, 12 }
整数型: x, pos, i
x ← 90
pos ← -1
i ← 0

while (i ≦ 4 and pos = -1)
  if (a[i] = x)
    pos = i
  endif
  i ← i + 1
endwhile
print(pos)

while 文のカッコの中にある

i ≦ 4 and pos = -1

という条件に注目してください。

i ≦ 4 は、 a[i] の i が 4 以下という条件なので「まだ末尾までチェックしていない」という意味です。
pos = -1 は、 pos が初期値の -1 のままであるという条件なので「まだ見つかっていない」という意味です。
これら 2 つの条件を「かつ」を意味する and でつないでいるので、「まだ末尾までチェックしていない、かつ、まだ見つかっていない」という条件が真である限り、探索が繰り返されます。

変数 x の値は a[2] に見つかるので、その時点で変数 pos に 2 が格納されます。 これによって「まだ見つかっていない」という条件が偽になり、「まだ末尾までチェックしていない、かつ、まだ見つかっていない」という条件も偽になるので探索が終了します。

このように、変数 pos の値を繰り返しの条件に使うことで、 break 文を使わずに繰り返し処理を中断できます。 プログラミングのテクニックとして覚えておいてください。

線形探索の穴埋め問題にチャレンジする

試験対策として、線形探索法の穴埋め問題にチャレンジしてみましょう。

リスト 3 は、要素数 10 個（これまでの例より要素数が多くなっていることに注意してください）の配列 a から変数 x と同じ値を線形探索法で見つけるプログラム（ break 文を使わないプログラム）です。 プログラム中のに入る正しい答えの組合せを解答群の中から選んでください。 配列の要素番号は、 0 から始まるとします。

整数型の配列: a ← { 89, 99, 56, 34, 90, 67, 23, 78, 12, 45 }
整数型: x, pos, i
x ← 90
pos ← a
i ← 0

while (b)
  if (a[i] = x)
    pos = i
  endif
  i ← i + 1
endwhile
print(pos)

解答群

	a	b
ア	0	i ≦ 9 and pos = 0
イ	0	i ≦ 9 and pos = -1
ウ	-1	i ≦ 9 and pos = 0
エ	-1	i ≦ 9 and pos = -1

配列の要素数が増えても、アルゴリズムは同じです。

空欄 a は、探索の結果を格納する変数 pos の初期値の設定です。 この初期値は、見つからなかったことを意味する -1 が適切です。

空欄 b は、繰り返しの条件です。「まだ末尾までチェックしていない、かつ、まだ見つかっていない」という条件にします。

ここでは、配列の要素が a[0] ～ a[9] なので、「まだ末尾までチェックしていない」は、 i ≦ 9 です。「まだ見つかっていない」は、これまでと同じ pos = -1 です。

したがって、「まだ末尾までチェックしていない、かつ、まだ見つかっていない」は、

i ≦ 9 and pos = -1

です。

以上のことから、選択肢エが正解です。

今回は、基本的なサーチアルゴリズムである線形探索法を取り上げました。

次回は、効率的なサーチアルゴリズムである二分探索法を取り上げる予定です。

それでは、またお会いしましょう！

The post サーチのアルゴリズム (1) 線形探索法｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/similar_programming/bubble_sort_with_multiple_loop/ Sun, 05 Mar 2023 23:30:14 +0000 https://www.seplus.jp/dokushuzemi/ec/fe/fenavi/?post_type=similar_programming&p=7662 基本情報技術者試験は、 2023 年 4 月から新制度で実施されます。 この連載では、新制度で採用される新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における […]

The post 多重ループを使うバブルソート｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]> 基本情報技術者試験は、 2023 年 4 月から新制度で実施されます。

この連載では、新制度で採用される新しい擬似言語（旧制度の擬似言語とは、表記方法に違いがあります）を使って、試験のシラバス（情報処理技術者試験における知識・技能の細目）に示されている代表的なアルゴリズムとデータ構造を、プログラミング入門者向けにやさしく解説します。 受験対策としてだけでなく、アルゴリズムとプログラミングの基礎知識を習得するために、ぜひお読みください。

今回は、多重ループを使うソートアルゴリズムである バブルソート を取り上げます。

前提知識として多重ループの流れを知る

ソート（ sort = 整列） とは、配列の要素を昇順（小さい順）または降順（大きい順）に並べ替えることです。

試験のシラバスには、ソートアルゴリズムとして、

• バブルソート
• 選択ソート
• 挿入ソート
• クイックソート
• マージソート
• ヒープソート

が示されています。

これらの中で、バブルソート、選択ソート、挿入ソートは、繰り返しの中に繰り返しがある多重ループ（ loop = 繰り返し）を使うという点で共通しています。 今回は、バブルソートだけを取り上げますが、多重ループでソートを行うポイントをつかめれば、選択ソートと挿入ソートも容易に理解できるでしょう。 クイックソート、マージソート、ヒープソートに関しては、別の機会に取り上げます。

 

バブルソートのアルゴリズムを理解するための前提知識として、多重ループの流れを知っておきましょう。

多重ループという言葉だけを聞くと、とても難しく感じるかもしれませんが、日常生活にも普通に存在するものであり、決して難しくありません。 たとえば、 0 時 0 分から 23 時 59 分まで変化する 1 日の時計（デジタル時計）は、多重ループの好例です。 時の繰り返しの中に、分の繰り返しがあるからです。

多重ループを使って 1 日の時計を表示するプログラム

リスト 1 は、 1 日の時計を擬似言語のプログラムにしたものです（わかりやすいように色分けしています）。

for 文は、繰り返しを表す構文であり、 for と endfor で囲まれた範囲にある処理が、 for の後のカッコの中にある制御記述（どのように繰り返すかを示した文や式など）に従って繰り返されます。

for 文のループ中に別の for 文のループがあることに注目してください。

外側のループでは、時を表す変数 hour が 0 から 23 まで 1 ずつ増えます。
内側のループでは、分を表す変数 minute が 0 から 59 まで 1 ずつ増えます。

この多重ループの中で「 hour 時 minute 分を表示する」という処理が切り返されます。

swipeプログラムは横スクロールできます

整数型: hour, minute
for (hour を 0 から 23 まで 1 ずつ増やす)		// 外側のループ
  for (minute を 0 から 59 まで 1 ずつ増やす)	// 内側のループ
    hour 時 minute 分を表示する
  endfor
endfor

多重ループの流れは「外側のループ変数（繰り返すたびに変化する変数）の値が固定された状態で、内側のループ変数が変化する」です。

リスト 1 の変化を順番に見てみましょう。

1. 外側のループ変数 hour が 0 に固定された状態で、内側のループ変数 minute が 0 から 59 まで 1 ずつ変化
   subdirectory_arrow_right これによって 0 時 0 分から 0 時 59 分までが表示
2. 内側のループが終了すると、外側のループ変数 hour が変化
   subdirectory_arrow_right ここでは、 1 ずつ増えるので、ループ変数 hour が 1 になる
3. ループ変数 hour が 1 に固定された状態で、内側のループに入り直す
4. 再びループ変数 minute が 0 から 59 まで 1 ずつ変化
   subdirectory_arrow_right これによって 1 時 0 分から 1 時 59 分までが表示

以下同様に、 2 時 0 分から 2 時 59 分まで、 3 時 0 分から 3 時 59 分まで、 ……. 23 時 0 分から 23 時 59 分までが表示され、外側のループの終了によって、多重ループ全体が終了します。

 

リスト 1 では、 for 文の中に別の for 文がある多重ループの例を示しましたが、 whil e文や do ～ while 文を使って多重ループを作ることもできます。 どの場合でも、多重ループは、外側のループ変数の値が固定された状態で、内側のループ変数が変化する、という流れになります。

バブルソートのアルゴリズムを理解する

バブルソートのアルゴリズムを大雑把に説明すると

「配列の後ろから前に向かって、

1. 隣り合った要素（ある要素と 1 つ前の要素）を比較
2. 小さい方が前になるように交換

という処理を繰り返す」です。

池の底から表面に泡が浮き上がるように、配列の後ろから前に小さな値が浮かび上がるので、バブル（ bubble = 泡）ソートと呼ぶのです。

プログラムを示す前に、手作業でバブルソートをやってみましょう。

図 1 に手順を示します。ここでは、要素数 4 個の配列 a を昇順にソートしています。 配列の要素番号（添字やインデックスとも呼びます）は、 1 から始まるとします。

図 1 の手順を理解できたら、どのようなループ変数の多重ループで、どのような処理が繰り返されるかを考えてみましょう。

バブルソートでは、決定する位置と比較位置が変化していきます。 後で示すプログラムに合わせて、決定する位置を変数 num 、比較位置を変数 pos で表すことにします。

1. num を 1 に固定した状態で、 pos が 4 から 2 まで変化
2. num を 2 に固定した状態で、 pos が 4 から 3 まで変化
3. num を 3 に固定した状態で、 pos が 4 から 4 に変化
   （ 4 と 4 は同じ値ですが他に合わせて変化と考えてください）

このことから、 num が外側のループ変数であり、 pos が内側のループ変数であることがわかります。

外側のループ変数 num は、 1 （配列の先頭）から 3 （配列の末尾より 1 つ前の要素）まで 1 ずつ増えて変化します。 1 から 4 （配列の末尾の要素）でないのは、配列の末尾より 1 つ前の要素が決定すれば、残りの 1 つとなった末尾の要素は自動的に決定するからです。

内側のループ変数 pos は、 4 （配列の末尾）から、現在決定しようとしている位置 num の 1 つ右 (num + 1 ) まで 1 ずつ減って変化します。

 

多重ループで繰り返される処理は「比較位置の要素と 1 つ前の要素を比較し、小さい方が前になるように交換する」です。

配列の名前を a とすれば、
比較位置の要素は a[pos] であり、
1 つ前の要素は a[pos - 1] です。

a[pos - 1] > a[pos] という条件が真なら、 a[pos] と a[pos - 1] の値を交換します。

バブルソートのプログラムを読み取る

バブルソートが、どのようなループ変数の多重ループになり、どのような処理が繰り返されるかを理解できたらなら、プログラムも容易に理解できるでしょう。

リスト 2 は、先ほど図 1 で手順を示したバブルソートを擬似言語のプログラムにしたものです。

整数型の配列: a ← { 78, 56, 34, 12 }

は、「 78 」「 56 」「 34 」「 12 」という要素を持った配列 a を宣言しています。 整数型の変数 num と pos の役割は、これまでの説明と同じです。 整数型の変数 temp （ temporary = 一時的、という意味です）は、要素の値を交換するときに使います。

整数型の配列: a ← { 78, 56, 34, 12 }
整数型: num, pos, temp
for (num を 1 から 3 まで 1 ずつ増やす)		// 外側のループ
  for (pos を 4 から num +1 まで 1 ずつ減らす)	// 内側のループ
    if (a[pos - 1] > a[pos])
      temp ← a[pos]
      a[pos] ← a[pos - 1]
      a[pos - 1] ← temp
    endif
  endfor
endfor

変数 temp を使った値の交換も、覚えておくべきアルゴリズムです。 ここでは、 a[pos] と a[pos - 1] の値を交換します。

もしも、いきなり a[pos] ← a[pos - 1] を行ったら a[pos] の値が失われてしまうので、その前に

temp ← a[pos]

で a[pos] の値を変数 temp に一時的に逃がします。 temp ← a[pos] の後で、 a[pos] ← a[pos - 1] を行い、最後に

a[pos - 1] ← temp

を行えば、 a[pos] と a[pos - 1] の値を交換できます。

バブルソートの穴埋め問題にチャレンジする

試験対策として、バブルソートの穴埋め問題にチャレンジしてみましょう。

リスト 3 は、要素数 5 個（これまでの例より要素数が多くなっていることに注意してください）の配列 a を昇順にバブルソートするプログラムです。 プログラム中のに入る正しい答えの組合せを解答群の中から選んでください。 配列の要素番号は、 1 から始まるとします。

整数型の配列: a ← { 90, 78, 56, 34, 12 }
整数型: num, pos, temp
for (a)  // 外側のループ
  for (b)	// 内側のループ
    if ([pos - 1] a[pos])
      temp ← a[pos]
      a[pos] ← a[pos - 1]
      a[pos - 1] ← temp
    endif
  endfor
endfor

解答群

	a	b
ア	pos を num + 1 から 5 まで 1 ずつ増やす	num を 4 から 1 まで 1 ずつ減らす
イ	num を 4 から 1 まで 1 ずつ減らす	pos を num + 1 から 5 まで 1 ずつ増やす
ウ	pos を 5 から num + 1 まで 1 ずつ減らす	num を 1 から 4 まで 1 ずつ増やす
エ	num を 1 から 4 まで 1 ずつ増やす	pos を 5 から num + 1 まで 1 ずつ減らす

要素数が増えても、アルゴリズムは同じです。

外側のループ変数 num は、配列の先頭から末尾より 1 つ前まで 1 ずつ増えて変化します。
内側のループ変数 pos は、配列の末尾から現在決定しようとしている位置 num の 1 つ右 (num + 1) まで 1 ずつ減って変化します。

ここでは、配列の要素が a[1] から a[5] なので、外側の for 文の制御記述は

num を 1 から 4 まで 1 ずつ増やす

であり、内側の for 文の制御記述は

pos を 5 から num + 1 まで 1 ずつ減らす

です。

したがって、選択肢エが正解です。

今回は、多重ループを使うソートアルゴリズムであるバブルソートを取り上げました。

次回以降も、シラバスに示されたアルゴリズムとデータ構造を学んでいきます。

それでは、またお会いしましょう！

The post 多重ループを使うバブルソート｜新しい擬似言語で学ぶ 科目 B アルゴリズムとプログラミング入門 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

]]>