1 00:00:00,000 --> 00:00:01,000 [Powered by Google Translate] [第6項] [より快適] 2 00:00:01,000 --> 00:00:04,000 [ロブボーデン] [ハーバード大学] 3 00:00:04,000 --> 00:00:09,000 [これはCS50です。] [CS50.TV] 4 00:00:09,000 --> 00:00:11,000 >> ここでは、質問の私達のセクションに向かうことができる。 5 00:00:11,000 --> 00:00:17,000 私は前にスペースのURLを送った。 6 00:00:17,000 --> 00:00:22,000 質問のセクションの冒頭は言う - 7 00:00:22,000 --> 00:00:26,000 どうやら私は、非常に簡単な質問unsick-が完全に分からない 8 00:00:26,000 --> 00:00:28,000 のvalgrindされるだけで何の？ 9 00:00:28,000 --> 00:00:30,000 valgrindのは何をしますか？ 10 00:00:30,000 --> 00:00:34,000 誰もvalgrindのが何を言いたい？ 11 00:00:34,000 --> 00:00:36,000 [学生]をチェックし、メモリリークします。 12 00:00:36,000 --> 00:00:41,000 うん、Valgrindは一般的なメモリチェッカーです。 13 00:00:41,000 --> 00:00:44,000 あなたは、任意のメモリリークがある場合、それは、最終的には、あなたを伝え、 14 00:00:44,000 --> 00:00:49,000 それはあなたがしたい場合、我々は理由のためにそれを使用しているものほとんどです 15 00:00:49,000 --> 00:00:54,000 問題セットで、またはあなたがしたい場合はうまくやる 16 00:00:54,000 --> 00:00:59,000 大きなボードに乗って、あなたは、全くメモリリークがないことが必要 17 00:00:59,000 --> 00:01:01,000 ケース内には、あなたが見つけることができないメモリリークが発生している 18 00:01:01,000 --> 00:01:04,000 また、ファイルを開くたびにことを覚えておいてください 19 00:01:04,000 --> 00:01:07,000 そしてあなたがそれを閉じない場合、それはメモリリークだ。 20 00:01:07,000 --> 00:01:10,000 >> 多くの人々は、彼らが解放していないことをいくつかのノードを探しています 21 00:01:10,000 --> 00:01:15,000 ときに本当に、彼らは非常に最初のステップで辞書を閉じていませんでした。 22 00:01:15,000 --> 00:01:19,000 あなたは、任意の読み込み無効であるか、または書き込みを持っている場合、それはまた、あなたに伝え、 23 00:01:19,000 --> 00:01:22,000 あなたがしようとする値を設定した場合は、これは意味 24 00:01:22,000 --> 00:01:26,000 そのヒープの末尾を超えてだとそれがseg faultを発生しません 25 00:01:26,000 --> 00:01:30,000 しかし、Valgrindは、あなたが実際にそこに書くべきではありませんので、それをキャッチ 26 00:01:30,000 --> 00:01:33,000 ので、あなたは間違いなくどちらかのもののいずれかを持つべきではありません。 27 00:01:33,000 --> 00:01:38,000 どのようにvalgrindのを使うのですか？ 28 00:01:38,000 --> 00:01:42,000 どのようにvalgrindのを使うのですか？ 29 00:01:42,000 --> 00:01:45,000 >> これは、一般的な質問です 30 00:01:45,000 --> 00:01:49,000 の種類は、それを実行して出力を見てみましょう。 31 00:01:49,000 --> 00:01:51,000 出力には、多くの時間を圧倒しています。 32 00:01:51,000 --> 00:01:54,000 あなたには、いくつかのひどく間違ったことがあれば楽しいのエラーもあります 33 00:01:54,000 --> 00:01:59,000 ループの中で何が起き、それが最終的には、あまりにも多くのエラーが発生する "、と言うだろう。 34 00:01:59,000 --> 00:02:03,000 私は今、カウントを停止するつもりです。 " 35 00:02:03,000 --> 00:02:08,000 それはあなたが解析しなければならないことを基本的にはテキスト出力です。 36 00:02:08,000 --> 00:02:13,000 最後に、それはあなたが持っている任意のメモリリークを教えてくれる、 37 00:02:13,000 --> 00:02:16,000 どのように多くの点で有用であることができるブロック、 38 00:02:16,000 --> 00:02:20,000 それは一つのブロック未解放の場合、それは見つけるために通常はより簡単です 39 00:02:20,000 --> 00:02:23,000 1,000以上のブロックは未解放。 40 00:02:23,000 --> 00:02:26,000 1000ブロックは、おそらくあなたが解放していないことを意味未解放 41 00:02:26,000 --> 00:02:30,000 適切か何かあなたのリンクリスト。 42 00:02:30,000 --> 00:02:32,000 それはvalgrindのです。 43 00:02:32,000 --> 00:02:35,000 >> 今、私たちは、質問の私達のセクションを持っている 44 00:02:35,000 --> 00:02:38,000 どちらをダウンロードする必要はありません。 45 00:02:38,000 --> 00:02:41,000 あなたは私の名前をクリックし、スペースでそれらをプルアップすることができます。 46 00:02:41,000 --> 00:02:44,000 今の私をクリックしてください。 47 00:02:44,000 --> 00:02:46,000 リビジョン1は我々が最初にやっているスタックになります。 48 00:02:46,000 --> 00:02:55,000 リビジョン2には、キューとなり、リビジョン3は、片方向リンクリストになります。 49 00:02:55,000 --> 00:02:58,000 私たちのスタックから開始する。 50 00:02:58,000 --> 00:03:02,000 それはここで言っているように、スタックは、最も基本的なの一つです 51 00:03:02,000 --> 00:03:07,000 コンピュータ科学の基本的なデータ構造。 52 00:03:07,000 --> 00:03:11,000 非常に典型的な例です 53 00:03:11,000 --> 00:03:13,000 ダイニングホールにあるトレーのスタック。 54 00:03:13,000 --> 00:03:16,000 あなたがスタックに導入されているときはいつでも、それは、基本的にはだ 55 00:03:16,000 --> 00:03:20,000 誰かが言おうとしている "トレーのスタックのように、ああ。" 56 00:03:20,000 --> 00:03:22,000 あなたは、トレイを積み重ねる。 57 00:03:22,000 --> 00:03:24,000 その後、トレイを引っ張って行くとき、 58 00:03:24,000 --> 00:03:31,000 引っ張らなってきた最初のトレイは、スタック上に置かれた最後のものである。 59 00:03:31,000 --> 00:03:34,000 それが言うにも似たここにデュアルスタック 60 00:03:34,000 --> 00:03:37,000 我々は、スタックと呼ば​​れるメモリのセグメントを持っています。 61 00:03:37,000 --> 00:03:40,000 そして、なぜそれがスタックと呼ば​​れる？ 62 00:03:40,000 --> 00:03:42,000 >> なぜなら、スタックデータ構造のような、 63 00:03:42,000 --> 00:03:46,000 それは、スタック上にスタックフレームをプッシュし、ポップ 64 00:03:46,000 --> 00:03:53,000 関数の特定の呼び出しのようにどこにスタックフレームです。 65 00:03:53,000 --> 00:03:57,000 と、スタックのように、いつでも返却する必要があります 66 00:03:57,000 --> 00:04:03,000 関数呼び出しから、再度下部のスタックフレームにダウンして得ることができる前に。 67 00:04:03,000 --> 00:04:08,000 あなたは、メインCALL FOOコールバーとバーメイン直接リターンを持つことができません。 68 00:04:08,000 --> 00:04:14,000 それは常に正しいスタックプッシュとポップに従うことを持っている。 69 00:04:14,000 --> 00:04:18,000 2つの操作は、私が言ったように、pushとpopされています。 70 00:04:18,000 --> 00:04:20,000 それらは普遍的な用語です。 71 00:04:20,000 --> 00:04:26,000 あなたは、スタックが何でという点でpushとpopを知っている必要があります。 72 00:04:26,000 --> 00:04:28,000 我々は、キューが異なるの一種であるが表示されます。 73 00:04:28,000 --> 00:04:32,000 それは本当に普遍的な言葉を持っていませんが、pushとpopはスタックの普遍的なものである。 74 00:04:32,000 --> 00:04:34,000 プッシュは単にスタックに置かれる。 75 00:04:34,000 --> 00:04:37,000 ポップはスタックを脱いだ。 76 00:04:37,000 --> 00:04:43,000 そして、我々は、我々は我々のtypedef structのスタックを持ってこちらをご覧ください 77 00:04:43,000 --> 00:04:46,000 ので、我々はchar **文字列を持っている。 78 00:04:46,000 --> 00:04:51,000 任意の**がびっくりしないでください。 79 00:04:51,000 --> 00:04:54,000 これは文字列の配列になってしまうために起こっている 80 00:04:54,000 --> 00:04:58,000 文字へのポインタの配列や、どこ 81 00:04:58,000 --> 00:05:00,000 文字へのポインタが文字列になる傾向があります。 82 00:05:00,000 --> 00:05:05,000 それは、文字列である必要はありませんが、ここでは、それらは文字列であることを行っている。 83 00:05:05,000 --> 00:05:08,000 >> 私たちは、文字列の配列を持っている。 84 00:05:08,000 --> 00:05:14,000 我々は、スタック上に現在どのように多くの要素を表す大きさを、持っている 85 00:05:14,000 --> 00:05:19,000 それから私達はスタック上にどのように多くの要素であることができるである能力を持っています。 86 00:05:19,000 --> 00:05:22,000 容量は、1より大きいものとしてオフを開始する必要があり 87 00:05:22,000 --> 00:05:27,000 しかし、サイズは0としてスタートする予定です。 88 00:05:27,000 --> 00:05:36,000 今、あなたがスタックと考えることができ、3つの異なる方法が基本的にあります。 89 00:05:36,000 --> 00:05:39,000 まあ、おそらくよりますが、2つの主要な方法があります。 90 00:05:39,000 --> 00:05:43,000 あなたは配列を使用して、それを実装したり、リンクされたリストを使用して実装できます。 91 00:05:43,000 --> 00:05:48,000 リンクされたリストからスタックを作るために些細なの一種です。 92 00:05:48,000 --> 00:05:51,000 これは、リンクされたリストを使用してスタックを作ることは非常に簡単です 93 00:05:51,000 --> 00:05:55,000 ので、ここで私たちは、配列を使用してスタックをするつもりだ、 94 00:05:55,000 --> 00:05:59,000 その後配列を使用して、あなたがそれについて考えることができる2つの方法も用意されている。 95 00:05:59,000 --> 00:06:01,000 前に、私が言ったとき、我々は、スタックの容量を持っている 96 00:06:01,000 --> 00:06:04,000 ので、我々は、スタック上に要素を収めることができます。 97 00:06:04,000 --> 00:06:09,000 >> それが起こりうる一つの方法は、できるだけ早くあなたが10個の要素を打つようにして、設定が完了しています。 98 00:06:09,000 --> 00:06:13,000 あなたは世界の10の事柄の上限があることを知っているかもしれません 99 00:06:13,000 --> 00:06:16,000 あなたは、あなたのスタックに10以上のものを持っていることは決してないだろうことを 100 00:06:16,000 --> 00:06:20,000 その場合には、スタックのサイズに上限を持つことができます。 101 00:06:20,000 --> 00:06:23,000 またはあなたは、あなたのスタックが際限のないことかもしれない 102 00:06:23,000 --> 00:06:27,000 アレイをやっているけど、それは、一つ一つの時間はあなたが10個の要素をヒットすることを意味します 103 00:06:27,000 --> 00:06:29,000 その後、20個の要素に成長する必要があるとしている、あなたは20個の要素をヒットしたとき、 104 00:06:29,000 --> 00:06:33,000 あなたは30の要素または40個の要素に配列を成長させる必要があるとしている。 105 00:06:33,000 --> 00:06:37,000 あなたは、私たちがここでやろうとしているな容量を増加する必要があるとしている。 106 00:06:37,000 --> 00:06:40,000 我々は、我々のスタックの最大サイズに達する毎回 107 00:06:40,000 --> 00:06:46,000 我々は他の何かを押したときに、我々は、容量を増やすことが必要になるだろう。 108 00:06:46,000 --> 00:06:50,000 ここでは、プッシュプッシュブール型（char * str）とのように宣言しました。 109 00:06:50,000 --> 00:06:54,000 のchar * strは、我々がスタックにプッシュされていることを文字列である 110 00:06:54,000 --> 00:06:58,000 とboolはちょうど私達が成功したか失敗したかと言います。 111 00:06:58,000 --> 00:07:00,000 >> どのように我々は失敗することができますか？ 112 00:07:00,000 --> 00:07:04,000 あなたが考えることができる唯一の​​状況は何ですか 113 00:07:04,000 --> 00:07:07,000 ここで我々は、falseを返す必要があるのでしょうか。 114 00:07:07,000 --> 00:07:09,000 うん。 115 00:07:09,000 --> 00:07:12,000 [学生]がいっぱいだと我々は境界の実装を使用している場合。 116 00:07:12,000 --> 00:07:17,000 ええ、そうどのように我々が定義する、と彼は答えない 117 00:07:17,000 --> 00:07:23,000 それが完全だと我々は有界実装を使用している場合。 118 00:07:23,000 --> 00:07:26,000 その後、我々は間違いなくfalseを返します。 119 00:07:26,000 --> 00:07:31,000 とすぐに我々は配列に10の事柄を打つように、我々は11を収めることができないので、我々はfalseを返します。 120 00:07:31,000 --> 00:07:32,000 それがバインドされていない場合はどうなりますか？うん。 121 00:07:32,000 --> 00:07:38,000 あなたには、いくつかの理由のためのアレイを拡張することができない場合。 122 00:07:38,000 --> 00:07:43,000 ええ、そうメモリは、限られたリソースである 123 00:07:43,000 --> 00:07:51,000 そして最終的に、我々は何度もスタックにプッシュすることを続ければ、 124 00:07:51,000 --> 00:07:54,000 我々は、フィットするように大きい配列を試してみて、割り当てるつもりだ 125 00:07:54,000 --> 00:07:59,000 我々が使っている大容量、およびmallocまたは何でもfalseを返すために起こっている。 126 00:07:59,000 --> 00:08:02,000 まあ、malloc関数はnullを返します。 127 00:08:02,000 --> 00:08:05,000 >> 、あなたがこれまでにmalloc関数を呼び出すごとに1つの時間を覚えて、あなたはそれかどうかをチェックすべきである 128 00:08:05,000 --> 00:08:12,000 nullを返すか、または他のそれが正しさの控除です。 129 00:08:12,000 --> 00:08:17,000 我々は、無制限のスタックを持つようにしたいので、 130 00:08:17,000 --> 00:08:21,000 我々がしようとした場合、我々はfalseを返すことになるだろう唯一のケースです 131 00:08:21,000 --> 00:08:26,000 容量とmallocを増やすか、falseを返します何でも。 132 00:08:26,000 --> 00:08:30,000 その後ポップは、引数を取らない 133 00:08:30,000 --> 00:08:37,000 そして、それはスタックの一番上の文字列を返します。 134 00:08:37,000 --> 00:08:41,000 全てのものが、最近スタックにプッシュされましたが、戻っている何ポップです 135 00:08:41,000 --> 00:08:44,000 そしてそれはまた、スタックから削除されます。 136 00:08:44,000 --> 00:08:50,000 およびスタック上の何もない場合にはnullを返していることがわかります。 137 00:08:50,000 --> 00:08:53,000 これは、スタックが空であることが常に可能である。 138 00:08:53,000 --> 00:08:55,000 Javaでは、あなたがその、あるいは他の言語に慣れている場合、 139 00:08:55,000 --> 00:09:01,000 空のスタックからポップしようとすると、例外か何かを引き起こすかもしれません。 140 00:09:01,000 --> 00:09:09,000 >> しかし、C言語では、nullは、我々はこれらの問題をどのように処理するかは多くのケースのようなものです。 141 00:09:09,000 --> 00:09:13,000 nullを返すことは、我々は、スタックが空であったことを意味しようとしている方法です。 142 00:09:13,000 --> 00:09:16,000 我々は、あなたのスタックの機能をテストするためのコードを提供してきました 143 00:09:16,000 --> 00:09:19,000 pushとpopを実装します。 144 00:09:19,000 --> 00:09:23,000 これは、多くのコードではありません。 145 00:09:23,000 --> 00:09:40,000 私は意志 - 実際に、我々はそれを行う前に、ヒント、ヒント - 146 00:09:40,000 --> 00:09:44,000 あなたがそれを見ていない場合は、malloc関数は唯一の機能ではありません 147 00:09:44,000 --> 00:09:47,000 それはあなたのためのヒープ上のメモリを割り当てます。 148 00:09:47,000 --> 00:09:51,000 アロケーションファミリの関数があります。 149 00:09:51,000 --> 00:09:53,000 第一は、これまで使ってmalloc関数です。 150 00:09:53,000 --> 00:09:56,000 その後、malloc関数と同じことをしcallocは、そこ 151 00:09:56,000 --> 00:09:59,000 しかし、それはあなたのためにすべてをゼロにします。 152 00:09:59,000 --> 00:10:04,000 あなたは今まで何かをmallocing後にnullにすべてのものを設定したいと思っていた場合 153 00:10:04,000 --> 00:10:06,000 あなただけの代わりに書いて最初の場所にあるcallocを使用している必要があります 154 00:10:06,000 --> 00:10:09,000 メモリの全ブロックを0にしてforループ。 155 00:10:09,000 --> 00:10:15,000 >> reallocは、malloc関数のようなもので、特殊な例をたくさん持っている 156 00:10:15,000 --> 00:10:19,000 しかし、基本的には何のreallocでない 157 00:10:19,000 --> 00:10:24,000 それがすでに割り当てられているポインタを受け取ります。 158 00:10:24,000 --> 00:10:27,000 reallocはここに注目したい関数です。 159 00:10:27,000 --> 00:10:31,000 それは、すでにmalloc関数から返されたポインタを受け取ります。 160 00:10:31,000 --> 00:10:35,000 Let 'sは、あなたは、mallocから10バイトのポインタを要求すると言う。 161 00:10:35,000 --> 00:10:38,000 その後、あなたが20バイトを望んで実現する、 162 00:10:38,000 --> 00:10:42,000 ので、20バイトで、そのポインタでreallocを呼び出す 163 00:10:42,000 --> 00:10:47,000 とreallocは自動的にあなたのためにすべてをコピーします。 164 00:10:47,000 --> 00:10:51,000 私は10バイトのブロックを持っているように、あなただけは、もう一度、malloc（）を呼び出された場合。 165 00:10:51,000 --> 00:10:53,000 今私は、20バイトのブロックを必要とする、 166 00:10:53,000 --> 00:10:58,000 ので、私がmalloc 20バイトあれば、私は手動で最初のものから10バイトを上書きコピーする必要があります 167 00:10:58,000 --> 00:11:01,000 まず二つ目に、その後フリー。 168 00:11:01,000 --> 00:11:04,000 reallocはあなたのためにそれを処理します。 169 00:11:04,000 --> 00:11:11,000 >> 署名は、void *であることを行っていることに気づく 170 00:11:11,000 --> 00:11:15,000 それはちょうど、メモリブロックへのポインタを返している 171 00:11:15,000 --> 00:11:17,000 次にボイド* ptrは。 172 00:11:17,000 --> 00:11:22,000 あなたは、汎用ポインタとしてvoid *型と考えることができます。 173 00:11:22,000 --> 00:11:27,000 一般的には、void *型を扱うことはありません 174 00:11:27,000 --> 00:11:30,000 しかし、mallocはvoid *を返すされており、それは同じように使われている 175 00:11:30,000 --> 00:11:34,000 これは実際にはchar *であることを行っている。 176 00:11:34,000 --> 00:11:37,000 mallocで返されていた以前のvoid * 177 00:11:37,000 --> 00:11:41,000 今のreallocに渡されようとして、次にサイズです 178 00:11:41,000 --> 00:11:49,000 割り当てたいバイトの新しい番号なので、あなたの新たな容量です。 179 00:11:49,000 --> 00:11:57,000 私はあなたに数分を与え、私たちの空間でそれをやる。 180 00:11:57,000 --> 00:12:02,000 リビジョン1から始まります。 181 00:12:16,000 --> 00:12:21,000 私は、プッシュを実装するのに十分な時間後に約願わくはあなたを停止します 182 00:12:21,000 --> 00:12:24,000 そして私はあなたにポップアップを行うには別の休憩を与えるでしょう。 183 00:12:24,000 --> 00:12:27,000 しかし、それは本当にすべてではそれほどコードではありません。 184 00:12:27,000 --> 00:12:35,000 ほとんどのコードは、容量を拡大し、おそらく拡大されるものです。 185 00:12:35,000 --> 00:12:39,000 さて、完全に実行するための圧力がない、 186 00:12:39,000 --> 00:12:47,000 しかし限り、あなたは正しい道にいるように感じるように、それは良いことだ。 187 00:12:47,000 --> 00:12:53,000 >> 誰もが、彼らが私を引き上げ、快適に感じて任意のコードを持っていますか？ 188 00:12:53,000 --> 00:12:59,000 ええ、私はしますが、誰も私がアップすることができ、任意のコードを持っているのですか？ 189 00:12:59,000 --> 00:13:05,000 さて、あなたはそれが何であれ、それを保存し、起動することができますか？ 190 00:13:05,000 --> 00:13:09,000 私はいつも、そのステップを忘れてしまった。 191 00:13:09,000 --> 00:13:15,000 さて、プッシュを見て、 192 00:13:15,000 --> 00:13:18,000 あなたのコードを説明したいのですか？ 193 00:13:18,000 --> 00:13:24,000 [学生]は、まず第一に、私はサイズを増加させた。 194 00:13:24,000 --> 00:13:28,000 私は多分私はその、とにかく持っている必要がありますね、私は、サイズを増加 195 00:13:28,000 --> 00:13:31,000 それが容量より小さい場合だと、私は参照してください。 196 00:13:31,000 --> 00:13:36,000 それが容量より小さい場合だと、私は我々がすでに持っている配列に追加します。 197 00:13:36,000 --> 00:13:42,000 それがないならば、私は、2で容量を掛け 198 00:13:42,000 --> 00:13:50,000 と私は今、より大きな容量の大きさで何かに文字列の配列を再割り当てする。 199 00:13:50,000 --> 00:13:55,000 それが失敗した場合、その後、私はユーザーに伝えると、falseを返す 200 00:13:55,000 --> 00:14:04,000 それは大丈夫ですなら、私は新しい場所に文字列を置く。 201 00:14:04,000 --> 00:14:07,000 >> [ロブB.]我々はここでは素敵なビット単位の演算子を使用していることも注意してください 202 00:14:07,000 --> 00:14:09,000 2を掛けます。 203 00:14:09,000 --> 00:14:11,000 覚えておいて、左シフトは常に2を乗じれようとしている。 204 00:14:11,000 --> 00:14:15,000 あなたはそれが意味することを覚えているように、右シフトであれば2分周され 205 00:14:15,000 --> 00:14:18,000 2で割った整数のように、2で割る。 206 00:14:18,000 --> 00:14:20,000 それはここまたはそこに1を切り捨てる可能性があります。 207 00:14:20,000 --> 00:14:26,000 しかし1だけ左シフトは常に2を乗じれようとしている、 208 00:14:26,000 --> 00:14:32,000 あなたは整数オーバーフローの境界をしない限り、そして、次に、それはできません。 209 00:14:32,000 --> 00:14:34,000 側のコメント。 210 00:14:34,000 --> 00:14:39,000 私は全くコーディングどのような方法を変更するつもりはない、これは、やりたい、 211 00:14:39,000 --> 00:14:48,000 しかし私はこのような何かをしたい。 212 00:14:48,000 --> 00:14:51,000 それは実際にそれが若干長く作るつもりです。 213 00:15:04,000 --> 00:15:08,000 多分これは、このことを示すのに最適なケースではありません 214 00:15:08,000 --> 00:15:14,000 しかし私は、これらのブロックの中にセグメントにそれを好む 215 00:15:14,000 --> 00:15:17,000 この事態が発生した場合場合、大丈夫、私は何かをするつもりだ、 216 00:15:17,000 --> 00:15:19,000 してから、関数が実行されます。 217 00:15:19,000 --> 00:15:22,000 私はその後、ダウン機能ずっと私の目をスクロールする必要はありません 218 00:15:22,000 --> 00:15:25,000 他の後に何が起こるか確認してください。 219 00:15:25,000 --> 00:15:27,000 この問題が発生した場合した場合それは、その後、私はちょうど返す。 220 00:15:27,000 --> 00:15:30,000 また、この以降はすべての素敵な付加的な利点を持っている 221 00:15:30,000 --> 00:15:33,000 今一度、左にシフトされます。 222 00:15:33,000 --> 00:15:40,000 あなたがこれまでに途方もなく長い行の近くにいる場合には、私はもはや、必要はありません 223 00:15:40,000 --> 00:15:45,000 、それらの4バイトは助けることができ、また、より左のものです 224 00:15:45,000 --> 00:15:48,000 少ないような - 大丈夫、私が覚えていたら、気が遠くなる 225 00:15:48,000 --> 00:15:53,000 私は、forループのelseの内側の内側のwhileループで、現在です。 226 00:15:53,000 --> 00:15:58,000 どこでもあなたは私の種類のような、すぐにこのリターンを行うことができます。 227 00:15:58,000 --> 00:16:05,000 それは完全にオプションだし、どのような方法では想定されません。 228 00:16:05,000 --> 00:16:12,000 >> [学生]はそこサイズである必要があります - 障害状態に？ 229 00:16:12,000 --> 00:16:19,000 ここで失敗する条件は、我々はそうはい、reallocのに失敗しています。 230 00:16:19,000 --> 00:16:22,000 、おそらく、障害状態でどのように注意してください 231 00:16:22,000 --> 00:16:26,000 私たちは無料のもの後、我々は常に失敗にしたいのでない限り 232 00:16:26,000 --> 00:16:29,000 私たちは何かをプッシュしようと何回でもありません。 233 00:16:29,000 --> 00:16:32,000 私達はプッシュし続けるなら、私たちは、インクリメントサイズを維持 234 00:16:32,000 --> 00:16:36,000 我々は、スタック上に何かを入れていない場合でも。 235 00:16:36,000 --> 00:16:39,000 通常、我々まで、サイズを増加させません 236 00:16:39,000 --> 00:16:43,000 我々は正常にスタックの上に置いた後。 237 00:16:43,000 --> 00:16:50,000 我々はこことここのどちらか、と言う、それを行うだろう。 238 00:16:50,000 --> 00:16:56,000 代わり≤容量をs.size言うのそして、それは、容量よりも小さいです 239 00:16:56,000 --> 00:17:01,000 すべてのものがどこにあったかという理由だけで、我々は移動しました。 240 00:17:01,000 --> 00:17:07,000 >> そして、我々はおそらくfalseを返すことができること、唯一の場所を覚えている 241 00:17:07,000 --> 00:17:14,000 reallocはnullを返して、​​ここにある 242 00:17:14,000 --> 00:17:19,000 そしてあなたは、標準エラーを覚えてしまった場合、 243 00:17:19,000 --> 00:17:22,000 あなたが標準エラーを出力したい場所多分あなたは、このようなケースを検討するかもしれない 244 00:17:22,000 --> 00:17:26,000 だけではなく、標準出力に直接印刷のようにfprintfを標準エラー出力（stderr）。 245 00:17:26,000 --> 00:17:31,000 繰り返しになりますが、、それは期待しないが、それは誤りだ場合 246 00:17:31,000 --> 00:17:41,000 printf関数の型、あなたはそれが標準エラー出力の代わりに標準出力に出力しておくことをお勧めします。 247 00:17:41,000 --> 00:17:44,000 >> 誰もが注意すべき何かを持っている？はい。 248 00:17:44,000 --> 00:17:47,000 [学生]あなたは[聞こえない]の上に行くことはできますか？ 249 00:17:47,000 --> 00:17:55,000 [ロブB.]はい、実際のそれのbinarinessまたはちょうどそれが何であるか？ 250 00:17:55,000 --> 00:17:57,000 [学生]だからあなたは2を掛けて？ 251 00:17:57,000 --> 00:17:59,000 [ロブB.]うん、基本的に。 252 00:17:59,000 --> 00:18:11,000 バイナリ土地では、我々は常に我々の数字のセットを持っています。 253 00:18:11,000 --> 00:18:22,000 右側でここは基本的にそれを挿入することで、この1を左シフトする。 254 00:18:22,000 --> 00:18:25,000 これに戻る、単なるバイナリでそのすべてを覚えている 255 00:18:25,000 --> 00:18:28,000 、2の累乗であるので、これは0から2を表す 256 00:18:28,000 --> 00:18:30,000 1〜2本、この2へ​​。 257 00:18:30,000 --> 00:18:33,000 今右側に0を挿入することによって、我々は、ちょうどすべてを上にシフトします。 258 00:18:33,000 --> 00:18:38,000 何が0から2にするために使用すると、今では1〜2で、2から2です。 259 00:18:38,000 --> 00:18:41,000 我々は挿入右側 260 00:18:41,000 --> 00:18:44,000 必ずしも0になるだろう 261 00:18:44,000 --> 00:18:46,000 これは理にかなっています。 262 00:18:46,000 --> 00:18:49,000 あなたがこれまでに2で番号を掛けると、それは、奇数終わることはないだろう 263 00:18:49,000 --> 00:18:54,000 ので0の場所に2が0でなければなりません 264 00:18:54,000 --> 00:18:59,000 あなたがシフトしてしまったんなら、これは私が半分になる前に何かを警告 265 00:18:59,000 --> 00:19:01,000 整数のビット数を超えて、 266 00:19:01,000 --> 00:19:04,000 次に、この1はオフに行くことに終わろうとしている。 267 00:19:04,000 --> 00:19:10,000 あなたが本当に大容量を扱うことが起こるなら、それは唯一の悩みだ。 268 00:19:10,000 --> 00:19:15,000 しかし、その時点で、あなたは、物事の数十億の配列を扱っている 269 00:19:15,000 --> 00:19:25,000 とにかくメモリに収まらないかもしれない。 270 00:19:25,000 --> 00:19:31,000 >> 今、私たちはさらに簡単ですポップ、取得することができます。 271 00:19:31,000 --> 00:19:36,000 あなたは全体の束をポップしてしまった場合は、それが好きなのでした 272 00:19:36,000 --> 00:19:38,000 今、あなたは再び半分の容量にいる。 273 00:19:38,000 --> 00:19:42,000 あなたは、あなたが持っているメモリの量を縮小することができREALLOC 274 00:19:42,000 --> 00:19:47,000 しかし、あなたはそのことについて心配する必要はありませんので、唯一のreallocのケースがあることを行っている 275 00:19:47,000 --> 00:19:50,000 成長しているメモリは、メモリを縮小することはありません、 276 00:19:50,000 --> 00:19:59,000 これはポップのスーパーを容易にしようとしている。 277 00:19:59,000 --> 00:20:02,000 スタックのようになるだろうしている今のキュー、 278 00:20:02,000 --> 00:20:06,000 しかし、あなたが物事を取り出した順序が逆になっています。 279 00:20:06,000 --> 00:20:10,000 キューの典型例は、ラインです 280 00:20:10,000 --> 00:20:12,000 あなたは英語であった場合、私が推測するに、私は言ったでしょう 281 00:20:12,000 --> 00:20:17,000 キューの典型例では、キューです。 282 00:20:17,000 --> 00:20:22,000 だから線のように、行の最初の人なら、 283 00:20:22,000 --> 00:20:24,000 あなたはラインの内、最初の人になることを期待しています。 284 00:20:24,000 --> 00:20:31,000 あなたが行の最後の人なら、あなたは修理最後の一人になるだろうしている。 285 00:20:31,000 --> 00:20:35,000 スタックはLIFOのパターンだったのに対し、我々は、そのFIFOのパターンを呼び出します。 286 00:20:35,000 --> 00:20:40,000 それらの言葉は、かなり普遍的なものである。 287 00:20:40,000 --> 00:20:46,000 >> スタックと同様と配列とは異なり、キューは通常、中間の要素へのアクセスを許可していません。 288 00:20:46,000 --> 00:20:50,000 ここでは、スタックは、我々は、pushとpopを持っています。 289 00:20:50,000 --> 00:20:54,000 ここでは、それらのエンキューおよびデキューの求めているために起こる。 290 00:20:54,000 --> 00:20:58,000 私はまた、彼らはshiftとunshiftを呼ばれるのを聞いた。 291 00:20:58,000 --> 00:21:02,000 私は人々がpushとpopキューにも適用すると言う聞いたことがある。 292 00:21:02,000 --> 00:21:05,000 私は、削除、挿入、聞いたことがある 293 00:21:05,000 --> 00:21:11,000 あなたがスタックの話をしている場合そうpushとpop、あなたはプッシュとポップされています。 294 00:21:11,000 --> 00:21:16,000 あなたがキューの話をしている場合は、使用する語句を選ぶことができ 295 00:21:16,000 --> 00:21:23,000 挿入および除去のために、それが呼ばれるべきかについてのコンセンサスはありません。 296 00:21:23,000 --> 00:21:27,000 しかし、ここで、我々はエンキューとデキューを持っています。 297 00:21:27,000 --> 00:21:37,000 今、構造体はスタック構造体とほぼ同じに見えます。 298 00:21:37,000 --> 00:21:40,000 しかし、我々は頭を追跡する必要があります。 299 00:21:40,000 --> 00:21:44,000 私はそれがダウンしてここに言うと思いますが、なぜ私たちは頭が必要なのでしょうか？ 300 00:21:53,000 --> 00:21:57,000 プロトタイプは、pushとpop、基本的に同じです。 301 00:21:57,000 --> 00:21:59,000 あなたは、pushとpopと考えることができます。 302 00:21:59,000 --> 00:22:08,000 ポップで唯一の違いは、返す代わりに、されている最後のではなく、最初に戻っている。 303 00:22:08,000 --> 00:22:12,000 2、1、3、4、または何か。 304 00:22:12,000 --> 00:22:14,000 そして、ここではスタートです。 305 00:22:14,000 --> 00:22:17,000 私達のキューが完全にいっぱいになるので、それには4つの要素があります。 306 00:22:17,000 --> 00:22:21,000 私達のキューの最後には、現在2である 307 00:22:21,000 --> 00:22:24,000 そして今我々は何か他のものを挿入する行く。 308 00:22:24,000 --> 00:22:29,000 >> 私たちは誰か他の何かを挿入したい場合は、スタックのバージョンのために何をした 309 00:22:29,000 --> 00:22:36,000 私たちは私たちの記憶のブロックを拡張されています。 310 00:22:36,000 --> 00:22:40,000 この場合の問題は何ですか？ 311 00:22:40,000 --> 00:22:45,000 [学生]あなたは2点を移動します。 312 00:22:45,000 --> 00:22:51,000 私はキューの終わりについての前に言ったことを、 313 00:22:51,000 --> 00:22:57,000 これは、我々は1から始まっていることには意味がありません 314 00:22:57,000 --> 00:23:01,000 その後、我々はその後、デキュー3、デキュー4、デキュー1にしたい 315 00:23:01,000 --> 00:23:05,000 デキュー2であれば、このいずれかをデキューします。 316 00:23:05,000 --> 00:23:08,000 我々は今、reallocを使用することはできません、 317 00:23:08,000 --> 00:23:11,000 または非常に少なくとも、あなたは別の方法でreallocを使用する必要があります。 318 00:23:11,000 --> 00:23:15,000 しかし、あなたはおそらくちょうどreallocを使うべきではありません。 319 00:23:15,000 --> 00:23:18,000 あなたのメモリを手動でコピーする必要があるとしている。 320 00:23:18,000 --> 00:23:21,000 >> メモリをコピーするには、2つの関数があります。 321 00:23:21,000 --> 00:23:25,000 memcopyとmemmove関数があります。 322 00:23:25,000 --> 00:23:29,000 私は現在あなたが使用するつもりだどれ見てmanページを読んでいます。 323 00:23:29,000 --> 00:23:35,000 さて、memcopy、違いがある 324 00:23:35,000 --> 00:23:38,000 memcopyとmemmove関数、1は正しく事件を処理すること 325 00:23:38,000 --> 00:23:41,000 あなたは、この地域に重なるように起こる領域にコピーしている場所 326 00:23:41,000 --> 00:23:46,000 あなたからコピーしている。 327 00:23:46,000 --> 00:23:50,000 Memcopyはそれを処理しません。 memmove関数はありません。 328 00:23:50,000 --> 00:23:59,000 あなたは、問題を考えることができます 329 00:23:59,000 --> 00:24:09,000 みましょう、私はこの男をコピーしたいと言う 330 00:24:09,000 --> 00:24:13,000 この男の上に、これらの4つ。 331 00:24:13,000 --> 00:24:16,000 結局、何の配列は次のようになります。 332 00:24:16,000 --> 00:24:26,000 コピーはその後、2、1、2、1、3、4、最後にいくつかのものになった後。 333 00:24:26,000 --> 00:24:29,000 しかし、これは、我々が実際にコピーされる順序に依存しています 334 00:24:29,000 --> 00:24:32,000 我々は、我々は地域にコピーしているという事実を考慮していない場合導入 335 00:24:32,000 --> 00:24:35,000 重なっている我々からコピーしている1、 336 00:24:35,000 --> 00:24:46,000 次に我々は、ここから始めて、私たちが行きたい場所に2をコピーするようにするかもしれない 337 00:24:46,000 --> 00:24:52,000 その後、前方に私達のポインターを移動します。 338 00:24:52,000 --> 00:24:56,000 >> 今、私たちは、こことここにあることを行っている、そして今我々は、コピーしたい 339 00:24:56,000 --> 00:25:04,000 このこの男以上の男とは、我々のポインタを移動します。 340 00:25:04,000 --> 00:25:07,000 我々が得ることを終えるつもりだと、2、1、2、1、2、1である 341 00:25:07,000 --> 00:25:10,000 代わりに適切な2、1、2、1、3、4の理由 342 00:25:10,000 --> 00:25:15,000 2、1、元の3,4を覆した。 343 00:25:15,000 --> 00:25:19,000 memmove関数は正しくそれを処理します。 344 00:25:19,000 --> 00:25:23,000 この場合、基本的には常にmemmove関数を使用 345 00:25:23,000 --> 00:25:26,000 それはそれを正しく処理しないため。 346 00:25:26,000 --> 00:25:29,000 これは、一般的に任意の悪化を実行しません。 347 00:25:29,000 --> 00:25:32,000 アイデアは最初から開始し、この方法でコピーするのではなく、ある 348 00:25:32,000 --> 00:25:35,000 私達はちょうどここにやったように、それは、終わりから始まり、でコピー 349 00:25:35,000 --> 00:25:38,000 その場合には、問題を持っていることはありません。 350 00:25:38,000 --> 00:25:40,000 何のパフォーマンスが失われることはありません。 351 00:25:40,000 --> 00:25:47,000 常にmemmove関数を使用します。 memcopy心配はありません。 352 00:25:47,000 --> 00:25:51,000 あなたが別々にmemmove関数する必要があるとしている場所、それはだ 353 00:25:51,000 --> 00:26:01,000 あなたのキューのラップアラウンド部分。 354 00:26:01,000 --> 00:26:04,000 心配しないで完全に行われていない場合。 355 00:26:04,000 --> 00:26:10,000 これは、スタック、プッシュ、およびポップよりも困難である。 356 00:26:10,000 --> 00:26:15,000 >> 誰もが私たちが働くことができる、任意のコードをお持ちですか？ 357 00:26:15,000 --> 00:26:21,000 でも、完全に不完全な場合？ 358 00:26:21,000 --> 00:26:23,000 [学生]ええ、それはしかし、完全に不完全です。 359 00:26:23,000 --> 00:26:27,000 我々は、することができますあなたがリビジョンを保存すると、完全に不完全な限り、罰金ですか？ 360 00:26:27,000 --> 00:26:32,000 私は毎回忘れる。 361 00:26:32,000 --> 00:26:39,000 さて、我々は物事のサイズを変更する必要があるときに何が起こるか無視。 362 00:26:39,000 --> 00:26:42,000 完全にサイズ変更を無視します。 363 00:26:42,000 --> 00:26:49,000 このコードを説明する。 364 00:26:49,000 --> 00:26:54,000 サイズはすべての最初のコピー未満である場合、私はまず第一にチェックしている 365 00:26:54,000 --> 00:27:01,000 し、その後、私は、頭+サイズを取る私は挿入し 366 00:27:01,000 --> 00:27:05,000 と私はそれは、アレイの容量を包み込むことを確認してください 367 00:27:05,000 --> 00:27:08,000 と私は、その位置に新しい文字列を挿入します。 368 00:27:08,000 --> 00:27:12,000 それから私は、サイズを大きくして、trueを返します。 369 00:27:12,000 --> 00:27:22,000 >> [ロブB.]これは間違いなくあなたはMODを使用したいとしているような事例の1つです。 370 00:27:22,000 --> 00:27:25,000 あなたの周りの折り返しと思われる場合は、ラップアラウンドした例あらゆる種類の、 371 00:27:25,000 --> 00:27:29,000 即時の思考はmodにする必要があります。 372 00:27:29,000 --> 00:27:36,000 迅速な最適化/あなたのコード1行を短くする、など 373 00:27:36,000 --> 00:27:42,000 あなたは、その行が直ちにこれを次のことに注意してください 374 00:27:42,000 --> 00:27:53,000 ジャストサイズです+ +ので​​、あなたは、このラインにマージされ、大きさ+ +。 375 00:27:53,000 --> 00:27:58,000 ダウンここに今、私たちはケースを持っている 376 00:27:58,000 --> 00:28:01,000 我々は十分なメモリがない場合には、 377 00:28:01,000 --> 00:28:05,000 ので、我々は2によって我々の能力を高めています。 378 00:28:05,000 --> 00:28:09,000 、私はあなたがここに同じ問題を抱えていることができると思いますが、我々は今それを無視することができます 379 00:28:09,000 --> 00:28:13,000 あなたの能力を高めるために失敗した場所ならば、 380 00:28:13,000 --> 00:28:18,000 その後、再び2であなたの能力を減少させるためにするつもりだ。 381 00:28:18,000 --> 00:28:24,000 別の短いノートはあなたがすることができるだけのようです+ = 382 00:28:24,000 --> 00:28:30,000 あなたはまた、<< =を行うことができます。 383 00:28:30,000 --> 00:28:43,000 等しい前に行くことができますほとんど何も、+ =、| =、＆=、<< =。 384 00:28:43,000 --> 00:28:52,000 char *の新しいメモリの私達の新しいブロックです。 385 00:28:52,000 --> 00:28:55,000 ああ、こっちに。 386 00:28:55,000 --> 00:29:02,000 >> 人々はメモリの私達の新しいブロックの型についてどう思いますか？ 387 00:29:02,000 --> 00:29:06,000 [学生]それはchar **であるべきである。 388 00:29:06,000 --> 00:29:12,000 ここまで我々の構造体に戻って考えると、 389 00:29:12,000 --> 00:29:14,000 文字列は、我々は再配分しているものである。 390 00:29:14,000 --> 00:29:21,000 我々は、キュー内の要素のための全体の新しい動的なストレージを作っている。 391 00:29:21,000 --> 00:29:25,000 私たちはあなたの文字列に代入することになるだろうと、申し訳mallocingているものです 392 00:29:25,000 --> 00:29:30,000 ますので、新たにはchar **になるだろう。 393 00:29:30,000 --> 00:29:34,000 これは、文字列の配列になるだろう。 394 00:29:34,000 --> 00:29:38,000 その後、我々は、falseを返すようになるだろうその下のケースは何ですか？ 395 00:29:38,000 --> 00:29:41,000 [学生]は、我々はchar *をやるべき？ 396 00:29:41,000 --> 00:29:44,000 [ロブB.]はい、良いコール。 397 00:29:44,000 --> 00:29:46,000 [学生]あれは何だ？ 398 00:29:46,000 --> 00:29:49,000 [ロブB.]我々は、もはや、いないので、我々は、char *のサイズをやってみたかった 399 00:29:49,000 --> 00:29:53,000 はsizeof（char型）が1になるので、これは実際には非常に大きな問題であろう。 400 00:29:53,000 --> 00:29:55,000 sizeof演算のchar * 4であることを行っている、 401 00:29:55,000 --> 00:29:58,000 ので、int型を扱っている多くの時間、 402 00:29:58,000 --> 00:30:01,000 あなたはintとint *のサイズのためサイズ離れてそれを取得する傾向がある 403 00:30:01,000 --> 00:30:04,000 32ビットシステムでも同じことになるだろうしている。 404 00:30:04,000 --> 00:30:09,000 しかし、ここでは、sizeof（char）をsizeofは（char *）は今、同じことになるだろうしている。 405 00:30:09,000 --> 00:30:15,000 >> 我々はfalseを返すような状況は何ですか？ 406 00:30:15,000 --> 00:30:17,000 [学生]新規はnullになります。 407 00:30:17,000 --> 00:30:23,000 新しいがnullの場合、ええ、我々は、falseを返す 408 00:30:23,000 --> 00:30:34,000 と私はスローダウンするつもりヒア 409 00:30:34,000 --> 00:30:37,000 [学生] [聞こえない] 410 00:30:37,000 --> 00:30:39,000 [ロブB.]うん、これは結構です。 411 00:30:39,000 --> 00:30:46,000 いずれか2倍の容量、または容量シフト1を実行してからここだけか何かそれを下に設定することができます。 412 00:30:46,000 --> 00:30:52,000 我々はそれを持っていたとして、我々はそれをやる。 413 00:30:52,000 --> 00:30:56,000 能力>> = 1。 414 00:30:56,000 --> 00:31:08,000 そして、あなたは1の地位を失うことを心配する必要がありますするつもりはありませんしている 415 00:31:08,000 --> 00:31:12,000 あなたは1だけ左シフトするので、とても1の場所は、必ずしも0である 416 00:31:12,000 --> 00:31:16,000 そう1だけ右シフト、あなたはまだ細かいことになるだろう。 417 00:31:16,000 --> 00:31:19,000 [学生]はリターンの前にそれを行う必要がありますか？ 418 00:31:19,000 --> 00:31:29,000 [ロブB.]はい、これは全く意味がありません。 419 00:31:29,000 --> 00:31:36,000 >> さて、最後にtrueを返す羽目になるだろうと仮定します。 420 00:31:36,000 --> 00:31:39,000 我々はこれらのmemmovesをやろうとしている方法、 421 00:31:39,000 --> 00:31:45,000 我々はそれらを行う方法に注意する必要があります。 422 00:31:45,000 --> 00:31:50,000 誰も我々はそれを行う方法についてどんな提案を持っていますか？ 423 00:32:17,000 --> 00:32:21,000 ここに我々のスタートだ。 424 00:32:21,000 --> 00:32:28,000 必然的に、我々は再び先頭から開始したい 425 00:32:28,000 --> 00:32:35,000 そこから内とコピーもの、1、3、4、2。 426 00:32:35,000 --> 00:32:41,000 どのようにすればよいでしょうか？ 427 00:32:41,000 --> 00:32:52,000 まず、私は再びmemmove関数のmanページを見ている。 428 00:32:52,000 --> 00:32:57,000 memmove関数は、引数の順序は常に重要です。 429 00:32:57,000 --> 00:33:01,000 私達は私達の目的地は、まずソース第二、第三の大きさが欲しい。 430 00:33:01,000 --> 00:33:06,000 ソースとデスティネーションを反転機能がたくさんあり​​ます。 431 00:33:06,000 --> 00:33:11,000 宛先、送信元は、やや一貫性になる傾向がある。 432 00:33:17,000 --> 00:33:21,000 それが何を返して、​​移動しますか？ 433 00:33:21,000 --> 00:33:27,000 それはあなたがすることを望むかもしれませんどのような理由であれ、目的地へのポインタを返します。 434 00:33:27,000 --> 00:33:32,000 私はそれを読むことができる絵が、我々は我々の目的地に移動したい。 435 00:33:32,000 --> 00:33:35,000 >> 私たちの目的地は何をされようとしている？ 436 00:33:35,000 --> 00:33:37,000 [学生]新。 437 00:33:37,000 --> 00:33:39,000 [ロブB.]はい、我々はどこからコピーされますか？ 438 00:33:39,000 --> 00:33:43,000 我々がコピーしている最初のものは、この1、図3、図4である。 439 00:33:43,000 --> 00:33:50,000 - この1、3、4とは何ですか。 440 00:33:50,000 --> 00:33:55,000 この1のアドレスは何ですか？ 441 00:33:55,000 --> 00:33:58,000 その1のアドレスは何ですか？ 442 00:33:58,000 --> 00:34:01,000 [学生] [聞こえない] 443 00:34:01,000 --> 00:34:03,000 [ロブB.]ヘッド+最初の要素のアドレス。 444 00:34:03,000 --> 00:34:05,000 どのように我々は配列の最初の要素を取得するのですか？ 445 00:34:05,000 --> 00:34:10,000 [学生]キュー。 446 00:34:10,000 --> 00:34:15,000 [ロブB.]はい、q.strings。 447 00:34:15,000 --> 00:34:20,000 覚えておいて、ここに、私たちの頭は、1です。 448 00:34:20,000 --> 00:34:24,000 それをかがる。私はちょうどそれは魔法のようだと思う - 449 00:34:24,000 --> 00:34:29,000 ここでは、私たちの頭は、1です。私はあまりにも私の色を変更するつもりです。 450 00:34:29,000 --> 00:34:36,000 そして、ここに文字列です。 451 00:34:36,000 --> 00:34:41,000 私たちはこっちに行ったようにこれは、我々はどちらかそれを書くことができます 452 00:34:41,000 --> 00:34:43,000 と頭+ q.strings。 453 00:34:43,000 --> 00:34:51,000 多くの人々はまた、それを書いて、＆q.strings [頭]。 454 00:34:51,000 --> 00:34:55,000 これは本当に任意の少ない効率的ではありません。 455 00:34:55,000 --> 00:34:58,000 あなたは、あなたがそれをデリファレンスした後のアドレスを取得していると考えるかもしれません 456 00:34:58,000 --> 00:35:04,000 しかし、コンパイラは、我々はとにかく、q.strings +ヘッドの前に持っていたものにそれを翻訳しようとしている。 457 00:35:04,000 --> 00:35:06,000 あなたはそれを考えたくいずれかの方法。 458 00:35:06,000 --> 00:35:11,000 >> そして、どのように多くのバイトたちがコピーしたいのですか？ 459 00:35:11,000 --> 00:35:15,000 [学生]容量 - 頭。 460 00:35:15,000 --> 00:35:18,000 容量 - 頭。 461 00:35:18,000 --> 00:35:21,000 そしてあなたはいつも例を書き出すことが可能 462 00:35:21,000 --> 00:35:23,000 そうですかどうかを把握する。 463 00:35:23,000 --> 00:35:26,000 [学生]それはその後、2で割ったする必要があります。 464 00:35:26,000 --> 00:35:30,000 うん、だから私たちはサイズを使用できると思います。 465 00:35:30,000 --> 00:35:35,000 我々はまだ大きさを持っている - 466 00:35:35,000 --> 00:35:39,000 サイズを使用して、我々は4に等しい大きさを有する。 467 00:35:39,000 --> 00:35:42,000 私たちのサイズは4です。私たちの頭は、1です。 468 00:35:42,000 --> 00:35:46,000 我々は、これらの3つの要素をコピーしたい。 469 00:35:46,000 --> 00:35:54,000 その正気は、そのサイズをチェックしている - 頭は正常に3です。 470 00:35:54,000 --> 00:35:58,000 我々は前に言ったように、ここに戻ってくる 471 00:35:58,000 --> 00:36:00,000 我々が能力を使用した場合は、次に我々は2で割る必要があるだろう 472 00:36:00,000 --> 00:36:04,000 我々はすでに我々の能力を成長させてきたので、その代わりに、我々はサイズを使用するつもりです。 473 00:36:11,000 --> 00:36:13,000 そのコピーした部分。 474 00:36:13,000 --> 00:36:18,000 今、私たちは、他の部分は、開始の残っている部分をコピーする必要があります。 475 00:36:18,000 --> 00:36:28,000 >> それはどのような位置にmemmove関数になるだろう？ 476 00:36:28,000 --> 00:36:32,000 [学生]プラスサイズ - 頭。 477 00:36:32,000 --> 00:36:38,000 はい、私たちは既にサイズでコピーした - 頭バイトを、 478 00:36:38,000 --> 00:36:43,000 それで我々は残りのバイトをコピーすることは新しいです 479 00:36:43,000 --> 00:36:48,000 その後サイズがマイナスでなく、バ​​イト数は、我々はすでにインチコピーした 480 00:36:48,000 --> 00:36:52,000 そして、私たちはどこからコピーされますか？ 481 00:36:52,000 --> 00:36:54,000 [学生] Q.strings [0]。 482 00:36:54,000 --> 00:36:56,000 [ロブB.]はい、q.strings。 483 00:36:56,000 --> 00:37:02,000 我々は、いずれか＆q.strings [0]を行うことができます。 484 00:37:02,000 --> 00:37:05,000 これは、これより大幅に少ないのが一般的です。 485 00:37:05,000 --> 00:37:14,000 それがちょうど0になるだろう場合は、q.stringsを見る傾向があるでしょう。 486 00:37:14,000 --> 00:37:16,000 我々はコピー元の場所です。 487 00:37:16,000 --> 00:37:18,000 我々は、コピーする方法を多くのバイトを残しているのですか？>> [学生] 10。 488 00:37:18,000 --> 00:37:20,000 右。 489 00:37:20,000 --> 00:37:25,000 [学生]我々は5を掛けなければなりませんか - バイトか何かの10倍？ 490 00:37:25,000 --> 00:37:30,000 うん、これはどこに - まさに我々がコピーしているのですか？ 491 00:37:30,000 --> 00:37:32,000 [学生] [聞こえない] 492 00:37:32,000 --> 00:37:34,000 我々がコピーしているものの種類は何ですか？ 493 00:37:34,000 --> 00:37:36,000 [学生] [聞こえない] 494 00:37:36,000 --> 00:37:41,000 それらがどこから来ているうん、char *で、我々がコピーしているように、我々は知らない。 495 00:37:41,000 --> 00:37:47,000 まあ、それが指している場所に、文字列のように、我々は、キューにプッシュ終わる 496 00:37:47,000 --> 00:37:49,000 またはキューにエンキューする。 497 00:37:49,000 --> 00:37:51,000 それらがどこから来ている、私たちにはわかりません。 498 00:37:51,000 --> 00:37:56,000 我々だけではchar * sの自分自身を追跡する必要があります。 499 00:37:56,000 --> 00:38:00,000 ヘッドバイト - 我々は、サイズをコピーしたくない。 500 00:38:00,000 --> 00:38:03,000 頭のchar * sを - 私たちは、サイズをコピーしたい 501 00:38:03,000 --> 00:38:11,000 ので、我々は、sizeof（char型の*）で、これを掛けるつもりです。 502 00:38:11,000 --> 00:38:17,000 同じダウンここで、ヘッド* sizeof（char *）は。 503 00:38:17,000 --> 00:38:24,000 >> [学生]何について[聞こえない]？ 504 00:38:24,000 --> 00:38:26,000 ここでこの権利は？ 505 00:38:26,000 --> 00:38:28,000 頭 - いや、大きさ、その下の[生徒]。 506 00:38:28,000 --> 00:38:30,000 [ロブB.]ここにこの権利は？ 507 00:38:30,000 --> 00:38:32,000 ポインタ演算。 508 00:38:32,000 --> 00:38:35,000 どのようにポインタ演算は、仕事に行くのです 509 00:38:35,000 --> 00:38:40,000 それは自動的に我々が扱っている型のサイズで乗算します。 510 00:38:40,000 --> 00:38:46,000 ただ、こっちのような新しい+（サイズ - ヘッド） 511 00:38:46,000 --> 00:38:56,000 ＆新しい[ - 頭サイズ]とまったく同じです 512 00:38:56,000 --> 00:39:00,000 我々は、正しく動作することを期待されるまで、 513 00:39:00,000 --> 00:39:04,000 我々はint配列を扱っている場合ので、次に我々は、int-によってインデックスしない 514 00:39:04,000 --> 00:39:07,000 に、またはそれが5の大きさだし、第四の要素が必要な場合は、我々は、インデックス 515 00:39:07,000 --> 00:39:10,000 int型の配列[4]。 516 00:39:10,000 --> 00:39:14,000 あなたドント·[4] int型のサイズ*。 517 00:39:14,000 --> 00:39:21,000 つまり、それを自動的に処理し、この場合 518 00:39:21,000 --> 00:39:29,000 文字通り同等なので、ブラケット構文 519 00:39:29,000 --> 00:39:34,000 ただできるだけ早くあなたがコンパイルしたときにこれに変換されようとしている。 520 00:39:34,000 --> 00:39:38,000 それはあなたがそのように注意する必要があることです 521 00:39:38,000 --> 00:39:42,000 あなたのサイズを追加している - 頭 522 00:39:42,000 --> 00:39:45,000 あなたは、1バイトではありませんが追加されています。 523 00:39:45,000 --> 00:39:53,000 あなたは、1バイトまたは任意に指定することが可能です1 char *を、追加している。 524 00:39:53,000 --> 00:39:56,000 >> その他の質問は？ 525 00:39:56,000 --> 00:40:04,000 さて、デキューが容易になるだろう。 526 00:40:04,000 --> 00:40:11,000 私はあなたに実装するための分を与えるでしょう。 527 00:40:11,000 --> 00:40:18,000 ああ、私は、これは同じような状況だと思いますどこに 528 00:40:18,000 --> 00:40:21,000 何エンキュー場合、我々は、nullをエンキューしている場合、 529 00:40:21,000 --> 00:40:24,000 多分私達はそれを処理したい場合は、おそらく我々にはありません。 530 00:40:24,000 --> 00:40:27,000 我々はここで再びそれを行うが、我々のスタックケースと同じではありません。 531 00:40:27,000 --> 00:40:34,000 私たちがヌルをエンキューした場合、我々はそれを無視したい場合があります。 532 00:40:34,000 --> 00:40:40,000 誰も私がアップすることができますいくつかのコードをお持ちですか？ 533 00:40:40,000 --> 00:40:45,000 [学生]私はちょうどデキューを持っています。 534 00:40:45,000 --> 00:40:56,000 バージョン2は、可もなく不可もなくです。 535 00:40:56,000 --> 00:40:59,000 あなたが説明したいと思います？ 536 00:40:59,000 --> 00:41:01,000 [学生]はまず、キューに何かがあることを確認してください 537 00:41:01,000 --> 00:41:07,000 とサイズが1ずつ下がっていることを確認します。 538 00:41:07,000 --> 00:41:11,000 あなたはそれを行う必要があり、その後、頭を返す 539 00:41:11,000 --> 00:41:13,000 その後1ヘッドアップを移動します。 540 00:41:13,000 --> 00:41:19,000 わかりましたので、我々が考慮しなければならないコーナーケースがあります。うん。 541 00:41:19,000 --> 00:41:24,000 [生徒]、あなたの頭は、最後の要素である場合 542 00:41:24,000 --> 00:41:26,000 その後は頭が配列の外を指すようにしたくない。 543 00:41:26,000 --> 00:41:29,000 >> ええ、そうとすぐヘッドとしては、我々の配列の最後に行き着く 544 00:41:29,000 --> 00:41:35,000 我々はデキュー時、私たちの頭は0に戻ってモッドされるべきである。 545 00:41:35,000 --> 00:41:40,000 残念なことに、我々は1つのステップでそれを行うことはできません。 546 00:41:40,000 --> 00:41:44,000 私はおそらくそれが解決すると思い方法を推測する 547 00:41:44,000 --> 00:41:52,000 これは、我々は戻っているのか、char *であることを行っている 548 00:41:52,000 --> 00:41:55,000 何でもあなたの変数名にはなりたがっている。 549 00:41:55,000 --> 00:42:02,000 その後、我々は我々の能力で頭をmodにしたい 550 00:42:02,000 --> 00:42:10,000 その後retに返します。 551 00:42:10,000 --> 00:42:14,000 ここで、彼らは可能性があります多くの人がdo- 552 00:42:14,000 --> 00:42:19,000 この場合はヘッドの人が何を参照してください - you'llのケースです 553 00:42:19,000 --> 00:42:29,000 容量 - 容量よりも大きい場合には、頭部を行う。 554 00:42:29,000 --> 00:42:36,000 そして、それは単にMODが何であるかを周りに取り組んでいる。 555 00:42:36,000 --> 00:42:41,000 ヘッドMOD =容量ははるかにきれいです 556 00:42:41,000 --> 00:42:51,000 容量 - 容量の頭よりも大きい場合に比べて頭の周りにラッピング。 557 00:42:51,000 --> 00:42:56,000 >> 質問はありますか？ 558 00:42:56,000 --> 00:43:02,000 さて、私たちが残っている最後のことは、私たちのリンクリストです。 559 00:43:02,000 --> 00:43:07,000 あなたがした場合は、リンクされたリストの動作の一部に使用されるかもしれない 560 00:43:07,000 --> 00:43:11,000 あなたはハッシュテーブルをしなかった場合、あなたのハッシュテーブル内のリストをリンクしました。 561 00:43:11,000 --> 00:43:15,000 私は強く、ハッシュテーブルを行うことをお勧め。 562 00:43:15,000 --> 00:43:17,000 あなたは既にトライを行っている可能性があり、 563 00:43:17,000 --> 00:43:23,000 しかし、トライは、より難しいものになります。 564 00:43:23,000 --> 00:43:27,000 理論的には、彼らは、漸近的に優れている。 565 00:43:27,000 --> 00:43:30,000 しかし、ちょうど、大きなボードを見れ 566 00:43:30,000 --> 00:43:35,000 とうまくやることはありませんしようとし、彼らはより多くのメモリを取る。 567 00:43:35,000 --> 00:43:43,000 試みについてのすべては、より多くの仕事のために悪くなってしまう。 568 00:43:43,000 --> 00:43:49,000 それはデビッドマランのソリューションは常にあるものだ 569 00:43:49,000 --> 00:43:56,000 彼は常に彼のポストトライソリューションであり、彼は現在の場所を確認してみましょう。 570 00:43:56,000 --> 00:44:00,000 デビッド·J、彼の下には何でしたか？ 571 00:44:00,000 --> 00:44:06,000 彼は第18位ですが、、それはひどく悪くはありませんので、 572 00:44:06,000 --> 00:44:09,000 そしてそれはあなたが考えることができる最高の試行の一つになるだろう 573 00:44:09,000 --> 00:44:17,000 トライの最高の試みの一つであるかを判断する。 574 00:44:17,000 --> 00:44:23,000 それも彼の元の解決策ではありません？ 575 00:44:23,000 --> 00:44:29,000 トライソリューションはRAMの使用量がこの範囲でより多くなる傾向があるような気がします。 576 00:44:29,000 --> 00:44:33,000 >> 一番上に行けば、RAMの使用率が一桁台になっています。 577 00:44:33,000 --> 00:44:36,000 底部に向かって行けば、その後は見て起動しようとし 578 00:44:36,000 --> 00:44:41,000 あなたが絶対に大規模なRAMの使用状況を取得する場所、 579 00:44:41,000 --> 00:44:45,000 とトライは、より難しいものになります。 580 00:44:45,000 --> 00:44:53,000 あなたは1をやっていない、完全にそれが、教育経験の価値があれば。 581 00:44:53,000 --> 00:44:56,000 最後のものは、私たちのリンクリストです 582 00:44:56,000 --> 00:45:04,000 そして、これらの3つの事、スタック、キュー、連結リスト、 583 00:45:04,000 --> 00:45:09,000 あなたがこれまでにコンピュータ·サイエンスで行う任意の将来の事 584 00:45:09,000 --> 00:45:12,000 あなたがこれらの事に精通していると仮定します。 585 00:45:12,000 --> 00:45:19,000 彼らはすべてにちょうどそう基本です。 586 00:45:19,000 --> 00:45:25,000 >> リンクされたリストが、ここではシングルリンクリストを持っているが、我々の実装であることを行っている。 587 00:45:25,000 --> 00:45:34,000 単独で何がリンクされないように二重にリンクされたとは対照的にどういう意味ですか？はい。 588 00:45:34,000 --> 00:45:37,000 [学生]それだけで、次のポインタではなくポインタをポイントする 589 00:45:37,000 --> 00:45:39,000 それとその後ろの1に先行するもののような。 590 00:45:39,000 --> 00:45:44,000 ええ、そう画像形式で、私はちょうど何をしましたか？ 591 00:45:44,000 --> 00:45:48,000 私は二つのものを持っている。私は絵や写真を持っています。 592 00:45:48,000 --> 00:45:51,000 画像形式では、私たちの単一リンクリスト、 593 00:45:51,000 --> 00:45:57,000 必然的に、私達は私達のリストの先頭へのポインタのいくつかの種類がある 594 00:45:57,000 --> 00:46:02,000 その後私たちのリストの中で、我々だけで、ポインタを持ってい 595 00:46:02,000 --> 00:46:05,000 そして多分この点はnullになります。 596 00:46:05,000 --> 00:46:08,000 それは、片方向リンクリストのあなたの典型的な描画になるだろう。 597 00:46:08,000 --> 00:46:14,000 二重連結リストには、後方に行くことができます。 598 00:46:14,000 --> 00:46:19,000 私はあなたに、リスト内の任意のノードを与える場合は、必然的にするために得ることができる 599 00:46:19,000 --> 00:46:23,000 リスト内の他のノードには、双方向リンクリストである場合。 600 00:46:23,000 --> 00:46:27,000 しかし、私はあなたのリストの3番目のノードを取得し、それは、片方向リンクリストの場合には、 601 00:46:27,000 --> 00:46:30,000 あなたがこれまでに第1および第2のノードに得ようとしている。方法はありません 602 00:46:30,000 --> 00:46:34,000 と利点と不利益、一つ明らかなものはあり 603 00:46:34,000 --> 00:46:42,000 あなたがより多くのサイズを取るです、あなたはこれらの事が今指している場所を追跡する必要があります。 604 00:46:42,000 --> 00:46:49,000 しかし、我々は唯一の単一リンクを気遣う。 605 00:46:49,000 --> 00:46:53,000 >> 私たちが実装する必要があるとしているいくつかのこと。 606 00:46:53,000 --> 00:47:00,000 あなたのtypedef structのノードは、int I：構造体のノード*次回、ノード。 607 00:47:00,000 --> 00:47:09,000 そのtypedefはあなたの心に焼き付けなければならない。 608 00:47:09,000 --> 00:47:14,000 クイズ1は、リンクリストノードのtypedefを与えるようにすべきである 609 00:47:14,000 --> 00:47:18,000 と、すぐにその走り書きすることができるはずです 610 00:47:18,000 --> 00:47:22,000 それについて何も考えずに。 611 00:47:22,000 --> 00:47:27,000 私はいくつかの質問を推測、なぜ我々はここで構造体が必要なのですか？ 612 00:47:27,000 --> 00:47:32,000 なぜ我々はノード*を言うことができないのですか？ 613 00:47:32,000 --> 00:47:35,000 [学生] [聞こえない] 614 00:47:35,000 --> 00:47:38,000 うん。 615 00:47:38,000 --> 00:47:44,000 ものとしてのノードを定義する唯一のもの 616 00:47:44,000 --> 00:47:47,000 自体typedefです。 617 00:47:47,000 --> 00:47:55,000 しかし、この点のように、我々は、この構造体のノード定義を介して解析の一種でいるときに、 618 00:47:55,000 --> 00:48:01,000 我々は、typedefが完了していないのでので、まだ私たちのtypedefを完了していない 619 00:48:01,000 --> 00:48:05,000 ノードが存在しません。 620 00:48:05,000 --> 00:48:12,000 しかし、構造体ノードはありませんし、ここでこのノード、 621 00:48:12,000 --> 00:48:14,000 これも何かを呼び出すことができます。 622 00:48:14,000 --> 00:48:16,000 これは、nと呼ばれるかもしれない。 623 00:48:16,000 --> 00:48:19,000 これは、リンクされたリストのノードと呼ばれることもあります。 624 00:48:19,000 --> 00:48:21,000 それは何かを呼び出すことができます。 625 00:48:21,000 --> 00:48:26,000 しかし、この構造体のノードは、この構造体のノードと同じものを呼び出す必要があります。 626 00:48:26,000 --> 00:48:29,000 あなたは、これがまたここに持って呼んでいるもの、 627 00:48:29,000 --> 00:48:32,000 となるように、質問の2つ目のポイントに答える 628 00:48:32,000 --> 00:48:37,000 なぜ、あなたは、構造体と構造体のtypedefを参照してください多くの時間、それはある 629 00:48:37,000 --> 00:48:42,000 あなたはあなただけのtypedef structをわかり無名の構造体を参照してくださいよ、 630 00:48:42,000 --> 00:48:47,000 構造体、ディクショナリ、または任意の実装。 631 00:48:47,000 --> 00:48:51,000 >> なぜここでは、ノードを言う必要があるのですか？ 632 00:48:51,000 --> 00:48:54,000 なぜそれが匿名の構造体でなければできないのですか？ 633 00:48:54,000 --> 00:48:56,000 これは、ほぼ同じ答えだ。 634 00:48:56,000 --> 00:48:58,000 [学生]あなたは構造体の中にそれを参照する必要があります。 635 00:48:58,000 --> 00:49:04,000 うん、構造体の中には、構造体自体を参照する必要があります。 636 00:49:04,000 --> 00:49:10,000 あなたは構造体に名前を与えていない場合は、匿名構造体の場合は、、あなたはそれを参照することはできません。 637 00:49:10,000 --> 00:49:17,000 と最後のではなく、少なくとも、これらはすべて、幾分簡単であるべきです 638 00:49:17,000 --> 00:49:20,000 あなたがこれをダウンして書いている場合、彼らはあなたが実現することを助けるべき 639 00:49:20,000 --> 00:49:24,000 このようなことは意味をなさない場合は、何か間違ったことをやっている。 640 00:49:24,000 --> 00:49:28,000 最後になりましたが、なぜこれが*構造体ノードである必要はありますか？ 641 00:49:28,000 --> 00:49:34,000 なぜそれだけで次のノードを構造体でなければできないのですか？ 642 00:49:34,000 --> 00:49:37,000 [学生]次の構造体へのポインタ。 643 00:49:37,000 --> 00:49:39,000 それは我々が望むものを必然的だ。 644 00:49:39,000 --> 00:49:42,000 なぜそれが次の構造体ノードとなることができませんでした？ 645 00:49:42,000 --> 00:49:50,000 なぜそれが*次の構造体ノードである必要はありますか？うん。 646 00:49:50,000 --> 00:49:53,000 [学生]それは無限ループのようなものだ。 647 00:49:53,000 --> 00:49:55,000 うん。 648 00:49:55,000 --> 00:49:57,000 [学生]それはすべて1になります。 649 00:49:57,000 --> 00:50:02,000 うん、ちょうど私達がの大きさや何かをするだろうかを考える。 650 00:50:02,000 --> 00:50:08,000 構造体自体のサイズは、基本的には+または - ここまたはそこにいくつかのパターン。 651 00:50:08,000 --> 00:50:15,000 それは基本的に構造体の中のものの大きさの和になるだろう。 652 00:50:15,000 --> 00:50:18,000 ここでこの権利は、何も変更せずに、サイズが容易になるだろう。 653 00:50:18,000 --> 00:50:24,000 構造ノードのサイズは、次のi +サイズの大きさになるだろう。 654 00:50:24,000 --> 00:50:27,000 私のサイズは4であることを行っている。次回のサイズは4であることを行っている。 655 00:50:27,000 --> 00:50:30,000 構造ノードのサイズは8になるだろう。 656 00:50:30,000 --> 00:50:34,000 私たちは*、sizeofの思考を持っていない場合、 657 00:50:34,000 --> 00:50:37,000 その後はsizeof（i）が4になるだろう。 658 00:50:37,000 --> 00:50:43,000 次の構造体ノードのサイズは、iの大きさになるだろう+次のstructノードのサイズを 659 00:50:43,000 --> 00:50:46,000 iの+サイズ+次のstructノードのサイズ。 660 00:50:46,000 --> 00:50:55,000 これは、ノードの無限再帰になる。 661 00:50:55,000 --> 00:51:00,000 これは物事がなければならない方法である理由です。 662 00:51:00,000 --> 00:51:03,000 >> 繰り返しになりますが、間違いなく、それを暗記する 663 00:51:03,000 --> 00:51:06,000 または少なくともあなたのことができるようにできるように、十分にそれを理解 664 00:51:06,000 --> 00:51:12,000 それがどのように見えるかを介して理由。 665 00:51:12,000 --> 00:51:14,000 私たちが実装するつもりだもの。 666 00:51:14,000 --> 00:51:18,000 の長さがあれば、リスト 667 00:51:18,000 --> 00:51:21,000 あなたはカンニングと周りに保つことができる 668 00:51:21,000 --> 00:51:24,000 グローバル長か何かが、我々はそれをするつもりはない。 669 00:51:24,000 --> 00:51:28,000 我々は、リストの長さをカウントするつもりだ。 670 00:51:28,000 --> 00:51:34,000 我々は含まれていた、それは基本的には検索のようなものだそう 671 00:51:34,000 --> 00:51:41,000 ので、この整数は、リンクされたリストに含まれているかどうかを確認するための整数のリンクリストを持っています。 672 00:51:41,000 --> 00:51:44,000 Prependはリストの先頭に挿入しようとしている。 673 00:51:44,000 --> 00:51:46,000 Appendは末尾に挿入しようとしている。 674 00:51:46,000 --> 00:51:53,000 Insert_sortedは、リスト内のソートされた位置に挿入しようとしている。 675 00:51:53,000 --> 00:52:01,000 Insert_sortedの種類は、prependを使ったことがないことを前提としていますか悪いかの方法で追加します。 676 00:52:01,000 --> 00:52:09,000 >> あなたが実装しようとしているときにinsert_sorted-Insert_sorted 677 00:52:09,000 --> 00:52:13,000 のが我々のリンクリストがあるとしましょう​​。 678 00:52:13,000 --> 00:52:18,000 これは、現在、5、4、2、のように見えるものです。 679 00:52:18,000 --> 00:52:24,000 私は、なるように長いリスト自体が既にソートされているように、3を挿入したい 680 00:52:24,000 --> 00:52:27,000 それは3が属する場所が簡単に見つかります。 681 00:52:27,000 --> 00:52:29,000 私は2から開始します。 682 00:52:29,000 --> 00:52:32,000 さて、3は2よりも大きいので、私は行き続けたい。 683 00:52:32,000 --> 00:52:35,000 ああ、4は大きすぎるので、私は3が2と4の間に入るようになるだろう知っている 684 00:52:35,000 --> 00:52:39,000 と私はポインタとすべてのものを修正する必要があります。 685 00:52:39,000 --> 00:52:43,000 しかし、我々は厳密にinsert_sorted使用しなかった場合、 686 00:52:43,000 --> 00:52:50,000 好き聞かせはちょうど、私は6を付加言う 687 00:52:50,000 --> 00:52:55,000 その後、私のリンクされたリストは、このなろうとしています。 688 00:52:55,000 --> 00:53:01,000 それが今では意味をなさないので、insert_sortedためには、あなただけと仮定することができ 689 00:53:01,000 --> 00:53:04,000 操作は存在していてもリストがソートされていること 690 00:53:04,000 --> 00:53:09,000 これは、それをソートしないことがあります、それはそれだ。 691 00:53:09,000 --> 00:53:20,000 それらは、実装する必要があるとしている主なものですので、参考にインサートを検索します。 692 00:53:20,000 --> 00:53:24,000 >> 今のところは、長さを実行する分を取ると、含まれています 693 00:53:24,000 --> 00:53:30,000 そしてそれらは比較的迅速でなければならない。 694 00:53:41,000 --> 00:53:48,000 閉店時間が近づいてますので、誰もが長さのために何を持っているか、含まれています？ 695 00:53:48,000 --> 00:53:50,000 彼らはほぼ同じことになるだろう。 696 00:53:50,000 --> 00:53:57,000 [学生]長さ。 697 00:53:57,000 --> 00:54:01,000 、見改訂してみましょう。 698 00:54:01,000 --> 00:54:04,000 オーケー。 699 00:54:12,000 --> 00:54:15,000 あなたが説明したいと思います？ 700 00:54:15,000 --> 00:54:21,000 [学生]私はただのポインタ·ノードを作成し、当社のグローバルな変数で、最初に初期化し、 701 00:54:21,000 --> 00:54:27,000 その後私はワンセグ障害を取得し、その場合は0が返されないようにそれがnullだかどうかを確認します。 702 00:54:27,000 --> 00:54:34,000 そうでなければ、私をループして、整数の中を追跡する 703 00:54:34,000 --> 00:54:38,000 何回私は、リストの次の要素にアクセスした 704 00:54:38,000 --> 00:54:43,000 と同じインクリメント操作でも、その実際の要素にアクセスする 705 00:54:43,000 --> 00:54:47,000 そして、私は継続的に、それがnullの場合は、チェックが見たい作る 706 00:54:47,000 --> 00:54:56,000 それがnullの場合には、それは中止され、ちょうど私がアクセスした要素数を返します。 707 00:54:56,000 --> 00:55:01,000 >> [ロブB.]誰が何についてのコメントを持っていますか？ 708 00:55:01,000 --> 00:55:06,000 これは賢明な細かい正確さに見えます。 709 00:55:06,000 --> 00:55:10,000 [学生]私はあなたがノード== nullを必要とは思わない。 710 00:55:10,000 --> 00:55:13,000 ええ、そうノード== nullの場合は0を返します。 711 00:55:13,000 --> 00:55:18,000 しかし、もしノード== nullの場合、この-OH、正しさの問題があります。 712 00:55:18,000 --> 00:55:23,000 それはちょうどあなたが私を返していたが、それは現在のスコープではありません。 713 00:55:23,000 --> 00:55:30,000 あなただけのint iを必要とするため、i = 0です。 714 00:55:30,000 --> 00:55:34,000 ノードがnullの場合はしかし、その後、私はまだ、0になるだろう 715 00:55:34,000 --> 00:55:39,000 そして我々は0を返すつもりなので、この場合は同じです。 716 00:55:39,000 --> 00:55:48,000 別の一般的なことは宣言しておくことです 717 00:55:48,000 --> 00:55:51,000 forループのノード内の。 718 00:55:51,000 --> 00:55:54,000 あなたは、いや、-OHを言うことができる。 719 00:55:54,000 --> 00:55:56,000 それはこのように続けましょう。 720 00:55:56,000 --> 00:55:59,000 私はおそらく、int型i = 0のここに置いたであろう 721 00:55:59,000 --> 00:56:05,000 その後、ノード*ノード=ここで初めて。 722 00:56:05,000 --> 00:56:11,000 そして、これはおそらく今これを取り除く方法を引くです。 723 00:56:11,000 --> 00:56:14,000 これは、私はそれを書かれているだろうかと思われます。 724 00:56:14,000 --> 00:56:21,000 あなたは、このようにそれでも見通しでした。 725 00:56:21,000 --> 00:56:25,000 右ここにループ構造のためにこの 726 00:56:25,000 --> 00:56:30,000 i = 0のint用者としてのあなたに同じくらい自然であるべき 727 00:56:30,000 --> 00:56:33,000 iはi + +の配列の長さよりも小さい 728 00:56:33,000 --> 00:56:38,000 それはあなたが配列を繰り返し処理方法の場合、これは、リンクされたリストを反復処理する方法です。 729 00:56:38,000 --> 00:56:45,000 >> これは、いくつかの点で第二の天性である必要があります。 730 00:56:45,000 --> 00:56:50,000 このことを念頭に置いて、これはほぼ同じものになるだろう。 731 00:56:50,000 --> 00:56:57,000 あなたは、リンクリストを反復処理するつもりだ。 732 00:56:57,000 --> 00:57:02,000 ノードは-I値が呼び出されたか見当がつかない場合。 733 00:57:02,000 --> 00:57:04,000 ノードi。 734 00:57:04,000 --> 00:57:15,000 そのノードの値= iはtrueを返し、それはそれましょう。 735 00:57:15,000 --> 00:57:18,000 ていることに注意してください私たちが今までにfalseを返す唯一の方法 736 00:57:18,000 --> 00:57:23,000 我々は全体のリンクリストを反復処理してtrueを返すことがない場合であり、 737 00:57:23,000 --> 00:57:29,000 そう、それはのこれが何。 738 00:57:29,000 --> 00:57:36,000 サイドノートとして、我々は、おそらく前後どちらに付加するために取得することはありません。 739 00:57:36,000 --> 00:57:39,000 >> クイック最後のノート。 740 00:57:39,000 --> 00:57:52,000 あなたはstaticキーワードが表示された場合は、それでは、静的なint型のカウント= 0としましょう 741 00:57:52,000 --> 00:57:56,000 それから私達はカウントを行う+ +では、基本的にグローバル変数と考えることができ、 742 00:57:56,000 --> 00:58:00,000 私は、これは我々が長さを実装しようとしている方法ではないと述べたにもかかわらず。 743 00:58:00,000 --> 00:58:06,000 私はここでこれをやって、次に+ +をカウントしています。 744 00:58:06,000 --> 00:58:11,000 我々は我々の数が増加している私達のリンクリストにノードを入力することができます任意の方法。 745 00:58:11,000 --> 00:58:15,000 この方法のポイントは、staticキーワードが何を意味するかである。 746 00:58:15,000 --> 00:58:20,000 私はちょうどintカウントを持っていた場合=通常の古いグローバル変数であろう0。 747 00:58:20,000 --> 00:58:25,000 何静的intカウント手段と、それは、このファイルのグローバル変数であるということです。 748 00:58:25,000 --> 00:58:28,000 それは、いくつかの他のファイルのために不可能である 749 00:58:28,000 --> 00:58:34,000 あなたが起動している場合は、PSET 5考える好きです。 750 00:58:34,000 --> 00:58:39,000 は、両方のspeller.cを持っていて、持っているdictionary.c 751 00:58:39,000 --> 00:58:42,000 あなたはちょうどspeller.cで、次に何かをグローバルな事を宣言した場合 752 00:58:42,000 --> 00:58:45,000 dictionary.c、またその逆でもアクセスできます。 753 00:58:45,000 --> 00:58:48,000 グローバル変数は、任意のcファイルでアクセスできます 754 00:58:48,000 --> 00:58:54,000 しかし、静的変数は、ファイル自体の内部からのみアクセスできます 755 00:58:54,000 --> 00:59:01,000 そう内部スペルチェッカーまたはdictionary.cの内側の、 756 00:59:01,000 --> 00:59:06,000 これは私が私の配列の大きさのための私の変数を宣言する方法の一種である 757 00:59:06,000 --> 00:59:10,000 または辞書内の単語の私の数の大きさ。 758 00:59:10,000 --> 00:59:15,000 私は誰がアクセスしたことをグローバル変数を宣言する必要はありませんので、 759 00:59:15,000 --> 00:59:18,000 私は実際には私自身の目的のためにそれを気遣う。 760 00:59:18,000 --> 00:59:21,000 >> これの良いところは、また、全体の名前の衝突のものです。 761 00:59:21,000 --> 00:59:27,000 他のいくつかのファイルがカウントと呼ばれるグローバル変数を使用しようとすると、物事は非常に、非常に間違って行くことは、 762 00:59:27,000 --> 00:59:33,000 ので、これはうまく物事を安全に保つ、唯一のあなたはそれにアクセスすることができます 763 00:59:33,000 --> 00:59:38,000 と誰もができ、他の誰かが、countという名前のグローバル変数を宣言している場合 764 00:59:38,000 --> 00:59:43,000 それはカウントと呼ばれるあなたの静的変数とは干渉しません。 765 00:59:43,000 --> 00:59:47,000 それは静的が何であるかです。これは、ファイルグローバル変数です。 766 00:59:47,000 --> 00:59:52,000 >> 何についての質問？ 767 00:59:52,000 --> 00:59:59,000 すべてのセット。さようなら。 768 00:59:59,000 --> 01:00:03,000 [CS50.TV]