1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Εβδομάδα 6]

2
00:00:02,000 --> 00:00:04,000
[David J. Malan] [Πανεπιστήμιο του Χάρβαρντ]

3
00:00:04,000 --> 00:00:08,000
[Αυτό είναι CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Αυτό είναι CS50, και αυτή είναι η αρχή της εβδομάδας 6,

5
00:00:12,000 --> 00:00:16,000
έτσι, ένα ζευγάρι νέων εργαλείων είναι τώρα στη διάθεσή σας για να επωφεληθούν από,

6
00:00:16,000 --> 00:00:19,000
η πρώτη από τις οποίες καλείται CS50 στυλ.

7
00:00:19,000 --> 00:00:22,000
Οι πιθανότητες είναι, αν είστε σαν εμένα ή οποιονδήποτε από τους υποτρόφους διδασκαλίας,

8
00:00:22,000 --> 00:00:26,000
έχετε δει πιθανώς ένα πρόγραμμα, του οποίου το στυλ μοιάζει λίγο κάτι σαν αυτό.

9
00:00:26,000 --> 00:00:30,000
Ίσως να αρχίσετε την κοπή κάποιες γωνιές αργά το βράδυ, ή θα ασχοληθεί με το θέμα αργότερα,

10
00:00:30,000 --> 00:00:32,000
και στη συνέχεια ένα TF ή CA έρχεται πάνω κατά τις ώρες γραφείου.

11
00:00:32,000 --> 00:00:34,000
Στη συνέχεια, είναι δύσκολο για μας να το διαβάσετε.

12
00:00:34,000 --> 00:00:38,000
Λοιπόν, αυτός ο κώδικας είναι συντακτικά σωστές, και θα συγκεντρώνει και θα τρέχουν στην πραγματικότητα.

13
00:00:38,000 --> 00:00:40,000
Αλλά σίγουρα δεν είναι ένα 5 για το στυλ.

14
00:00:40,000 --> 00:00:45,000
>> Αλλά τώρα, αν πάμε σε αυτόν τον κατάλογο εδώ-

15
00:00:45,000 --> 00:00:48,000
και παρατηρήσετε ότι έχω conditions2.c-

16
00:00:48,000 --> 00:00:55,000
και τρέχω αυτή τη νέα εντολή, style50, σε αυτό το αρχείο conditions2.c, Enter,

17
00:00:55,000 --> 00:00:57,000
παρατηρήσετε ότι είναι με πληροφόρησε ότι έχει στυλιζαρισμένο.

18
00:00:57,000 --> 00:01:00,000
Gedit παρατηρήσει ότι το αρχείο έχει αλλάξει στο δίσκο,

19
00:01:00,000 --> 00:01:08,000
και αν κάνω κλικ reload, όλα τα προβλήματά σας τώρα αυτοματοποιημένη.

20
00:01:08,000 --> 00:01:15,000
[Χειροκροτήματα]

21
00:01:15,000 --> 00:01:17,000
Αυτό είναι ένα από τα πράγματα που κάναμε αυτό το Σαββατοκύριακο.

22
00:01:17,000 --> 00:01:20,000
Συνειδητοποιήστε ότι είναι ατελής, διότι υπάρχουν κάποιες κώδικα

23
00:01:20,000 --> 00:01:23,000
ότι απλά δεν θα είναι σε θέση να στυλιζάρω τέλεια,

24
00:01:23,000 --> 00:01:26,000
αλλά συνειδητοποιούν αυτό τώρα είναι ένα εργαλείο που μπορείτε να εκμεταλλευτείτε

25
00:01:26,000 --> 00:01:33,000
εάν μόνο για να βάλει τάξη σε μερικά από τα πιο errantly τοποθετούνται άγκιστρα και τα παρόμοια.

26
00:01:33,000 --> 00:01:36,000
>> Αλλά το πιο συναρπαστικό είναι τώρα CS50 Έλεγχος.

27
00:01:36,000 --> 00:01:39,000
Με CS50 Έλεγχος, μπορείτε να κάνετε πραγματικά τις ίδιες δοκιμές ορθότητα

28
00:01:39,000 --> 00:01:42,000
για το δικό του κωδικό σας ότι οι υπότροφοι διδασκαλίας είναι σε θέση να.

29
00:01:42,000 --> 00:01:44,000
Αυτό είναι ένα βοηθητικό πρόγραμμα γραμμής εντολών που έρχεται τώρα στη συσκευή

30
00:01:44,000 --> 00:01:46,000
το συντομότερο κάνετε μια update50 ως ανά

31
00:01:46,000 --> 00:01:49,000
PSET 4 προδιαγραφές, και μπορείτε να το χρησιμοποιήσετε κατ 'ουσίαν, όπως αυτό.

32
00:01:49,000 --> 00:01:51,000
Μπορείτε να εκτελέσετε την εντολή check50.

33
00:01:51,000 --> 00:01:56,000
Στη συνέχεια θα περάσει σε ένα όρισμα γραμμής εντολών, ή πιο γενικά γνωστό ως ένα διακόπτη ή μια σημαία.

34
00:01:56,000 --> 00:01:58,000
Σε γενικές γραμμές, τα πράγματα που έχουν παύλες ονομάζεται διακόπτης

35
00:01:58,000 --> 00:02:02,000
σε ένα πρόγραμμα γραμμής εντολών, έτσι ώστε-γ καθορίζει

36
00:02:02,000 --> 00:02:04,000
οι έλεγχοι που θέλετε να εκτελέσετε.

37
00:02:04,000 --> 00:02:07,000
>> Οι δοκιμές που θέλετε να εκτελέσετε με μοναδικό τρόπο από αυτή τη σειρά,

38
00:02:07,000 --> 00:02:10,000
2012/pset4/resize.

39
00:02:10,000 --> 00:02:13,000
Με άλλα λόγια, αυτό είναι απλώς μια αυθαίρετη, αλλά μοναδική συμβολοσειρά

40
00:02:13,000 --> 00:02:18,000
που χρησιμοποιούμε για να προσδιορίσει μοναδικά δοκιμές ορθότητα PSET 4 του.

41
00:02:18,000 --> 00:02:21,000
Και στη συνέχεια να ορίσετε ένα χώρο χωρίζονται λίστα με τα αρχεία που θέλετε να ανεβάσετε

42
00:02:21,000 --> 00:02:24,000
να CS50 Έλεγχος για ανάλυση.

43
00:02:24,000 --> 00:02:29,000
Για παράδειγμα, αν πάω σε λύση μου εδώ για resize.c-

44
00:02:29,000 --> 00:02:31,000
επιτρέψτε μου να ανοίξει ένα μεγαλύτερο παράθυρο τερματικού-

45
00:02:31,000 --> 00:02:42,000
και πάω μπροστά και να τρέξει ας πούμε check50-γ 2012/pset4/resize,

46
00:02:42,000 --> 00:02:46,000
και τότε να προχωρήσει και να καθορίσετε τα ονόματα των αρχείων,

47
00:02:46,000 --> 00:02:49,000
resize.c, και πατήστε Enter, στη συνέχεια, το συμπιέζει,

48
00:02:49,000 --> 00:02:53,000
αυτό προσθήκες, ελέγχει, και εγώ απλά απέτυχε ένα σωρό εξετάσεις.

49
00:02:53,000 --> 00:02:59,000
Το ένα με κόκκινα γράμματα στο πάνω αριστερά λέει ότι resize.c και bmp υπάρχουν.

50
00:02:59,000 --> 00:03:01,000
Αυτή ήταν η δοκιμή. Αυτό ήταν το ερώτημα που τέθηκε.

51
00:03:01,000 --> 00:03:04,000
Και είναι δυσαρεστημένοι επειδή η απάντηση ήταν ψευδείς.

52
00:03:04,000 --> 00:03:08,000
Το λευκό παρακάτω κείμενο λέει bmp.h αναμένεται να υπάρχουν, και ότι είναι απλά λάθος μου.

53
00:03:08,000 --> 00:03:11,000
Ξέχασα να το ανεβάσετε, γι 'αυτό πρέπει να ανεβάσετε τα αρχεία και τα δύο,

54
00:03:11,000 --> 00:03:14,000
resize.c και bmp.h.

55
00:03:14,000 --> 00:03:17,000
Αλλά τώρα παρατηρήσετε όλες τις άλλες δοκιμές είναι κίτρινο, επειδή δεν έχουν εκτελεστεί,

56
00:03:17,000 --> 00:03:21,000
και έτσι το χαμογελαστό πρόσωπο είναι κάθετες επειδή είναι ούτε ικανοποιημένοι ούτε λυπημένος,

57
00:03:21,000 --> 00:03:25,000
αλλά θα πρέπει να επανορθώσει αυτό το θέμα σε κόκκινο πριν οι λοιποί έλεγχοι που θα τρέξει.

58
00:03:25,000 --> 00:03:27,000
>> Επιτρέψτε μου να το διορθώσω αυτό.

59
00:03:27,000 --> 00:03:30,000
Επιτρέψτε μου σμίκρυνση και να επαναπροσδιοριστούν αυτό, αυτή τη φορά με bmp.h επίσης

60
00:03:30,000 --> 00:03:34,000
στη γραμμή εντολών, Enter, και τώρα, αν όλα πάνε καλά,

61
00:03:34,000 --> 00:03:38,000
πρόκειται να ελέγξει και στη συνέχεια να επιστρέψει ένα αποτέλεσμα-κρατήστε την αναπνοή σας-

62
00:03:38,000 --> 00:03:42,000
όλα πράσινο, που σημαίνει κάνω πολύ καλά στις PSET 4 μέχρι τώρα.

63
00:03:42,000 --> 00:03:44,000
Μπορείτε να δείτε και να συναγάγει από το περιγραφικό κείμενο εδώ

64
00:03:44,000 --> 00:03:47,000
ακριβώς τι είναι αυτό που δοκιμάσαμε.

65
00:03:47,000 --> 00:03:49,000
Εξετάσαμε αρχικά υπάρχουν τα αρχεία;

66
00:03:49,000 --> 00:03:51,000
Στη συνέχεια δοκιμάστηκε κάνει resize.c μεταγλώττιση;

67
00:03:51,000 --> 00:03:58,000
Στη συνέχεια ελέγξαμε δεν είναι το μέγεθος ενός 1x1-pixel BMP όταν n, ο συντελεστής αλλαγής μεγέθους, είναι 1.

68
00:03:58,000 --> 00:04:01,000
Τώρα, αν δεν έχετε ιδέα τι είναι ν, θα τη στιγμή που θα βουτήξει PSET 4,

69
00:04:01,000 --> 00:04:04,000
αλλά αυτό είναι απλά μια λογική βεβαιωθείτε ότι δεν είστε αλλαγή μεγέθους

70
00:04:04,000 --> 00:04:08,000
μια εικόνα καθόλου αν ο παράγοντας αλλαγής μεγέθους είναι 1.

71
00:04:08,000 --> 00:04:14,000
Εάν, αντίθετα, είναι μια αλλάζει το μέγεθος 1x1 pixel σε ένα 1x1 pixel BMP σε 2x2 σωστά

72
00:04:14,000 --> 00:04:19,000
όταν το η είναι 2, τότε ομοίως, ορυχείο σχηματίζει ανάλογα.

73
00:04:19,000 --> 00:04:22,000
>> Εν ολίγοις, αυτό έχει ως στόχο να, ένα, να λάβει τα διασχίζουν τα δάχτυλά

74
00:04:22,000 --> 00:04:25,000
από την εξίσωση δεξιά προτού να υποβάλετε PSET σας.

75
00:04:25,000 --> 00:04:28,000
Θα ξέρετε ακριβώς τι TF σας σύντομα θα γνωρίζουμε

76
00:04:28,000 --> 00:04:30,000
όταν θα πάτε για την υποβολή μερικά από αυτά τα σύνολα πρόβλημα,

77
00:04:30,000 --> 00:04:34,000
καθώς επίσης και το παιδαγωγικό κίνητρο είναι πραγματικά να θέσει

78
00:04:34,000 --> 00:04:37,000
η ευκαιρία μπροστά σας, έτσι ώστε όταν ξέρεις εκ των προτέρων

79
00:04:37,000 --> 00:04:39,000
ότι υπάρχει σφάλματα στον κώδικά σας και δοκιμές που δεν έχει μεταβιβαστεί,

80
00:04:39,000 --> 00:04:43,000
μπορείτε να βάλετε σε πιο αποτελεσματική χρόνο μπροστά για να λύσει αυτά τα προβλήματα

81
00:04:43,000 --> 00:04:45,000
αντί να χάσετε πόντους, να πάρει πληροφορίες από τους TF σας,

82
00:04:45,000 --> 00:04:48,000
και στη συνέχεια να πάμε, "Ααα," όπως θα έπρεπε να είχα καταλάβει ότι έξω.

83
00:04:48,000 --> 00:04:50,000
Τώρα τουλάχιστον υπάρχει ένα εργαλείο για να σας βοηθήσει να βρείτε αυτό.

84
00:04:50,000 --> 00:04:52,000
Δεν πρόκειται να επισημάνει τα πεδία όπου το σφάλμα είναι, αλλά θα σας πω

85
00:04:52,000 --> 00:04:54,000
τι είναι σύμπτωμα αυτό.

86
00:04:54,000 --> 00:04:57,000
>> Τώρα συνειδητοποιούν οι δοκιμές δεν είναι κατ 'ανάγκη εξαντλητικός.

87
00:04:57,000 --> 00:04:59,000
Ακριβώς επειδή μπορείτε να πάρετε μια οθόνη γεμάτη πράσινο χαμογελαστά πρόσωπα

88
00:04:59,000 --> 00:05:02,000
δεν σημαίνει ότι τον κωδικό σας είναι τέλειο, αλλά αυτό δεν σημαίνει

89
00:05:02,000 --> 00:05:06,000
ότι έχει περάσει ορισμένες δοκιμές που προβλέπονται από το spec.

90
00:05:06,000 --> 00:05:08,000
Μερικές φορές δεν θα απελευθερώσει τους ελέγχους.

91
00:05:08,000 --> 00:05:10,000
Για παράδειγμα, whodunit, μια από τις πλευρές της PSET 4,

92
00:05:10,000 --> 00:05:15,000
είναι είδος απογοητευτικό αν σας δίνουμε

93
00:05:15,000 --> 00:05:18,000
η απάντηση ως προς το τι είναι, και υπάρχει μια σειρά από τρόπους για να αποκαλύψει

94
00:05:18,000 --> 00:05:21,000
που το άτομο είναι σε αυτό το κόκκινο θόρυβο.

95
00:05:21,000 --> 00:05:24,000
Το spec θα είναι πάντα καθορίζουν στο μέλλον για PSET 5 προς τα εμπρός

96
00:05:24,000 --> 00:05:26,000
τι ελέγχει υπάρχουν για εσάς.

97
00:05:26,000 --> 00:05:28,000
Θα παρατηρήσετε ότι υπάρχει αυτό το λευκό URL στο κάτω μέρος.

98
00:05:28,000 --> 00:05:30,000
Προς το παρόν, αυτό είναι μόνο διαγνωστική έξοδος.

99
00:05:30,000 --> 00:05:33,000
Αν επισκεφθείτε το URL, θα έχετε ένα σωρό τρελοί, κρυπτογραφημένα μηνύματα

100
00:05:33,000 --> 00:05:36,000
ότι είστε ευπρόσδεκτοι να κοιτάξουμε μέσα, αλλά είναι ως επί το πλείστον για το προσωπικό

101
00:05:36,000 --> 00:05:41,000
έτσι ώστε να μπορούμε να διαγνώσουμε και να διορθώσετε σφάλματα σε check50 ίδια.

102
00:05:41,000 --> 00:05:46,000
>> Χωρίς φασαρία, ας προχωρήσουμε εκεί που σταμάτησε.

103
00:05:46,000 --> 00:05:48,000
CS50 βιβλιοθήκη πήραμε ως δεδομένο για μερικές εβδομάδες,

104
00:05:48,000 --> 00:05:52,000
αλλά στη συνέχεια τελευταία εβδομάδα, αρχίσαμε ξεφλούδισμα πίσω ένα από τα στρώματα του.

105
00:05:52,000 --> 00:05:55,000
Ξεκινήσαμε βάζοντας στην άκρη κορδόνι υπέρ του τι αντ 'αυτού;

106
00:05:55,000 --> 00:05:57,000
[Φοιτητές] Χαρ.

107
00:05:57,000 --> 00:05:59,000
Char *, η οποία έχει ένα char * όλο αυτό το διάστημα,

108
00:05:59,000 --> 00:06:03,000
αλλά τώρα δεν έχουμε να προσποιούνται ότι είναι ένας πραγματικός τύπος δεδομένων συμβολοσειράς.

109
00:06:03,000 --> 00:06:06,000
Μάλλον, αυτό είναι ένα συνώνυμο του είδους για char *,

110
00:06:06,000 --> 00:06:09,000
και μια συμβολοσειρά είναι μια ακολουθία χαρακτήρων,

111
00:06:09,000 --> 00:06:14,000
γιατί έτσι έχει νόημα να αντιπροσωπεύουν χορδές ως char * s;

112
00:06:14,000 --> 00:06:20,000
Τι κάνει ένας char * εκπροσωπούν στο πλαίσιο αυτής της έννοιας της σειράς;

113
00:06:20,000 --> 00:06:23,000
Ναι. >> [Φοιτητικό] Ο πρώτος χαρακτήρας.

114
00:06:23,000 --> 00:06:25,000
Καλό, ο πρώτος χαρακτήρας, αλλά όχι αρκετά ο πρώτος χαρακτήρας.

115
00:06:25,000 --> 00:06:27,000
Είναι οι-[Φοιτητές] Διεύθυνση.

116
00:06:27,000 --> 00:06:29,000
Καλό, η διεύθυνση του πρώτου χαρακτήρα.

117
00:06:29,000 --> 00:06:33,000
Το μόνο που είναι απαραίτητο για να αντιπροσωπεύουν ένα string στη μνήμη ενός υπολογιστή

118
00:06:33,000 --> 00:06:36,000
είναι ακριβώς η μοναδική διεύθυνση του πρώτου byte πολύ του.

119
00:06:36,000 --> 00:06:38,000
Δεν χρειάζεται καν να ξέρω πόσο καιρό είναι

120
00:06:38,000 --> 00:06:42,000
γιατί πώς μπορεί κανείς να υπολογίσει ότι από δυναμικά;

121
00:06:42,000 --> 00:06:44,000
[Φοιτητικό] μήκος String.

122
00:06:44,000 --> 00:06:48,000
Μπορείτε να καλέσετε το μήκος συμβολοσειράς, εξαιρετική, αλλά πώς κορδόνι μήκους εργασίας;

123
00:06:48,000 --> 00:06:50,000
Τι κάνει; Ναι.

124
00:06:50,000 --> 00:06:52,000
[Φοιτητικό] Συνεχίστε μέχρι να φτάσετε το null χαρακτήρα.

125
00:06:52,000 --> 00:06:54,000
Ναι, ακριβώς, αυτό επαναλαμβάνει απλώς με ένα βρόχο for, while loop,

126
00:06:54,000 --> 00:06:57,000
όποια και αν είναι από * στο τέλος, και το άκρο εκπροσωπείται

127
00:06:57,000 --> 00:07:01,000
με \ 0, το λεγόμενο nul χαρακτήρα, nul,

128
00:07:01,000 --> 00:07:05,000
δεν πρέπει να συγχέεται με την μηδενική, η οποία είναι ένας δείκτης,

129
00:07:05,000 --> 00:07:07,000
η οποία θα καταλήξει σε συζήτηση και πάλι σήμερα.

130
00:07:07,000 --> 00:07:11,000
>> Έχουμε τη φλούδα τους πίσω από ένα στρώμα GetInt, και στη συνέχεια πήραμε μια ματιά στο GetString,

131
00:07:11,000 --> 00:07:14,000
και υπενθυμίζουν ότι και οι δύο αυτές λειτουργίες, ή πραγματικά,

132
00:07:14,000 --> 00:07:18,000
GetString, ήταν χρησιμοποιώντας μια συγκεκριμένη λειτουργία

133
00:07:18,000 --> 00:07:21,000
πραγματικά να αναλύσει, που είναι, να διαβάσετε ή να αναλύσει, η είσοδος του χρήστη.

134
00:07:21,000 --> 00:07:25,000
Και αυτό ήταν ότι η νέα λειτουργία;

135
00:07:25,000 --> 00:07:27,000
Scanf ή sscanf. Έρχεται πραγματικά σε μερικές διαφορετικές γεύσεις.

136
00:07:27,000 --> 00:07:31,000
Υπάρχει scanf, υπάρχει sscanf, υπάρχει fscanf.

137
00:07:31,000 --> 00:07:35,000
Προς το παρόν, όμως, ας επικεντρωθεί σε αυτό που φαίνεται πιο εύκολα,

138
00:07:35,000 --> 00:07:38,000
και επιτρέψτε μου να προχωρήσει και να ανοίξει στη συσκευή

139
00:07:38,000 --> 00:07:41,000
ένα αρχείο σαν αυτό, scanf1.c.

140
00:07:41,000 --> 00:07:43,000
Αυτό είναι ένα εξαιρετικά απλό πρόγραμμα,

141
00:07:43,000 --> 00:07:46,000
αλλά αυτό κάνει κάτι που ποτέ δεν έχω κάνει

142
00:07:46,000 --> 00:07:48,000
χωρίς τη βοήθεια της βιβλιοθήκης CS50.

143
00:07:48,000 --> 00:07:51,000
Αυτό παίρνει ένα int από ένα χρήστη. Πώς λειτουργεί;

144
00:07:51,000 --> 00:07:53,000
Λοιπόν, σε γραμμή 16 εκεί,

145
00:07:53,000 --> 00:07:56,000
παρατηρήσετε ότι έχουμε κηρύξει ονομάζεται int x, και σε αυτό το σημείο στην ιστορία,

146
00:07:56,000 --> 00:07:58,000
ποια είναι η τιμή του χ;

147
00:07:58,000 --> 00:08:00,000
[Ακούγεται ανταπόκριση των φοιτητών]

148
00:08:00,000 --> 00:08:02,000
[David M.] Δεξιά, ποιος ξέρει, κάποια αξία σκουπίδια δυνητικά, έτσι ώστε σε 17, θα πω μόνο το χρήστη

149
00:08:02,000 --> 00:08:06,000
να μου δώσει έναν αριθμό, παρακαλώ, και το βήμα 18 είναι όπου παίρνει ενδιαφέρον.

150
00:08:06,000 --> 00:08:11,000
Scanf φαίνεται να δανειστεί μια ιδέα από την printf στο ότι χρησιμοποιεί αυτούς τους κωδικούς μορφή σε εισαγωγικά.

151
00:08:11,000 --> 00:08:13,000
Δ% είναι φυσικά ένας δεκαδικός αριθμός.

152
00:08:13,000 --> 00:08:21,000
Αλλά γιατί είμαι περνώντας & x όχι μόνο x;

153
00:08:21,000 --> 00:08:24,000
Το πρώτο είναι σωστή. Ναι.

154
00:08:24,000 --> 00:08:26,000
[Ακούγεται ανταπόκριση των φοιτητών]

155
00:08:26,000 --> 00:08:31,000
Ακριβώς, αν ο στόχος αυτού του προγράμματος, όπως και η ίδια η λειτουργία GetInt,

156
00:08:31,000 --> 00:08:34,000
είναι να πάρετε μια int από το χρήστη μπορώ να περάσει λειτουργίες

157
00:08:34,000 --> 00:08:38,000
όλες οι μεταβλητές που θέλω, αλλά αν δεν τα περνούν με αναφορά

158
00:08:38,000 --> 00:08:41,000
ή κατά διεύθυνση ή με δείκτη, όλα συνώνυμο για τους σκοπούς του σήμερα,

159
00:08:41,000 --> 00:08:46,000
τότε αυτή η λειτουργία δεν έχει τη δυνατότητα να αλλάξετε τα περιεχόμενα αυτής της μεταβλητής.

160
00:08:46,000 --> 00:08:49,000
Αυτό θα περάσει σε ένα αντίγραφο ακριβώς όπως το buggy έκδοση της ανταλλαγής

161
00:08:49,000 --> 00:08:51,000
ότι έχουμε μιλήσει για μερικές φορές μέχρι τώρα.

162
00:08:51,000 --> 00:08:54,000
>> Αλλά αντ 'αυτού, κάνοντας & x, είμαι κυριολεκτικά περνώντας σε ό, τι;

163
00:08:54,000 --> 00:08:57,000
[Φοιτητικό] Η διεύθυνση. >> Η διεύθυνση του x.

164
00:08:57,000 --> 00:09:01,000
Είναι σαν την κατάρτιση ενός χάρτη για τη λειτουργία που ονομάζεται scanf και λέει εδώ,

165
00:09:01,000 --> 00:09:04,000
κατευθύνσεις αυτές είναι σε ένα κομμάτι της μνήμης του υπολογιστή

166
00:09:04,000 --> 00:09:07,000
ότι μπορείτε να πάτε αποθηκεύσει έναν ακέραιο μέσα

167
00:09:07,000 --> 00:09:10,000
Προκειμένου για sscanf να κάνω τώρα που

168
00:09:10,000 --> 00:09:13,000
τι χειριστή, τι κομμάτι της σύνταξης είναι αυτό που θα πρέπει να χρησιμοποιήσετε

169
00:09:13,000 --> 00:09:19,000
ακόμα κι αν δεν μπορούμε να δούμε επειδή κάποιος άλλος έγραψε αυτή τη λειτουργία;

170
00:09:19,000 --> 00:09:21,000
Με άλλα λόγια - τι είναι αυτό;

171
00:09:21,000 --> 00:09:23,000
[Φοιτητικό] X διαβάσετε.

172
00:09:23,000 --> 00:09:27,000
Υπάρχει πρόκειται να είναι κάποια ανάγνωση, αλλά μόνο όσον αφορά x εδώ.

173
00:09:27,000 --> 00:09:30,000
Αν scanf είναι να περάσει τη διεύθυνση του x,

174
00:09:30,000 --> 00:09:35,000
συντακτικά, τι χειριστής είναι βέβαιο ότι θα υπάρχουν κάπου

175
00:09:35,000 --> 00:09:38,000
εσωτερικό της εφαρμογής scanf έτσι ώστε scanf

176
00:09:38,000 --> 00:09:42,000
πραγματικά μπορεί να γράψει έναν αριθμό 2 της εν λόγω διεύθυνση;

177
00:09:42,000 --> 00:09:44,000
Ναι, έτσι το *.

178
00:09:44,000 --> 00:09:47,000
Υπενθυμίζουμε ότι ο χειριστής είναι * dereference μας, το οποίο ουσιαστικά σημαίνει εκεί.

179
00:09:47,000 --> 00:09:50,000
>> Μόλις εκδοθεί μια διεύθυνση, όπως συμβαίνει εν προκειμένω,

180
00:09:50,000 --> 00:09:53,000
scanf πιθανότατα-αν πραγματικά κοίταξε γύρω από την πηγή του κώδικα-

181
00:09:53,000 --> 00:09:59,000
κάνει * x ή το ισοδύναμο πραγματικά να μεταβεί στη συγκεκριμένη διεύθυνση και να θέσει κάποια αξία εκεί.

182
00:09:59,000 --> 00:10:02,000
Τώρα, όπως και για το πώς scanf παίρνει είσοδο από το πληκτρολόγιο,

183
00:10:02,000 --> 00:10:04,000
θα κυματίσει στα χέρια μας έξω για σήμερα.

184
00:10:04,000 --> 00:10:07,000
Απλά υποθέσουμε ότι το λειτουργικό σύστημα επιτρέπει sscanf να μιλήσει

185
00:10:07,000 --> 00:10:11,000
στο πληκτρολόγιο του χρήστη, αλλά σε αυτό το σημείο τώρα στη γραμμή 19,

186
00:10:11,000 --> 00:10:14,000
όταν απλά εκτύπωση χ, φαίνεται να είναι η περίπτωση

187
00:10:14,000 --> 00:10:17,000
scanf που έχει θέσει σε int x.

188
00:10:17,000 --> 00:10:19,000
Αυτό είναι ακριβώς το πώς λειτουργεί scanf, ενώ υπενθυμίζει και την περασμένη εβδομάδα

189
00:10:19,000 --> 00:10:25,000
αυτό είναι ακριβώς το πώς GetString και GetInt και άλλα οικογένεια των λειτουργιών του

190
00:10:25,000 --> 00:10:28,000
τελικά λειτουργεί, αν και με μικρή διακύμανση, όπως sscanf,

191
00:10:28,000 --> 00:10:31,000
πράγμα που σημαίνει μια συμβολοσειρά σάρωση αντί για το πληκτρολόγιο.

192
00:10:31,000 --> 00:10:33,000
Αλλά ας ρίξουμε μια ματιά σε μια μικρή διακύμανση από αυτό.

193
00:10:33,000 --> 00:10:37,000
Σε scanf2, εγώ πραγματικά μαντάρα.

194
00:10:37,000 --> 00:10:42,000
Ποιο είναι το πρόβλημα-και θα κρύψει το σχόλιο που εξηγεί ως πολύ-

195
00:10:42,000 --> 00:10:47,000
τι είναι λάθος με αυτό το πρόγραμμα, έκδοση 2;

196
00:10:47,000 --> 00:10:55,000
Να είστε όσο το δυνατόν τεχνικά αυτή τη στιγμή.

197
00:10:55,000 --> 00:10:57,000
Φαίνεται αρκετά καλό.

198
00:10:57,000 --> 00:11:03,000
Είναι ωραία εσοχή, αλλά-

199
00:11:03,000 --> 00:11:07,000
εντάξει, σχετικά με το πώς ας το κλαδεύω τα κάτω σε μικρότερα ερωτήσεις;

200
00:11:07,000 --> 00:11:17,000
Γραμμή 16. Τι είναι γραμμή 16 κάνει σε ακριβή αλλά τεχνικά αγγλικά;

201
00:11:17,000 --> 00:11:20,000
Να πάρει λίγο άβολα. Ναι, Μάικλ.

202
00:11:20,000 --> 00:11:25,000
[Φοιτητικό] Είναι δείχνοντας με το πρώτο γράμμα μιας συμβολοσειράς.

203
00:11:25,000 --> 00:11:27,000
>> Εντάξει, κοντά. Επιτρέψτε μου να τσιμπιά ότι λίγο.

204
00:11:27,000 --> 00:11:33,000
Επισημαίνοντας το πρώτο γράμμα μιας συμβολοσειράς, που κηρύσσει μια μεταβλητή που ονομάζεται ρυθμιστικό

205
00:11:33,000 --> 00:11:36,000
που θα τονίζουν την πρώτη διεύθυνση της συμβολοσειράς,

206
00:11:36,000 --> 00:11:39,000
ή μάλλον, αυτό θα δείξει πιο συγκεκριμένα σε ένα απανθρακώματος.

207
00:11:39,000 --> 00:11:42,000
Σημειώστε ότι δεν είναι πραγματικά δείχνει οπουδήποτε, επειδή δεν υπάρχει φορέας ανάθεσης.

208
00:11:42,000 --> 00:11:46,000
Δεν υπάρχει το σύμβολο της ισότητας, ώστε όλοι κάνουμε είναι την κατανομή της μεταβλητής που ονομάζεται buffer.

209
00:11:46,000 --> 00:11:49,000
Συμβαίνει να είναι 32 bit επειδή είναι ένας δείκτης,

210
00:11:49,000 --> 00:11:52,000
και τα περιεχόμενα του ρυθμιστικού πιθανώς τελικά

211
00:11:52,000 --> 00:11:57,000
θα περιέχει τη διεύθυνση μιας char, αλλά για τώρα, ό, τι δεν περιέχει ρυθμιστικό διάλυμα;

212
00:11:57,000 --> 00:11:59,000
Απλά μερικές ψεύτικες, ποιος ξέρει, κάποια αξία σκουπίδια,

213
00:11:59,000 --> 00:12:03,000
επειδή δεν έχουμε προετοιμαστεί ρητά, γι 'αυτό δεν θα πρέπει να υποθέσουμε τίποτα.

214
00:12:03,000 --> 00:12:06,000
Εντάξει, έτσι τώρα η γραμμή 17 είναι-τι γραμμή 17 κάνει;

215
00:12:06,000 --> 00:12:08,000
Ίσως αυτό θα ζεστάνει αυτό επάνω.

216
00:12:08,000 --> 00:12:10,000
Εκτυπώνει μια σειρά, έτσι δεν είναι;

217
00:12:10,000 --> 00:12:12,000
Τυπώνει String παρακαλώ.

218
00:12:12,000 --> 00:12:15,000
>> Η γραμμή 18 είναι το είδος των γνωστών πλέον σε ότι είδαμε μόνο μια διακύμανση αυτή

219
00:12:15,000 --> 00:12:18,000
αλλά με διαφορετικό κωδικό μορφή, έτσι στη γραμμή 18,

220
00:12:18,000 --> 00:12:23,000
λέμε scanf εδώ είναι η διεύθυνση του ένα κομμάτι της μνήμης.

221
00:12:23,000 --> 00:12:27,000
Θέλω να τηλεφωνήσετε σε μια σειρά, όπως υπονοείται από% s,

222
00:12:27,000 --> 00:12:32,000
αλλά το πρόβλημα είναι ότι δεν έχουμε κάνει μερικά πράγματα εδώ.

223
00:12:32,000 --> 00:12:35,000
Τι είναι ένα από τα προβλήματα;

224
00:12:35,000 --> 00:12:38,000
[Φοιτητικό] Είναι προσπαθεί να dereference ένα null δείκτη.

225
00:12:38,000 --> 00:12:41,000
Καλό, μηδενική ή αλλιώς απλά άγνωστο δείκτες.

226
00:12:41,000 --> 00:12:45,000
Είσαι παράδοση scanf μια διεύθυνση, αλλά το μόνο που είπε πριν από λίγο

227
00:12:45,000 --> 00:12:49,000
ότι η διεύθυνση είναι κάποια αξία σκουπίδια, επειδή δεν είχαμε εκχωρήσει πραγματικά σε τίποτα,

228
00:12:49,000 --> 00:12:53,000
και έτσι λέτε scanf αποτελεσματικά να θέσει μια σειρά εδώ,

229
00:12:53,000 --> 00:12:56,000
αλλά δεν ξέρετε από πού είναι ακόμη εδώ,

230
00:12:56,000 --> 00:12:59,000
έτσι δεν έχουμε στην πραγματικότητα διατεθεί για μνήμη buffer.

231
00:12:59,000 --> 00:13:03,000
Επιπλέον, αυτό που είστε, επίσης, δεν λέει ακόμη και scanf;

232
00:13:03,000 --> 00:13:06,000
Ας υποθέσουμε ότι αυτό ήταν ένα κομμάτι της μνήμης, και αυτό δεν ήταν μια αξία σκουπίδια,

233
00:13:06,000 --> 00:13:09,000
αλλά είστε ακόμα δεν λέει κάτι σημαντικό scanf.

234
00:13:09,000 --> 00:13:12,000
[Φοιτητικό] Όταν είναι στην πραγματικότητα, το εμπορικό.

235
00:13:12,000 --> 00:13:15,000
Ampersand, οπότε σε αυτή την περίπτωση, είναι εντάξει.

236
00:13:15,000 --> 00:13:18,000
Επειδή ρυθμιστικό ήδη δηλωθεί ως δείκτης

237
00:13:18,000 --> 00:13:22,000
με το κομμάτι * της σύνταξης, δεν χρειάζεται να χρησιμοποιήσετε ampersand

238
00:13:22,000 --> 00:13:25,000
γιατί είναι ήδη μια διεύθυνση, αλλά νομίζω ότι το άκουσα εδώ.

239
00:13:25,000 --> 00:13:27,000
[Φοιτητικό] Πόσο μεγάλο είναι αυτό;

240
00:13:27,000 --> 00:13:29,000
Καλό, δεν είμαστε scanf λέει πόσο μεγάλο είναι αυτό το ρυθμιστικό,

241
00:13:29,000 --> 00:13:32,000
πράγμα που σημαίνει ακόμα κι αν ήταν ένα ρυθμιστικό δείκτη,

242
00:13:32,000 --> 00:13:35,000
λέμε scanf, να θέσει μια σειρά εδώ,

243
00:13:35,000 --> 00:13:38,000
αλλά εδώ θα μπορούσε να είναι 2 bytes, θα μπορούσε να είναι 10 bytes, θα μπορούσε να είναι ένα megabyte.

244
00:13:38,000 --> 00:13:41,000
Scanf δεν έχει καμία ιδέα, γιατί και αυτό είναι ένα κομμάτι της μνήμης

245
00:13:41,000 --> 00:13:43,000
προφανώς, δεν είναι μια σειρά ακόμα.

246
00:13:43,000 --> 00:13:48,000
Είναι μόνο ένα string από τη στιγμή που γράφουν χαρακτήρες και μια \ 0 έως το κομμάτι της μνήμης.

247
00:13:48,000 --> 00:13:51,000
Τώρα είναι μερικές μόνο κομμάτι της μνήμης.

248
00:13:51,000 --> 00:13:55,000
Scanf δεν θα ξέρουν πότε να σταματήσω να γράφω σε αυτή τη διεύθυνση.

249
00:13:55,000 --> 00:13:59,000
>> Αν θυμηθούμε μερικά παραδείγματα στο παρελθόν όπου τυχαία πληκτρολογηθεί

250
00:13:59,000 --> 00:14:03,000
προσπαθώντας να ξεχειλίσει ένα ρυθμιστικό, και μιλήσαμε την Παρασκευή για ακριβώς αυτό.

251
00:14:03,000 --> 00:14:07,000
Εάν ένας αντίπαλος εγχέει με κάποιο τρόπο στο πρόγραμμά σας μια πολύ μεγαλύτερη λέξη

252
00:14:07,000 --> 00:14:10,000
ή πρόταση ή φράση τότε θα ανέμεναν μπορείτε να υπερβεί

253
00:14:10,000 --> 00:14:13,000
ένα κομμάτι της μνήμης, η οποία μπορεί να έχει κακές συνέπειες,

254
00:14:13,000 --> 00:14:15,000
όπως τη λήψη όλο το ίδιο το πρόγραμμα.

255
00:14:15,000 --> 00:14:17,000
Πρέπει να διορθώσετε αυτό με κάποιο τρόπο.

256
00:14:17,000 --> 00:14:20,000
Επιτρέψτε μου σμίκρυνση και να πάει στην έκδοση 3 του εν λόγω προγράμματος.

257
00:14:20,000 --> 00:14:22,000
Αυτό είναι λίγο καλύτερα.

258
00:14:22,000 --> 00:14:24,000
Σε αυτή την έκδοση, παρατηρήσετε την διαφορά.

259
00:14:24,000 --> 00:14:27,000
Στη γραμμή 16, είμαι δηλώνοντας και πάλι μια μεταβλητή που ονομάζεται buffer,

260
00:14:27,000 --> 00:14:29,000
αλλά τι είναι αυτό τώρα;

261
00:14:29,000 --> 00:14:33,000
Είναι μια σειρά από 16 χαρακτήρες.

262
00:14:33,000 --> 00:14:36,000
Αυτό είναι καλό, διότι αυτό σημαίνει ότι μπορώ να πω τώρα scanf

263
00:14:36,000 --> 00:14:39,000
εδώ είναι ένα πραγματικό κομμάτι της μνήμης.

264
00:14:39,000 --> 00:14:42,000
Μπορείτε να σκεφτείτε σχεδόν συστοιχίες ως δείκτες τώρα,

265
00:14:42,000 --> 00:14:44,000
ακόμα κι αν δεν είστε στην πραγματικότητα ισοδύναμη.

266
00:14:44,000 --> 00:14:47,000
Θα συμπεριφέρονται με διαφορετικό τρόπο σε διαφορετικά πλαίσια.

267
00:14:47,000 --> 00:14:50,000
Αλλά αυτό είναι σίγουρα η περίπτωση ότι ρυθμιστικό αναφορά

268
00:14:50,000 --> 00:14:53,000
16 συνεχόμενα χαρακτήρες, διότι αυτό είναι ένας πίνακας είναι

269
00:14:53,000 --> 00:14:55,000
και ήταν για μερικές εβδομάδες τώρα.

270
00:14:55,000 --> 00:14:59,000
>> Εδώ, λέω scanf εδώ είναι ένα κομμάτι της μνήμης.

271
00:14:59,000 --> 00:15:01,000
Αυτή τη φορά, είναι πραγματικά ένα κομμάτι της μνήμης,

272
00:15:01,000 --> 00:15:07,000
αλλά γιατί είναι αυτό το πρόγραμμα ακόμα εκμεταλλεύσιμο;

273
00:15:07,000 --> 00:15:11,000
Τι συμβαίνει ακόμα;

274
00:15:11,000 --> 00:15:14,000
Έχω πει να μου δώσει 16 byte, αλλά-

275
00:15:14,000 --> 00:15:16,000
[Φοιτητικό] Τι και αν πληκτρολογήσετε σε περισσότερες από 16;

276
00:15:16,000 --> 00:15:20,000
Ακριβώς, τι θα γίνει αν ο χρήστης πληκτρολογεί σε 17 χαρακτήρες ή χαρακτήρες 1700;

277
00:15:20,000 --> 00:15:23,000
Στην πραγματικότητα, ας δούμε αν μπορούμε να μην μπορεί να σκοντάψει σε αυτό το λάθος τώρα.

278
00:15:23,000 --> 00:15:25,000
Είναι καλύτερα, αλλά δεν είναι τέλεια.

279
00:15:25,000 --> 00:15:28,000
Επιτρέψτε μου να πάμε μπροστά και να τρέξει να scanf3 για την κατάρτιση αυτού του προγράμματος.

280
00:15:28,000 --> 00:15:34,000
Επιτρέψτε μου να τρέξει scanf3, παρακαλώ String: Γεια σας, και φαίνεται να είναι εντάξει.

281
00:15:34,000 --> 00:15:37,000
Επιτρέψτε μου να δοκιμάσετε ένα ελαφρώς μακρύτερο, γειά σου εκεί.

282
00:15:37,000 --> 00:15:42,000
Εντάξει, ας το κάνουμε hello there πώς είστε σήμερα, Enter.

283
00:15:42,000 --> 00:15:54,000
Να πάρει το είδος τυχερός εδώ, ας πούμε γεια εκεί τι κάνεις.

284
00:15:54,000 --> 00:15:56,000
Γαμώτο.

285
00:15:56,000 --> 00:16:03,000
Εντάξει, έτσι έχουμε τύχη. Ας δούμε αν δεν μπορούμε να το διορθώσετε αυτό.

286
00:16:03,000 --> 00:16:06,000
Όχι, δεν πρόκειται να με αφήσει να αντιγράψετε.

287
00:16:06,000 --> 00:16:09,000
Ας δοκιμάσουμε ξανά.

288
00:16:09,000 --> 00:16:12,000
Εντάξει, να σταθεί με.

289
00:16:12,000 --> 00:16:20,000
Θα δούμε πόσο καιρό μπορώ να προσποιηθώ να επικεντρωθεί, ενώ κάνει ακόμη αυτό.

290
00:16:20,000 --> 00:16:23,000
Γαμώτο. Αυτό είναι μάλλον σκόπιμο, στην πραγματικότητα.

291
00:16:23,000 --> 00:16:26,000
Εκεί εμείς πάμε.

292
00:16:26,000 --> 00:16:30,000
Σημείο έκανε.

293
00:16:30,000 --> 00:16:34,000
>> Αυτό, ενοχλητικό αν και είναι επίσης, είναι επίσης μία από τις πηγές της μεγάλη σύγχυση

294
00:16:34,000 --> 00:16:38,000
κατά τη σύνταξη των προγραμμάτων που έχουν σφάλματα, επειδή εκδηλώνονται

295
00:16:38,000 --> 00:16:40,000
μόνο μία φορά σε ένα ενώ μερικές φορές.

296
00:16:40,000 --> 00:16:43,000
Η πραγματικότητα είναι ότι, ακόμη και αν ο κωδικός σας είναι εντελώς σπασμένα,

297
00:16:43,000 --> 00:16:46,000
θα μπορούσε μόνο να σπάσει τελείως κάποια στιγμή

298
00:16:46,000 --> 00:16:49,000
γιατί μερικές φορές, κατ 'ουσίαν, αυτό που συμβαίνει είναι τα διαθέτει λειτουργικό σύστημα

299
00:16:49,000 --> 00:16:52,000
λίγο περισσότερη μνήμη από ό, τι πραγματικά χρειάζεται, για οποιονδήποτε λόγο,

300
00:16:52,000 --> 00:16:57,000
και έτσι κανένας άλλος δεν χρησιμοποιεί τη μνήμη αμέσως μετά κομμάτι σας από 16 χαρακτήρες,

301
00:16:57,000 --> 00:17:01,000
έτσι αν πας σε 17, 18, 19, όποια και αν είναι, δεν είναι μια τέτοια μεγάλη υπόθεση.

302
00:17:01,000 --> 00:17:04,000
Τώρα, ο υπολογιστής, ακόμη και αν δεν συντριβή σε αυτό το σημείο,

303
00:17:04,000 --> 00:17:09,000
μπορεί να χρησιμοποιήσει τελικά byte αριθμό 17 ή 18 ή 19 για κάτι άλλο,

304
00:17:09,000 --> 00:17:14,000
κατά την οποία τα δεδομένα σας επισημάνω ότι βάζετε εκεί, αν και υπερβολικά μακρύ,

305
00:17:14,000 --> 00:17:18,000
πρόκειται να πάρει αντικατασταθεί πιθανώς από κάποια άλλη λειτουργία.

306
00:17:18,000 --> 00:17:21,000
Δεν είναι κατ 'ανάγκην θα παραμείνει ανέπαφη,

307
00:17:21,000 --> 00:17:23,000
αλλά δεν θα προκαλέσει αναγκαστικά seg σφάλμα.

308
00:17:23,000 --> 00:17:26,000
Αλλά στην περίπτωση αυτή, θα παρέχεται τελικά αρκετά χαρακτήρες

309
00:17:26,000 --> 00:17:29,000
ότι υπερέβη ουσιαστικά τμήμα της μνήμης μου, και μπαμ,

310
00:17:29,000 --> 00:17:33,000
το λειτουργικό σύστημα είπε: «Συγγνώμη, αυτό δεν είναι καλό, σφάλμα κατάτμησης."

311
00:17:33,000 --> 00:17:38,000
>> Και ας δούμε τώρα αν αυτό που μένει εδώ μου σε κατάλογο-

312
00:17:38,000 --> 00:17:40,000
παρατηρήσετε ότι έχω αυτό το αρχείο, εδώ πυρήνα.

313
00:17:40,000 --> 00:17:42,000
Σημειώστε ότι αυτό ονομάζεται και πάλι μια χωματερή πυρήνα.

314
00:17:42,000 --> 00:17:46,000
Είναι ουσιαστικά ένα αρχείο που περιέχει το περιεχόμενο της μνήμης του προγράμματός σας

315
00:17:46,000 --> 00:17:48,000
στο σημείο όπου συνετρίβη,

316
00:17:48,000 --> 00:17:51,000
και μόνο για να δοκιμάσετε ένα μικρό παράδειγμα εδώ επιτρέψτε μου να πάω εδώ

317
00:17:51,000 --> 00:17:57,000
και να τρέξει gdb για scanf3 και στη συνέχεια, καθορίστε ένα τρίτο επιχείρημα που ονομάζεται πυρήνας,

318
00:17:57,000 --> 00:18:01,000
και παρατηρήσετε εδώ ότι αν λίστα τον κωδικό,

319
00:18:01,000 --> 00:18:06,000
θα είμαστε σε θέση, ως συνήθως, με το gdb για να αρχίσει το περπάτημα μέσα από αυτό το πρόγραμμα,

320
00:18:06,000 --> 00:18:10,000
και μπορώ να το τρέξει και το συντομότερο χτύπησα-όπως με την εντολή βήμα-gdb

321
00:18:10,000 --> 00:18:13,000
μόλις χτύπησα το δυνητικά προβληματικό γραμμή μετά από την πληκτρολόγηση σε μια τεράστια σειρά,

322
00:18:13,000 --> 00:18:16,000
Θα είμαι σε θέση να προσδιορίσει πραγματικά εδώ.

323
00:18:16,000 --> 00:18:19,000
Περισσότερα για το θέμα αυτό, όμως, στο τμήμα από την άποψη των βασικών χωματερές

324
00:18:19,000 --> 00:18:22,000
και τα παρόμοια, ώστε να μπορείτε πραγματικά να σακί γύρω στο εσωτερικό της χωματερής πυρήνα

325
00:18:22,000 --> 00:18:27,000
και να δούμε ποια γραμμή για το πρόγραμμα που απέτυχε.

326
00:18:27,000 --> 00:18:32,000
Οποιεσδήποτε ερωτήσεις σχετικά με δείκτες στη συνέχεια και για τις διευθύνσεις;

327
00:18:32,000 --> 00:18:36,000
Διότι σήμερα, θα πάμε για να αρχίσετε να παίρνετε ως δεδομένο ότι υπάρχουν αυτά τα πράγματα

328
00:18:36,000 --> 00:18:40,000
και γνωρίζουμε ακριβώς τι είναι.

329
00:18:40,000 --> 00:18:42,000
Ναι.

330
00:18:42,000 --> 00:18:46,000
>> [Φοιτητής] Πώς και δεν πρέπει να βάλετε ένα εμπορικό δίπλα στο μέρος-

331
00:18:46,000 --> 00:18:48,000
Καλή ερώτηση.

332
00:18:48,000 --> 00:18:51,000
Πώς έρχονται δεν είχα να θέσει ένα εμπορικό δίπλα στην παράταξη χαρακτήρα όπως έκανα και στο παρελθόν

333
00:18:51,000 --> 00:18:53,000
με το μεγαλύτερο μέρος των παραδειγμάτων μας;

334
00:18:53,000 --> 00:18:55,000
Η σύντομη απάντηση είναι συστοιχίες είναι λίγο ιδιαίτερη.

335
00:18:55,000 --> 00:18:59,000
Μπορείτε να σκεφτείτε ένα ρυθμιστικό σχεδόν όπως στην πραγματικότητα είναι μια διεύθυνση,

336
00:18:59,000 --> 00:19:03,000
και είναι ακριβώς έτσι συμβαίνει να είναι η υπόθεση ότι η πλατεία σημειογραφία βραχίονα

337
00:19:03,000 --> 00:19:06,000
είναι μια ευκολία, έτσι ώστε να μπορούμε να πάμε σε βραχίονα 0, κατηγορία 1,

338
00:19:06,000 --> 00:19:10,000
στήριγμα 2, χωρίς να χρειάζεται να χρησιμοποιήσει το συμβολισμό *.

339
00:19:10,000 --> 00:19:13,000
Αυτό είναι ένα κομμάτι από ένα λευκό ψέμα, διότι πίνακες και δείκτες

340
00:19:13,000 --> 00:19:17,000
είναι, στην πραγματικότητα, ένα λίγο διαφορετικό, αλλά μπορούν συχνά αλλά όχι πάντα να χρησιμοποιηθούν εναλλακτικά.

341
00:19:17,000 --> 00:19:21,000
Με λίγα λόγια, όταν μια συνάρτηση περιμένει ένα δείκτη σε ένα κομμάτι της μνήμης,

342
00:19:21,000 --> 00:19:24,000
μπορείτε είτε να δώσετε μια διεύθυνση που επέστρεψε από την malloc,

343
00:19:24,000 --> 00:19:29,000
και θα δούμε malloc και πάλι πριν από καιρό, ή μπορείτε να δώσετε το όνομα ενός πίνακα.

344
00:19:29,000 --> 00:19:32,000
Δεν έχουν να κάνουν με το εμπορικό και συστοιχίες, επειδή είναι ήδη

345
00:19:32,000 --> 00:19:34,000
κατ 'ουσίαν, όπως διευθύνσεις.

346
00:19:34,000 --> 00:19:36,000
Αυτή είναι η μία εξαίρεση.

347
00:19:36,000 --> 00:19:39,000
Οι αγκύλες κάνει τους ειδικούς.

348
00:19:39,000 --> 00:19:41,000
>> Θα μπορούσατε να βάλετε ένα εμπορικό δίπλα στο ρυθμιστικό;

349
00:19:41,000 --> 00:19:43,000
Όχι σε αυτή την περίπτωση.

350
00:19:43,000 --> 00:19:46,000
Αυτό δεν θα μπορούσε να λειτουργήσει, διότι, και πάλι, στην παρούσα υπόθεση γωνία

351
00:19:46,000 --> 00:19:49,000
όπου συστοιχίες δεν είναι αρκετά πραγματικά διευθύνσεις.

352
00:19:49,000 --> 00:19:54,000
Αλλά ίσως θα επανέλθουμε σε αυτό πριν από καιρό με άλλα παραδείγματα.

353
00:19:54,000 --> 00:19:56,000
Ας προσπαθήσουμε να λύσουμε ένα πρόβλημα εδώ.

354
00:19:56,000 --> 00:20:00,000
Έχουμε μια δομή δεδομένων που έχουμε χρησιμοποιήσει για κάποιο χρονικό διάστημα είναι γνωστή ως μια σειρά.

355
00:20:00,000 --> 00:20:02,000
Υπόθεση στο σημείο, αυτό είναι ό, τι ακριβώς έπρεπε.

356
00:20:02,000 --> 00:20:04,000
Αλλά συστοιχίες έχουν κάποια upsides και μειονεκτήματα.

357
00:20:04,000 --> 00:20:06,000
Οι πίνακες είναι ωραία γιατί;

358
00:20:06,000 --> 00:20:11,000
Τι είναι ένα πράγμα που σας αρέσει-στο βαθμό που σας αρέσει πίνακες-σχετικά με πίνακες;

359
00:20:11,000 --> 00:20:13,000
Τι είναι βολικό γι 'αυτούς; Τι είναι συναρπαστικό;

360
00:20:13,000 --> 00:20:18,000
Γιατί να τους εισαγάγει στην πρώτη θέση;

361
00:20:18,000 --> 00:20:20,000
Ναι.

362
00:20:20,000 --> 00:20:27,000
[Φοιτητικό] Μπορούν να αποθηκεύσει πολλά δεδομένα, και εσείς δεν χρειάζεται να χρησιμοποιήσετε ένα ολόκληρο πράγμα.

363
00:20:27,000 --> 00:20:29,000
Μπορείτε να χρησιμοποιήσετε μια ενότητα.

364
00:20:29,000 --> 00:20:32,000
Καλό, με μια σειρά μπορείτε να αποθηκεύσετε πολλά δεδομένα,

365
00:20:32,000 --> 00:20:35,000
και δεν πρέπει κατ 'ανάγκη να χρησιμοποιήσει όλα αυτά, ώστε να μπορείτε να overallocate,

366
00:20:35,000 --> 00:20:39,000
η οποία μπορεί να είναι βολικό, αν δεν ξέρετε εκ των προτέρων πόσα από κάτι να περιμένουν.

367
00:20:39,000 --> 00:20:41,000
>> GetString είναι ένα τέλειο παράδειγμα.

368
00:20:41,000 --> 00:20:44,000
GetString, γραμμένο από εμάς, δεν έχει καμία ιδέα για το πώς πολλοί χαρακτήρες να περιμένουν,

369
00:20:44,000 --> 00:20:48,000
έτσι το γεγονός ότι μπορούμε να διαθέσουν κομμάτια της συνεχούς μνήμης είναι καλή.

370
00:20:48,000 --> 00:20:51,000
Πίνακες λύσει ένα πρόβλημα, επίσης, είδαμε μερικές εβδομάδες πριν από την επιχείρηση

371
00:20:51,000 --> 00:20:54,000
όπου κωδικό σας αρχίζει να περιέρχεται σε κάτι πολύ κακοσχεδιασμένα.

372
00:20:54,000 --> 00:20:57,000
Υπενθυμίζουμε ότι έχω δημιουργήσει μια δομή που ονομάζεται David μαθητή,

373
00:20:57,000 --> 00:21:00,000
και στη συνέχεια, αυτό ήταν πραγματικά μια εναλλακτική λύση, αν και,

374
00:21:00,000 --> 00:21:04,000
να έχει μια μεταβλητή που ονομάζεται όνομα και μια άλλη μεταβλητή που ονομάζεται, νομίζω, το σπίτι,

375
00:21:04,000 --> 00:21:08,000
και μια άλλη μεταβλητή που ονομάζεται ID, διότι σε αυτή την ιστορία τότε θα ήθελα να εισαγάγει κάτι άλλο

376
00:21:08,000 --> 00:21:11,000
Rob αρέσει στο πρόγραμμα, έτσι αποφάσισε τότε να περιμένετε ένα λεπτό,

377
00:21:11,000 --> 00:21:13,000
Πρέπει να μετονομάσετε αυτές τις μεταβλητές.

378
00:21:13,000 --> 00:21:16,000
Ας το ονομάσουμε ορυχείο NAME1, ID1, House1.

379
00:21:16,000 --> 00:21:20,000
Ας το ονομάσουμε του Rob όνομα2, house2, ID2.

380
00:21:20,000 --> 00:21:22,000
Αλλά περιμένετε ένα λεπτό, στη συνέχεια, τι θα γίνει με τον Tommy;

381
00:21:22,000 --> 00:21:24,000
Στη συνέχεια, είχαμε τρεις μεταβλητές.

382
00:21:24,000 --> 00:21:27,000
Εισαγάγαμε κάποιος άλλος, τέσσερα σύνολα των μεταβλητών.

383
00:21:27,000 --> 00:21:30,000
Ο κόσμος άρχισε να πάρει βρώμικο πολύ γρήγορα,

384
00:21:30,000 --> 00:21:33,000
έτσι ώστε να εισαχθεί structs, και τι είναι συναρπαστικό για ένα struct;

385
00:21:33,000 --> 00:21:39,000
Τι κάνει ένα struct C σας επιτρέπει να κάνετε;

386
00:21:39,000 --> 00:21:42,000
Είναι πραγματικά δύσκολη σήμερα.

387
00:21:42,000 --> 00:21:44,000
Τι; >> [ακούγεται ανταπόκριση των φοιτητών]

388
00:21:44,000 --> 00:21:47,000
Ναι, ειδικά, typedef σας επιτρέπει να δημιουργήσετε ένα νέο τύπο δεδομένων,

389
00:21:47,000 --> 00:21:51,000
και struct, η λέξη-κλειδί struct, σας δίνει τη δυνατότητα να ενσωματώσουν

390
00:21:51,000 --> 00:21:54,000
εννοιολογικά συνδέονται κομμάτια των δεδομένων από κοινού

391
00:21:54,000 --> 00:21:56,000
και στη συνέχεια καλέστε τους κάτι σαν φοιτητής.

392
00:21:56,000 --> 00:21:58,000
>> Αυτό ήταν καλό, γιατί τώρα μπορούμε να μοντελοποιήσουμε

393
00:21:58,000 --> 00:22:03,000
πολύ περισσότερο είδος εννοιολογικά συνεπής η έννοια του φοιτητή σε μια μεταβλητή

394
00:22:03,000 --> 00:22:07,000
αντί να έχουν αυθαίρετα ένα για ένα συμβολοσειρά, μία για ένα ID, και ούτω καθεξής.

395
00:22:07,000 --> 00:22:10,000
Οι πίνακες είναι ωραία επειδή μας επιτρέπουν να ξεκινήσετε τον καθαρισμό κωδικό μας.

396
00:22:10,000 --> 00:22:13,000
Αλλά αυτό είναι ένα μειονέκτημα τώρα από μια σειρά;

397
00:22:13,000 --> 00:22:15,000
Τι δεν μπορείτε να κάνετε; Ναι.

398
00:22:15,000 --> 00:22:17,000
[Φοιτητικό] Θα πρέπει να ξέρετε πόσο μεγάλο είναι.

399
00:22:17,000 --> 00:22:19,000
Θα πρέπει να ξέρετε πόσο μεγάλο είναι, γι 'αυτό είναι το είδος του πόνου.

400
00:22:19,000 --> 00:22:21,000
Όσοι από εσάς με προηγούμενη εμπειρία στον προγραμματισμό γνωρίζουμε ότι σε πολλές γλώσσες,

401
00:22:21,000 --> 00:22:24,000
όπως η Java, μπορείτε να ζητήσετε από ένα κομμάτι της μνήμης, ειδικά μια σειρά,

402
00:22:24,000 --> 00:22:28,000
πόσο μεγάλη είναι σας, με το μήκος, την ιδιοκτησία, να το πω έτσι, και αυτό είναι πραγματικά βολικό.

403
00:22:28,000 --> 00:22:32,000
Στην C, δεν μπορείτε να καλέσετε ακόμη και strlen σε μία γενική σειρά

404
00:22:32,000 --> 00:22:35,000
strlen επειδή, όπως υποδηλώνει η λέξη, είναι μόνο για έγχορδα,

405
00:22:35,000 --> 00:22:39,000
και μπορείτε να υπολογίσετε το μήκος της συμβολοσειράς, λόγω αυτής της Σύμβασης Ανθρωπίνων

406
00:22:39,000 --> 00:22:43,000
να έχουν ένα \ 0, αλλά μια σειρά, πιο γενικά, είναι απλά ένα κομμάτι της μνήμης.

407
00:22:43,000 --> 00:22:46,000
Αν είναι μια σειρά από ints, εκεί δεν πρόκειται να είναι κάποιος ειδικός χαρακτήρας

408
00:22:46,000 --> 00:22:48,000
στο τέλος σας περιμένει.

409
00:22:48,000 --> 00:22:50,000
Θα πρέπει να θυμόμαστε το μήκος ενός πίνακα.

410
00:22:50,000 --> 00:22:54,000
Ένα άλλο μειονέκτημα του ενός πίνακα που εκτρέφονται στο κεφάλι του GetString ίδια.

411
00:22:54,000 --> 00:22:59,000
Τι άλλο μειονέκτημα μιας σειράς;

412
00:22:59,000 --> 00:23:01,000
Κύριε, μόνο εσείς και εγώ σήμερα.

413
00:23:01,000 --> 00:23:04,000
[Ακούγεται ανταπόκριση των φοιτητών] >> Είναι ό, τι;

414
00:23:04,000 --> 00:23:06,000
Είναι δηλωθεί στη στοίβα.

415
00:23:06,000 --> 00:23:09,000
Εντάξει, δήλωσε στη στοίβα. Γιατί δεν σας αρέσει αυτό;

416
00:23:09,000 --> 00:23:13,000
[Φοιτητικό] Επειδή παίρνει ξαναχρησιμοποιηθεί.

417
00:23:13,000 --> 00:23:15,000
Παίρνει επαναχρησιμοποιηθούν.

418
00:23:15,000 --> 00:23:18,000
Εντάξει, αν χρησιμοποιείτε έναν πίνακα για την κατανομή της μνήμης,

419
00:23:18,000 --> 00:23:21,000
δεν μπορείτε, για παράδειγμα, να επιστρέψει γιατί είναι στη στοίβα.

420
00:23:21,000 --> 00:23:23,000
Εντάξει, αυτό είναι ένα μειονέκτημα.

421
00:23:23,000 --> 00:23:25,000
Και τι θα λέγατε για ένα άλλο με μια σειρά;

422
00:23:25,000 --> 00:23:28,000
Όταν η κατανομή της, είστε το είδος του βιδωθεί αν χρειάζεστε περισσότερο χώρο

423
00:23:28,000 --> 00:23:30,000
από εκείνο συστοιχία έχει.

424
00:23:30,000 --> 00:23:34,000
>> Στη συνέχεια, εισάγαμε, ανάκληση, malloc, η οποία μας έδωσε τη δυνατότητα να κατανέμει δυναμικά μνήμη.

425
00:23:34,000 --> 00:23:37,000
Αλλά τι γίνεται αν έχουμε δοκιμάσει ένα διαφορετικό κόσμο εντελώς;

426
00:23:37,000 --> 00:23:40,000
Τι γίνεται αν θέλουμε να λύσουμε ένα ζευγάρι από αυτά τα προβλήματα

427
00:23:40,000 --> 00:23:45,000
έτσι αντί-στυλό μου έχει αποκοιμηθεί εδώ-

428
00:23:45,000 --> 00:23:51,000
τι θα γίνει αν εμείς αντί ήθελε να δημιουργήσει ουσιαστικά ένα κόσμο που δεν είναι πλέον σαν αυτό;

429
00:23:51,000 --> 00:23:56,000
Αυτή είναι μια συστοιχία, και, φυσικά, αυτό το είδος των επιδεινώνεται μόλις χτυπήσει το άκρο της διάταξης,

430
00:23:56,000 --> 00:24:00,000
και εγώ τώρα δεν έχουν πλέον χώρο για άλλο ακέραιο ή έναν άλλο χαρακτήρα.

431
00:24:00,000 --> 00:24:03,000
Τι θα συμβεί αν έχουμε είδους προληπτικά λένε καλά, γιατί δεν μπορούμε να χαλαρώσετε

432
00:24:03,000 --> 00:24:07,000
η απαίτηση ότι όλα αυτά τα κομμάτια της μνήμης είναι συνεχόμενες πλάτη με πλάτη,

433
00:24:07,000 --> 00:24:10,000
και γιατί όχι, όταν χρειάζομαι ένα int ή char ένα,

434
00:24:10,000 --> 00:24:12,000
απλά να μου δώσει χώρο για ένα από αυτά;

435
00:24:12,000 --> 00:24:14,000
Και όταν χρειάζομαι ένα άλλο, να μου δώσει ένα άλλο χώρο,

436
00:24:14,000 --> 00:24:16,000
και όταν χρειάζομαι ένα άλλο, να μου δώσει ένα άλλο χώρο.

437
00:24:16,000 --> 00:24:19,000
Το πλεονέκτημα του οποίου τώρα είναι ότι αν κάποιος άλλος

438
00:24:19,000 --> 00:24:21,000
παίρνει τη μνήμη πάνω από εδώ, δεν είναι μεγάλη υπόθεση.

439
00:24:21,000 --> 00:24:25,000
Θα πάρω αυτό το επιπλέον κομμάτι της μνήμης εδώ και στη συνέχεια αυτό.

440
00:24:25,000 --> 00:24:28,000
>> Τώρα, το μόνο αλιεύματα εδώ είναι ότι αυτό αισθάνεται σχεδόν σαν να έχω

441
00:24:28,000 --> 00:24:30,000
ένα σωρό διαφορετικές μεταβλητές.

442
00:24:30,000 --> 00:24:33,000
Αυτό μοιάζει με πέντε διαφορετικές μεταβλητές δυνητικά.

443
00:24:33,000 --> 00:24:36,000
Αλλά τι εάν θα κλέψουν μια ιδέα από χορδές

444
00:24:36,000 --> 00:24:41,000
σύμφωνα με την οποία έχουμε συνδέσει με κάποιο τρόπο αυτά τα πράγματα μαζί εννοιολογικά, τι και αν το έκανα αυτό;

445
00:24:41,000 --> 00:24:44,000
Αυτό είναι πολύ άσχημα που βέλος μου.

446
00:24:44,000 --> 00:24:46,000
Αλλά ας υποθέσουμε ότι κάθε μία από αυτές κομμάτια της μνήμης

447
00:24:46,000 --> 00:24:52,000
τόνισε την άλλη, και αυτός ο τύπος, ο οποίος δεν έχει δικαίωμα να αδερφό του,

448
00:24:52,000 --> 00:24:54,000
έχει καμία τέτοια βέλος.

449
00:24:54,000 --> 00:24:56,000
Αυτό είναι στην πραγματικότητα αυτό που ονομάζεται μια συνδεδεμένη λίστα.

450
00:24:56,000 --> 00:25:00,000
Πρόκειται για μια νέα δομή δεδομένων που μας επιτρέπει να διαθέσει ένα μεγάλο κομμάτι της μνήμης,

451
00:25:00,000 --> 00:25:03,000
τότε μια άλλη, τότε μια άλλη, τότε μια άλλη, κάθε φορά που θέλουμε

452
00:25:03,000 --> 00:25:07,000
κατά τη διάρκεια του προγράμματος, και θυμόμαστε ότι είμαστε όλοι με κάποιο τρόπο σχετίζονται με

453
00:25:07,000 --> 00:25:11,000
κυριολεκτικά από αλυσοποίηση μαζί τους, και κάναμε ότι εικονογραφικά εδώ με ένα βέλος.

454
00:25:11,000 --> 00:25:15,000
Αλλά σε κώδικα, τι θα είναι ο μηχανισμός μέσω του οποίου μπορείτε να συνδέσετε με κάποιο τρόπο,

455
00:25:15,000 --> 00:25:20,000
σχεδόν σαν Scratch, ένα κομμάτι σε ένα άλλο κομμάτι;

456
00:25:20,000 --> 00:25:22,000
Θα μπορούσαμε να χρησιμοποιήσουμε ένα δείκτη, έτσι δεν είναι;

457
00:25:22,000 --> 00:25:25,000
Επειδή πραγματικά το βέλος που πηγαίνει από το επάνω αριστερό τετράγωνο,

458
00:25:25,000 --> 00:25:31,000
αυτός ο τύπος εδώ σε αυτό το ένα, θα μπορούσε να περιέχει μέσα από αυτό το τετράγωνο

459
00:25:31,000 --> 00:25:34,000
όχι μόνο μερικά ints, όχι μόνο μερικά char, αλλά τι γίνεται αν έχω πραγματικά κατανέμονται

460
00:25:34,000 --> 00:25:37,000
λίγο επιπλέον χώρο, έτσι ώστε τώρα,

461
00:25:37,000 --> 00:25:41,000
καθένα από τα κομμάτια της μνήμης μου, ακόμα κι αν αυτό θα μου κοστίσει,

462
00:25:41,000 --> 00:25:45,000
τώρα μοιάζει λίγο πιο ορθογώνια, όπου ένα από τα κομμάτια της μνήμης

463
00:25:45,000 --> 00:25:47,000
χρησιμοποιείται για έναν αριθμό, όπως ο αριθμός 1,

464
00:25:47,000 --> 00:25:50,000
και στη συνέχεια, αν αυτός ο τύπος αποθηκεύει τον αριθμό 2,

465
00:25:50,000 --> 00:25:52,000
αυτό το άλλο κομμάτι της μνήμης που χρησιμοποιείται για ένα βέλος,

466
00:25:52,000 --> 00:25:54,000
ή πιο συγκεκριμένα, ένας δείκτης.

467
00:25:54,000 --> 00:25:59,000
Και ας υποθέσουμε ότι έχω αποθηκεύσει τον αριθμό 3 πάνω από εδώ, ενώ μπορώ να χρησιμοποιήσω αυτό το σημείο σε αυτόν τον τύπο,

468
00:25:59,000 --> 00:26:02,000
και τώρα αυτός ο τύπος, ας υποθέσουμε ότι θέλω μόνο τρία τέτοια κομμάτια της μνήμης.

469
00:26:02,000 --> 00:26:05,000
Θα χαράξουμε μια διαχωριστική γραμμή μέσα από αυτό, δείχνοντας μηδενική.

470
00:26:05,000 --> 00:26:07,000
Δεν υπάρχει καμία πρόσθετη χαρακτήρα.

471
00:26:07,000 --> 00:26:10,000
>> Πράγματι, αυτό είναι το πώς μπορούμε να πάμε για την εφαρμογή

472
00:26:10,000 --> 00:26:12,000
κάτι που ονομάζεται συνδεδεμένη λίστα.

473
00:26:12,000 --> 00:26:18,000
Μια συνδεδεμένη λίστα είναι μια νέα δομή δεδομένων, και αυτό είναι ένα σκαλοπάτι προς την κατεύθυνση

474
00:26:18,000 --> 00:26:21,000
πολύ πιό φανταχτερό δομές δεδομένων που αρχίζουν να λύσουν τα προβλήματα

475
00:26:21,000 --> 00:26:23,000
κατά μήκος των γραμμών του τύπου Facebook και το Google προβλήματα τύπου προβλήματα

476
00:26:23,000 --> 00:26:26,000
όπου έχετε τεράστια σύνολα δεδομένων, και πλέον δεν κόβει

477
00:26:26,000 --> 00:26:29,000
για να αποθηκεύσετε τα πάντα συνεχόμενα και να χρησιμοποιήσετε κάτι σαν γραμμική αναζήτηση

478
00:26:29,000 --> 00:26:31,000
ή ακόμη και κάτι σαν δυαδική αναζήτηση.

479
00:26:31,000 --> 00:26:33,000
Θέλετε ακόμα καλύτερες μέρες λειτουργίας.

480
00:26:33,000 --> 00:26:37,000
Στην πραγματικότητα, ένα από τα Ιερά Δισκοπότηρα θα μιλήσουμε αργότερα αυτή την εβδομάδα ή την επόμενη

481
00:26:37,000 --> 00:26:41,000
είναι ένας αλγόριθμος του οποίου χρόνου λειτουργίας είναι σταθερή.

482
00:26:41,000 --> 00:26:44,000
Με άλλα λόγια, λαμβάνει πάντα την ίδια ποσότητα του χρόνου δεν έχει σημασία

483
00:26:44,000 --> 00:26:47,000
πόσο μεγάλη είναι η είσοδος, και ότι θα είναι πράγματι συναρπαστικό,

484
00:26:47,000 --> 00:26:49,000
ακόμη περισσότερο από ό, τι κάτι λογαριθμική.

485
00:26:49,000 --> 00:26:51,000
Τι είναι αυτό στην οθόνη εδώ;

486
00:26:51,000 --> 00:26:55,000
Κάθε ένα από τα ορθογώνια είναι ακριβώς αυτό που μόλις έσυρε με το χέρι.

487
00:26:55,000 --> 00:26:59,000
Αλλά το πράγμα σε όλη τη διαδρομή για την αριστερά είναι μια ειδική μεταβλητή.

488
00:26:59,000 --> 00:27:02,000
Είναι πρόκειται να είναι ένα ενιαίο δείκτη, διότι η μία gotcha

489
00:27:02,000 --> 00:27:04,000
με μια συνδεδεμένη λίστα, όπως ονομάζονται αυτές οι δραστηριότητες,

490
00:27:04,000 --> 00:27:09,000
είναι ότι θα πρέπει να κολλήσει επάνω το ένα άκρο του συνδέεται με λίστα.

491
00:27:09,000 --> 00:27:13,000
>> Ακριβώς όπως και με μια σειρά, θα πρέπει να γνωρίζετε τη διεύθυνση του πρώτου char.

492
00:27:13,000 --> 00:27:15,000
Η ίδια συμφωνία για συνδεδεμένες λίστες.

493
00:27:15,000 --> 00:27:19,000
Θα πρέπει να γνωρίζετε την διεύθυνση του πρώτου κομμάτι της μνήμης

494
00:27:19,000 --> 00:27:25,000
επειδή από εκεί, μπορείτε να φτάσετε σε κάθε άλλη.

495
00:27:25,000 --> 00:27:27,000
Απαισιόδοξη.

496
00:27:27,000 --> 00:27:30,000
Τι τιμή πληρώνουμε γι 'αυτό ευελιξία με δυναμικά

497
00:27:30,000 --> 00:27:34,000
αρκετά μεγάλη δομή δεδομένων ότι αν χρειαζόμαστε όλο και περισσότερο μνήμη, πρόστιμο,

498
00:27:34,000 --> 00:27:37,000
διαθέτουν μόνο ένα ακόμη κομμάτι και σχεδιάστε ένα δείκτη από

499
00:27:37,000 --> 00:27:39,000
το παλιό με το νέο ουρά της λίστας;

500
00:27:39,000 --> 00:27:41,000
Ναι.

501
00:27:41,000 --> 00:27:43,000
[Φοιτητικό] Χρειάζονται περίπου δύο φορές πιο πολύ χώρο.

502
00:27:43,000 --> 00:27:45,000
Παίρνει το διπλάσιο χώρο, έτσι ώστε να είναι σίγουρα ένα μειονέκτημα, και έχουμε δει αυτό

503
00:27:45,000 --> 00:27:48,000
tradeoff πριν από το χρόνο και το χώρο και ευελιξία

504
00:27:48,000 --> 00:27:51,000
όπου από τώρα, δεν χρειαζόμαστε 32 bit για κάθε ένα από αυτούς τους αριθμούς.

505
00:27:51,000 --> 00:27:57,000
Χρειαζόμαστε πραγματικά 64, 32 για τον αριθμό και το 32 για το δείκτη.

506
00:27:57,000 --> 00:27:59,000
Αλλά hey, έχω 2 gigabytes μνήμης RAM.

507
00:27:59,000 --> 00:28:02,000
Η προσθήκη επιπλέον 32 bit εδώ και εδώ δεν φαίνεται ότι μεγάλο ζήτημα.

508
00:28:02,000 --> 00:28:05,000
Αλλά για μεγάλα σύνολα δεδομένων, προσθέτει σίγουρα μέχρι κυριολεκτικά τα διπλάσια.

509
00:28:05,000 --> 00:28:09,000
Τι άλλο μειονέκτημα τώρα, ή ό, τι χαρακτηριστικό δίνουμε επάνω,

510
00:28:09,000 --> 00:28:12,000
αν εμείς εκπροσωπούμε τους καταλόγους των πραγμάτων με μια συνδεδεμένη λίστα και όχι μια σειρά;

511
00:28:12,000 --> 00:28:14,000
[Φοιτητικό] Δεν μπορείτε να διασχίσουν προς τα πίσω.

512
00:28:14,000 --> 00:28:16,000
Δεν μπορείτε να διασχίσουν προς τα πίσω, έτσι είστε το είδος του βιδωθεί αν είστε με τα πόδια

513
00:28:16,000 --> 00:28:19,000
από αριστερά προς τα δεξιά χρησιμοποιώντας ένα βρόχο for ή ένα βρόχο, ενώ

514
00:28:19,000 --> 00:28:21,000
και τότε συνειδητοποιείς, «Ω, θέλω να πάω πίσω στην αρχή της λίστας."

515
00:28:21,000 --> 00:28:26,000
Δεν μπορείτε, επειδή μόνο οι δείκτες πάνε από αριστερά προς τα δεξιά, όπως δείχνουν τα βέλη.

516
00:28:26,000 --> 00:28:29,000
>> Τώρα, μπορείτε να θυμηθείτε την αρχή της λίστας με μια άλλη μεταβλητή,

517
00:28:29,000 --> 00:28:31,000
αλλά αυτό είναι μια πολυπλοκότητα που πρέπει να θυμάστε.

518
00:28:31,000 --> 00:28:35,000
Μια σειρά, δεν έχει σημασία πόσο μακριά θα πάτε, μπορείτε πάντα να κάνετε μείον, μείον, μείον, μείον

519
00:28:35,000 --> 00:28:37,000
και να επιστρέψετε από όπου ήρθατε.

520
00:28:37,000 --> 00:28:40,000
Τι άλλο μειονέκτημα εδώ; Ναι.

521
00:28:40,000 --> 00:28:43,000
[Ακούγεται ερώτηση φοιτητή]

522
00:28:43,000 --> 00:28:47,000
Θα μπορούσε, έτσι έχετε πραγματικά προτείνεται μόνο μια δομή δεδομένων που ονομάζεται μια διπλά συνδεδεμένη λίστα,

523
00:28:47,000 --> 00:28:50,000
και μάλιστα, θα προσθέσει ένα άλλο δείκτη για κάθε ένα από αυτά ορθογώνια

524
00:28:50,000 --> 00:28:53,000
που πηγαίνει προς την άλλη κατεύθυνση, η οποία ανάποδα

525
00:28:53,000 --> 00:28:55,000
τώρα μπορείτε να διασχίσει εμπρός και πίσω,

526
00:28:55,000 --> 00:28:59,000
το μειονέκτημα της οποίας είναι τώρα είστε χρησιμοποιώντας τρεις φορές το μέγεθος της μνήμης που θα χρησιμοποιείται για

527
00:28:59,000 --> 00:29:04,000
και προσθέτοντας επίσης την πολυπλοκότητα όσον αφορά τον κώδικα που πρέπει να γράψετε για να το κάνετε σωστά.

528
00:29:04,000 --> 00:29:08,000
Αλλά όλα αυτά είναι ίσως πολύ λογική τήρησης ισορροπιών, αν η αντιστροφή είναι πιο σημαντικό.

529
00:29:08,000 --> 00:29:10,000
Ναι.

530
00:29:10,000 --> 00:29:12,000
[Φοιτητικό] Μπορείτε, επίσης, δεν μπορεί να έχει ένα 2D συνδεδεμένη λίστα.

531
00:29:12,000 --> 00:29:16,000
Καλό, δεν μπορείτε να έχετε πραγματικά ένα 2D συνδεδεμένη λίστα.

532
00:29:16,000 --> 00:29:18,000
Θα μπορούσατε. Δεν είναι σχεδόν τόσο εύκολο όσο μια σειρά.

533
00:29:18,000 --> 00:29:21,000
Όπως και μια σειρά, να κάνετε ανοιχτό βραχίονα, κλειστή γωνία, ανοιχτό βραχίονα κλειστό βραχίονα,

534
00:29:21,000 --> 00:29:23,000
και μπορείτε να πάρετε κάποια 2-τρισδιάστατη δομή.

535
00:29:23,000 --> 00:29:26,000
Θα μπορούσε να εφαρμόσει μια 2-διαστάσεων συνδεδεμένη λίστα

536
00:29:26,000 --> 00:29:29,000
αν το κάνετε add-όπως προτείνεται-ένα τρίτο δείκτη σε κάθε ένα από αυτά τα πράγματα,

537
00:29:29,000 --> 00:29:34,000
και αν νομίζετε ότι για μια άλλη λίστα που έρχονται σε 3D στυλ σας

538
00:29:34,000 --> 00:29:40,000
από την οθόνη σε όλους μας, το οποίο είναι ακριβώς μια άλλη αλυσίδα κάποιου είδους.

539
00:29:40,000 --> 00:29:45,000
Θα μπορούσαμε να το κάνουμε, αλλά δεν είναι τόσο απλή όσο η πληκτρολόγηση ανοιχτό βραχίονα, αγκύλη. Ναι.

540
00:29:45,000 --> 00:29:48,000
[Ακούγεται ερώτηση φοιτητή]

541
00:29:48,000 --> 00:29:50,000
Καλό, έτσι αυτό είναι μια πραγματική kicker.

542
00:29:50,000 --> 00:29:54,000
>> Αυτοί οι αλγόριθμοι που έχουμε pined πάνω, όπως OH, δυαδική αναζήτηση,

543
00:29:54,000 --> 00:29:57,000
μπορείτε να αναζητήσετε μια σειρά από αριθμούς στον πίνακα

544
00:29:57,000 --> 00:30:01,000
ή ένα βιβλίο τηλέφωνο τόσο πιο γρήγορα αν χρησιμοποιείτε διαίρει και βασίλευε

545
00:30:01,000 --> 00:30:05,000
και ένα δυαδικό αλγόριθμο αναζήτησης, αλλά δυαδική αναζήτηση απαιτεί δύο υποθέσεις.

546
00:30:05,000 --> 00:30:09,000
Ένα, ότι τα δεδομένα ήταν ταξινομημένο.

547
00:30:09,000 --> 00:30:11,000
Τώρα, μπορούμε προφανώς να κρατήσει αυτή η ταξινόμηση,

548
00:30:11,000 --> 00:30:14,000
οπότε ίσως αυτό δεν είναι μια ανησυχία, αλλά δυαδική αναζήτηση και υποτίθεται

549
00:30:14,000 --> 00:30:18,000
ότι είχατε τυχαία πρόσβαση στη λίστα των αριθμών,

550
00:30:18,000 --> 00:30:21,000
και μια σειρά σας επιτρέπει να έχετε πρόσβαση τυχαία, και με τυχαία πρόσβαση,

551
00:30:21,000 --> 00:30:24,000
Θέλω να πω, αν σας δίνεται μια σειρά, πόσο χρόνο χρειάζεται για να πάρετε

552
00:30:24,000 --> 00:30:26,000
για να φτάσετε στο βραχίονα 0;

553
00:30:26,000 --> 00:30:29,000
Μια λειτουργία, μπορείτε να χρησιμοποιήσετε μόνο [0] και είσαι εκεί.

554
00:30:29,000 --> 00:30:33,000
Πόσα βήματα χρειάζονται για να φτάσετε στο σημείο 10;

555
00:30:33,000 --> 00:30:36,000
Ένα βήμα, απλά πηγαίνετε στο [10] και είσαι εκεί.

556
00:30:36,000 --> 00:30:40,000
Αντίθετα, πώς να φτάσετε στο 10ο ακέραιο σε μια συνδεδεμένη λίστα;

557
00:30:40,000 --> 00:30:42,000
Θα πρέπει να ξεκινήσουμε από την αρχή, επειδή είστε μόνο να θυμόμαστε

558
00:30:42,000 --> 00:30:45,000
η αρχή μιας συνδεδεμένη λίστα, ακριβώς όπως μια χορδή να θυμόμαστε

559
00:30:45,000 --> 00:30:48,000
από την διεύθυνση της πρώτης char του, και να διαπιστώσετε ότι 10ης int

560
00:30:48,000 --> 00:30:53,000
ή ότι 10ης χαρακτήρα σε μια σειρά, θα πρέπει να αναζητήσετε το σύνολο πράγμα βλασφημίας.

561
00:30:53,000 --> 00:30:55,000
>> Και πάλι, δεν είμαστε επίλυση όλων των προβλημάτων μας.

562
00:30:55,000 --> 00:31:00,000
Είμαστε εισαγωγή νέων, αλλά αυτό εξαρτάται πραγματικά από το τι προσπαθείτε να σχεδιάσει για.

563
00:31:00,000 --> 00:31:04,000
Όσον αφορά την εφαρμογή της παρούσας, μπορούμε να δανειστούμε μια ιδέα από την δομή των φοιτητών.

564
00:31:04,000 --> 00:31:07,000
Η σύνταξη είναι πολύ παρόμοια, εκτός από τώρα, η ιδέα είναι λίγο πιο αφηρημένη

565
00:31:07,000 --> 00:31:09,000
από το σπίτι και το όνομα και ταυτότητα.

566
00:31:09,000 --> 00:31:13,000
Αλλά προτείνω ότι θα μπορούσαμε να έχουμε μια δομή δεδομένων σε C

567
00:31:13,000 --> 00:31:17,000
που ονομάζεται κόμβος, καθώς η τελευταία λέξη για τη διαφάνεια προτείνει,

568
00:31:17,000 --> 00:31:21,000
μέσα από έναν κόμβο, και ένας κόμβος είναι απλά ένας γενικός δοχείο στην επιστήμη των υπολογιστών.

569
00:31:21,000 --> 00:31:25,000
Είναι συνήθως συντάσσεται ως ένα κύκλο ή ένα τετράγωνο ή ορθογώνιο, όπως έχουμε κάνει.

570
00:31:25,000 --> 00:31:27,000
Και σε αυτή τη δομή δεδομένων, έχουμε έναν int, n,

571
00:31:27,000 --> 00:31:29,000
έτσι ώστε να είναι ο αριθμός που θέλετε να αποθηκεύσετε.

572
00:31:29,000 --> 00:31:36,000
Αλλά τι είναι αυτή η δεύτερη γραμμή, struct node * το επόμενο βήμα;

573
00:31:36,000 --> 00:31:40,000
Γιατί αυτό είναι σωστό, ή τι ρόλο έχει παίξει αυτό το πράγμα,

574
00:31:40,000 --> 00:31:42,000
ακόμα κι αν είναι λίγο αινιγματικό με την πρώτη ματιά;

575
00:31:42,000 --> 00:31:44,000
Ναι.

576
00:31:44,000 --> 00:31:46,000
[Ακούγεται ανταπόκριση των φοιτητών]

577
00:31:46,000 --> 00:31:50,000
Ακριβώς, έτσι ώστε το είδος της λάφυρα * ότι είναι ένας δείκτης κάποιου είδους.

578
00:31:50,000 --> 00:31:53,000
Το όνομα αυτού του δείκτη είναι αυθαίρετα επόμενο,

579
00:31:53,000 --> 00:32:00,000
αλλά θα μπορούσαμε να έχουμε κάτι που ονομάζεται το θέλουμε, αλλά τι κάνει αυτό το σημείο δείκτη;

580
00:32:00,000 --> 00:32:03,000
[Φοιτητικό] Ένα άλλο κόμβο. >> Ακριβώς, επισημαίνει σε άλλο τέτοιο κόμβο.

581
00:32:03,000 --> 00:32:05,000
>> Τώρα, αυτό είναι ένα είδος περιέργεια του C.

582
00:32:05,000 --> 00:32:09,000
Υπενθυμίζουμε ότι η C διαβάζεται από πάνω προς τα κάτω compiler, αριστερά προς τα δεξιά,

583
00:32:09,000 --> 00:32:13,000
το οποίο σημαίνει ότι αν αυτό-είναι λίγο διαφορετικό από αυτό που κάναμε με τον μαθητή.

584
00:32:13,000 --> 00:32:16,000
Όταν ορίζεται ένας φοιτητής, που στην πραγματικότητα δεν έθεσε μια λέξη.

585
00:32:16,000 --> 00:32:18,000
Απλώς είπε typedef.

586
00:32:18,000 --> 00:32:20,000
Τότε είχαμε int id, όνομα συμβολοσειράς, string σπίτι,

587
00:32:20,000 --> 00:32:23,000
και ακολούθως φοιτητής στο πυθμένα του struct.

588
00:32:23,000 --> 00:32:26,000
Η δήλωση αυτή είναι λίγο διαφορετική, διότι,

589
00:32:26,000 --> 00:32:28,000
πάλι, η C compiler είναι λίγο χαζή.

590
00:32:28,000 --> 00:32:30,000
Είναι μόνο πρόκειται να διαβάσετε πάνω προς τα κάτω,

591
00:32:30,000 --> 00:32:33,000
οπότε αν φτάσει στη 2η γραμμή εδώ

592
00:32:33,000 --> 00:32:37,000
όπου δηλώνεται δίπλα και βλέπει, OH, εδώ είναι μια μεταβλητή που ονομάζεται επόμενο.

593
00:32:37,000 --> 00:32:39,000
Είναι ένας δείκτης σε κόμβο struct.

594
00:32:39,000 --> 00:32:42,000
Ο μεταγλωττιστής πρόκειται να συνειδητοποιήσει τι είναι ένας κόμβος struct;

595
00:32:42,000 --> 00:32:44,000
Δεν έχω ακούσει για αυτό το πράγμα πριν,

596
00:32:44,000 --> 00:32:47,000
επειδή ο κόμβος λέξη μπορεί να μην εμφανίζονται διαφορετικά

597
00:32:47,000 --> 00:32:49,000
μέχρι τον πυθμένα, έτσι δεν υπάρχει αυτή η πλεονασμό.

598
00:32:49,000 --> 00:32:53,000
Θα πρέπει να πω εδώ struct node, το οποίο μπορείτε στη συνέχεια να μειωθεί αργότερα

599
00:32:53,000 --> 00:32:56,000
χάρη στην typedef εδώ κάτω, αλλά αυτό είναι επειδή

600
00:32:56,000 --> 00:33:02,000
είμαστε αναφορά ίδια την δομή εσωτερικό της δομής.

601
00:33:02,000 --> 00:33:05,000
Αυτό είναι το ένα gotcha εκεί.

602
00:33:05,000 --> 00:33:07,000
>> Μερικά ενδιαφέροντα προβλήματα που θα προκύψουν.

603
00:33:07,000 --> 00:33:09,000
Έχουμε μια λίστα των αριθμών. Πώς μπορούμε να εισάγετε σε αυτό;

604
00:33:09,000 --> 00:33:11,000
Πώς μπορούμε να το ψάξει; Πώς μπορούμε να διαγράψετε από αυτό;

605
00:33:11,000 --> 00:33:13,000
Ειδικά τώρα που έχουμε να διαχειριστεί όλες αυτές τις υποδείξεις.

606
00:33:13,000 --> 00:33:15,000
Νομίζατε ότι ήταν δείκτες είδος της μυαλό κάμψης

607
00:33:15,000 --> 00:33:17,000
όταν είχε ένα από αυτά ακριβώς που προσπαθεί να διαβάσει ένα int σε αυτό.

608
00:33:17,000 --> 00:33:20,000
Τώρα έχουμε να χειραγωγήσουν αξίζει μιας ολόκληρης λίστας.

609
00:33:20,000 --> 00:33:22,000
Γιατί δεν παίρνουμε 5-λεπτά διάλειμμα μας εδώ, και στη συνέχεια θα φέρει

610
00:33:22,000 --> 00:33:34,000
μερικοί λαοί πάνω στη σκηνή για να κάνει ακριβώς αυτό.

611
00:33:34,000 --> 00:33:36,000
>> C είναι πολύ πιο διασκεδαστικό όταν είναι ενεργήσει έξω.

612
00:33:36,000 --> 00:33:39,000
Ποιος θα ήθελε κυριολεκτικά να είναι η πρώτη;

613
00:33:39,000 --> 00:33:41,000
Εντάξει, έλα επάνω. Είστε πρώτα.

614
00:33:41,000 --> 00:33:44,000
Ποιος θα ήθελε να είναι 9; Εντάξει, 9.

615
00:33:44,000 --> 00:33:46,000
Πόσο περίπου 9; 17;

616
00:33:46,000 --> 00:33:51,000
Μια μικρή κλίκα εδώ. 22 και 26 στην εν λόγω πρώτη σειρά.

617
00:33:51,000 --> 00:33:53,000
Και τότε πώς για κάποιον εκεί που επισήμανε σε.

618
00:33:53,000 --> 00:33:57,000
Είστε 34. Εντάξει, 34, έλα επάνω.

619
00:33:57,000 --> 00:33:59,000
Πρώτη είναι εκεί πέρα. Εντάξει, και οι τέσσερις από σας παιδιά.

620
00:33:59,000 --> 00:34:01,000
Και ποιος δεν λέμε για 9;

621
00:34:01,000 --> 00:34:04,000
Ποιος είναι 9 μας;

622
00:34:04,000 --> 00:34:07,000
Ποιος θέλει πραγματικά να είναι 9; Εντάξει, έλα, είναι 9.

623
00:34:07,000 --> 00:34:10,000
Εδώ πάμε.

624
00:34:10,000 --> 00:34:13,000
34, θα σας συναντήσω εκεί.

625
00:34:13,000 --> 00:34:17,000
Το πρώτο μέρος είναι να κάνει τον εαυτό σας να μοιάζει με αυτό.

626
00:34:17,000 --> 00:34:21,000
26, 22, 17, καλό.

627
00:34:21,000 --> 00:34:25,000
Αν μπορείτε να σταθείτε στο πλάι, γιατί θα πάμε για να σας malloc σε μια στιγμή.

628
00:34:25,000 --> 00:34:29,000
>> Ωραία, ωραία.

629
00:34:29,000 --> 00:34:32,000
Εντάξει, εξαιρετική, οπότε ας ρωτήσω μερικές ερωτήσεις εδώ.

630
00:34:32,000 --> 00:34:34,000
Και στην πραγματικότητα, αυτό που είναι το όνομά σου; >> Anita.

631
00:34:34,000 --> 00:34:37,000
Anita, εντάξει, έλα εδώ.

632
00:34:37,000 --> 00:34:41,000
Anita πρόκειται να μας βοηθήσει είδος επίλυση ενός αρκετά απλή ερώτηση στην πρώτη,

633
00:34:41,000 --> 00:34:44,000
το οποίο είναι το πώς μπορείτε να βρείτε αν ή όχι η τιμή είναι στη λίστα;

634
00:34:44,000 --> 00:34:48,000
Τώρα, παρατηρούμε ότι η πρώτη, που εκπροσωπείται εδώ από τον Lucas,

635
00:34:48,000 --> 00:34:52,000
είναι λίγο διαφορετική, και έτσι κομμάτι του χαρτί είναι σκόπιμα πλάγια

636
00:34:52,000 --> 00:34:55,000
επειδή δεν είναι αρκετά ψηλό, όπως και δεν λαμβάνει ως πολλά κομμάτια,

637
00:34:55,000 --> 00:34:58,000
παρόλο που τεχνικά έχει το ίδιο μέγεθος χαρτιού μόνο περιστρέφεται.

638
00:34:58,000 --> 00:35:01,000
Αλλά είναι λίγο διαφορετικό στο ότι αυτός είναι μόνο 32 bits για ένα δείκτη,

639
00:35:01,000 --> 00:35:05,000
και όλα αυτά τα παιδιά είναι 64 bits, το ήμισυ των οποίων είναι ο αριθμός, το ήμισυ του οποίου είναι ένας δείκτης.

640
00:35:05,000 --> 00:35:08,000
Αλλά ο δείκτης δεν απεικονίζεται, οπότε αν εσείς θα μπορούσε κάπως αδέξια

641
00:35:08,000 --> 00:35:12,000
χρησιμοποιήστε το αριστερό σας χέρι να το σημείο στο πρόσωπο δίπλα σε σας.

642
00:35:12,000 --> 00:35:14,000
Και είστε αριθμό 34. Ποιο είναι το όνομά σου;

643
00:35:14,000 --> 00:35:16,000
Ari.

644
00:35:16,000 --> 00:35:19,000
Ari, έτσι στην πραγματικότητα, κρατήστε το χαρτί στο δεξί σας χέρι, το αριστερό χέρι και πηγαίνει κατ 'ευθείαν προς τα κάτω.

645
00:35:19,000 --> 00:35:21,000
Δηλώνετε null στα αριστερά.

646
00:35:21,000 --> 00:35:24,000
>> Τώρα ανθρώπινη εικόνα μας είναι πολύ συνεπής.

647
00:35:24,000 --> 00:35:26,000
Αυτό είναι στην πραγματικότητα το πώς δείκτες εργασία.

648
00:35:26,000 --> 00:35:29,000
Και αν μπορείτε να τραγανίζω λίγο με αυτόν τον τρόπο, έτσι δεν είμαι στο δρόμο σας.

649
00:35:29,000 --> 00:35:34,000
Anita εδώ, βρείτε μου τον αριθμό 22,

650
00:35:34,000 --> 00:35:40,000
αλλά υποθέτουν έναν περιορισμό των ανθρώπων δεν κρατά ψηλά κομμάτια από χαρτί,

651
00:35:40,000 --> 00:35:43,000
αλλά αυτό είναι μια λίστα, και το μόνο που πρέπει Lucas για να αρχίσει με

652
00:35:43,000 --> 00:35:46,000
επειδή είναι κυριολεκτικά η πρώτη δείκτη.

653
00:35:46,000 --> 00:35:51,000
Ας υποθέσουμε ότι εσείς ο ίδιος είναι ένας δείκτης, και έτσι έχετε πολύ τη δυνατότητα να επισημάνει κάτι.

654
00:35:51,000 --> 00:35:56,000
Γιατί δεν ξεκινάτε δείχνοντας ακριβώς τι Lucas είναι στραμμένο προς;

655
00:35:56,000 --> 00:35:58,000
Καλό, και επιτρέψτε μου να θεσπίσει αυτό από εδώ.

656
00:35:58,000 --> 00:36:04,000
Απλά για χάρη της συζήτησης, επιτρέψτε μου να σηκώσει μια κενή σελίδα εδώ.

657
00:36:04,000 --> 00:36:06,000
Πώς μπορείτε να πείτε το όνομά σας; >> Anita.

658
00:36:06,000 --> 00:36:08,000
Εντάξει, Anita.

659
00:36:08,000 --> 00:36:18,000
Ας πούμε ότι ο κόμβος * anita = Lucas.

660
00:36:18,000 --> 00:36:22,000
Λοιπόν, δεν θα πρέπει να σας καλέσει lucas. Θα πρέπει να καλέσετε εσείς πρώτα.

661
00:36:22,000 --> 00:36:25,000
Γιατί αυτό είναι στην πραγματικότητα συνάδει με την πραγματικότητα εδώ;

662
00:36:25,000 --> 00:36:27,000
Ένα πρώτο υπάρχει ήδη.

663
00:36:27,000 --> 00:36:30,000
Πρώτον έχει διατεθεί κατά πάσα πιθανότητα κάπου εδώ.

664
00:36:30,000 --> 00:36:35,000
Κόμβος * πρώτα, και είναι ήδη διατεθεί μια λίστα με κάποιο τρόπο.

665
00:36:35,000 --> 00:36:37,000
Δεν ξέρω πώς συνέβη αυτό. Αυτό συνέβη πριν το μάθημα ξεκινήσει.

666
00:36:37,000 --> 00:36:40,000
Αυτή η συνδεδεμένη λίστα των ανθρώπων έχει δημιουργηθεί.

667
00:36:40,000 --> 00:36:44,000
Και τώρα σε αυτό το σημείο στην ιστορία, αυτό είναι όλο πρόκειται στο Facebook προφανώς αργότερα-

668
00:36:44,000 --> 00:36:49,000
σε αυτό το σημείο στην ιστορία, Anita έχει προετοιμαστεί για να είναι ίση με την πρώτη,

669
00:36:49,000 --> 00:36:51,000
το οποίο δεν σημαίνει ότι Anita σημεία στο Lucas.

670
00:36:51,000 --> 00:36:53,000
Αντίθετα, επισημαίνει σε αυτό που δείχνει στο

671
00:36:53,000 --> 00:36:57,000
επειδή η ίδια διεύθυνση που είναι μέσα των 32 bits του Lucas - 1, 2, 3 -

672
00:36:57,000 --> 00:37:01,000
Είναι τώρα επίσης στο εσωτερικό του 32 Ανίτας bits - 1, 2, 3.

673
00:37:01,000 --> 00:37:05,000
>> Τώρα βρείτε 22. Πώς θα μπορείτε να κάνετε για αυτό;

674
00:37:05,000 --> 00:37:07,000
Τι είναι αυτό; >> Point για οτιδήποτε άλλο.

675
00:37:07,000 --> 00:37:11,000
Τοποθετήστε το δείκτη στο οτιδήποτε, έτσι ώστε να προχωρήσει και να ενεργούν έξω όσο καλύτερα μπορείτε εδώ.

676
00:37:11,000 --> 00:37:15,000
Καλό, καλό, και τώρα είστε δείχνοντας-τι είναι το όνομά σας με 22;

677
00:37:15,000 --> 00:37:18,000
Ραμόν. >> Ramon, έτσι Ramon κρατάει μέχρι 22.

678
00:37:18,000 --> 00:37:20,000
Έχετε κάνει τώρα μια επιταγή.

679
00:37:20,000 --> 00:37:24,000
Μήπως Ramon == 22, και αν ναι, για παράδειγμα, μπορούμε να επιστρέψουμε αλήθεια.

680
00:37:24,000 --> 00:37:26,000
Επιτρέψτε μου-ενώ αυτοί οι τύποι στέκονται εδώ κάπως αδέξια-

681
00:37:26,000 --> 00:37:32,000
επιτρέψτε μου να κάνω κάτι γρήγορα, όπως bool βρείτε.

682
00:37:32,000 --> 00:37:37,000
Πάω να προχωρήσει και να πω (κόμβος λίστα *, int n).

683
00:37:37,000 --> 00:37:39,000
Θα είμαι πίσω δεξιά με σας παιδιά. Απλώς πρέπει να γράψετε κάποιο κώδικα.

684
00:37:39,000 --> 00:37:45,000
Και τώρα είμαι πρόκειται να πάει μπροστά και να το κάνετε αυτό, ο κόμβος * = anita λίστα.

685
00:37:45,000 --> 00:37:51,000
Και εγώ είμαι πρόκειται να πάει μπροστά και να πει, ενώ (anita! = NULL).

686
00:37:51,000 --> 00:37:57,000
>> Η μεταφορά εδώ είναι να πάρει λίγο τεντωμένα, αλλά παράλληλα (anita! = NULL), τι θέλω να κάνω;

687
00:37:57,000 --> 00:38:03,000
Χρειάζομαι κάποιο τρόπο αναφορά

688
00:38:03,000 --> 00:38:05,000
ο ακέραιος ότι Anita δείχνει σε.

689
00:38:05,000 --> 00:38:08,000
Στο παρελθόν, όταν είχαμε δομές, το οποίο είναι ένας κόμβος,

690
00:38:08,000 --> 00:38:11,000
χρησιμοποιήσαμε το συμβολισμό τελεία, και θα λέγαμε κάτι σαν

691
00:38:11,000 --> 00:38:15,000
anita.n, αλλά το πρόβλημα εδώ είναι ότι δεν Anita είναι ένα struct per se.

692
00:38:15,000 --> 00:38:17,000
Τι είναι;

693
00:38:17,000 --> 00:38:21,000
Είναι ένας δείκτης, τόσο πραγματικά, αν θέλουμε να χρησιμοποιήσουμε αυτό το συμβολισμό dot-

694
00:38:21,000 --> 00:38:23,000
και αυτό πρόκειται να δούμε σκόπιμα λίγο αινιγματικό-

695
00:38:23,000 --> 00:38:28,000
πρέπει να κάνουμε κάτι για να πάνε χέρι αριστερά Anita ό, τι είναι να υποδεικνύουν

696
00:38:28,000 --> 00:38:31,000
και να πάρει στη συνέχεια το πεδίο που ονομάζεται n.

697
00:38:31,000 --> 00:38:35,000
Anita είναι ένας δείκτης, αλλά είναι ό, τι * anita;

698
00:38:35,000 --> 00:38:38,000
Τι θα βρείτε όταν θα πάτε σε ό, τι Anita είναι στραμμένο προς;

699
00:38:38,000 --> 00:38:42,000
Ένα struct, ένας κόμβος, και ένας κόμβος, ανάκληση, έχει ένα πεδίο που ονομάζεται n

700
00:38:42,000 --> 00:38:47,000
γιατί έχει, θυμάμαι, αυτά τα 2 πεδία, δίπλα και n,

701
00:38:47,000 --> 00:38:50,000
που είδαμε πριν από λίγο εδώ.

702
00:38:50,000 --> 00:38:53,000
>> Για να μιμηθούν την πραγματικότητα αυτή σε κώδικα,

703
00:38:53,000 --> 00:39:02,000
θα μπορούσαμε να το κάνουμε αυτό και να πω εάν ((* anita). == n n), το n που ψάχνω.

704
00:39:02,000 --> 00:39:04,000
Σημειώστε ότι η λειτουργία ψηφίστηκε ο αριθμός νοιάζει.

705
00:39:04,000 --> 00:39:10,000
Στη συνέχεια, μπορώ να πάω μπροστά και να κάνουμε κάτι σαν επιστροφή αλήθεια.

706
00:39:10,000 --> 00:39:12,000
Αλλιώς, αν αυτό δεν είναι η περίπτωση, αυτό που θέλω να κάνω;

707
00:39:12,000 --> 00:39:19,000
Πώς μπορώ να μεταφράσει κώδικα Τι Anita έκανε ενστικτωδώς με τα πόδια μέσα από την λίστα;

708
00:39:19,000 --> 00:39:26,000
Τι πρέπει να κάνω εδώ την προσομοίωση Anita λαμβάνοντας αυτό το βήμα προς τα αριστερά, αυτό το βήμα προς τα αριστερά;

709
00:39:26,000 --> 00:39:28,000
[Ακούγεται ανταπόκριση των φοιτητών] >> Τι είναι αυτό;

710
00:39:28,000 --> 00:39:30,000
[Ακούγεται ανταπόκριση των φοιτητών]

711
00:39:30,000 --> 00:39:34,000
Καλό, δεν είναι κακή ιδέα, αλλά και στο παρελθόν, όταν έχουμε κάνει αυτό, έχουμε κάνει anita + +

712
00:39:34,000 --> 00:39:37,000
γιατί αυτό θα προσθέσετε τον αριθμό 1 έως Anita,

713
00:39:37,000 --> 00:39:40,000
η οποία τυπικά θα το σημείο στο επόμενο πρόσωπο, όπως Ramon,

714
00:39:40,000 --> 00:39:44,000
ή το πρόσωπο δίπλα του, ή ο δίπλα του προσώπου κάτω από τη γραμμή.

715
00:39:44,000 --> 00:39:49,000
Αλλά αυτό δεν είναι αρκετά καλό, διότι εδώ τι σημαίνει αυτό το πράγμα μοιάζει στη μνήμη;

716
00:39:49,000 --> 00:39:54,000
Δεν είναι αυτό. Πρέπει να την απενεργοποιήσετε.

717
00:39:54,000 --> 00:40:00,000
Μοιάζει με αυτό στη μνήμη, και παρόλο που έχω σχεδιάσει 1 και 2 και 3 κοντά το ένα στο άλλο,

718
00:40:00,000 --> 00:40:03,000
αν θέλουμε πραγματικά να προσομοιώνουν αυτό-μπορεί να σας παιδιά, ενώ εξακολουθούν να δείχνουν στα ίδια τα άτομα,

719
00:40:03,000 --> 00:40:07,000
μπορεί κάποιοι από εσάς να λάβει ένα τυχαίο βήμα πίσω, κάποια από εσάς ένα τυχαίο βήμα προς τα εμπρός;

720
00:40:07,000 --> 00:40:10,000
>> Αυτό το χάλι είναι ακόμα μια συνδεδεμένη λίστα,

721
00:40:10,000 --> 00:40:13,000
αλλά αυτοί οι τύποι θα μπορούσε να είναι οπουδήποτε στη μνήμη,

722
00:40:13,000 --> 00:40:15,000
έτσι anita + + δεν πρόκειται να λειτουργήσει γιατί;

723
00:40:15,000 --> 00:40:19,000
Τι είναι σε θέση anita + +;

724
00:40:19,000 --> 00:40:21,000
Ποιος ξέρει.

725
00:40:21,000 --> 00:40:24,000
Είναι κάποια άλλη αξία ότι ακριβώς έτσι συμβαίνει να παρεμβάλλεται

726
00:40:24,000 --> 00:40:28,000
μεταξύ όλων αυτών των κόμβων κατά τύχη, επειδή δεν είμαστε χρησιμοποιώντας μια σειρά.

727
00:40:28,000 --> 00:40:30,000
Εμείς χορηγούνται καθένα από αυτούς τους κόμβους χωριστά.

728
00:40:30,000 --> 00:40:32,000
Εντάξει, αν εσείς μπορείτε να καθαρίσετε τον εαυτό σας να δημιουργήσετε αντίγραφα ασφαλείας.

729
00:40:32,000 --> 00:40:37,000
Επιτρέψτε μου να προτείνω ότι αντί του anita + +, αντί να κάνουμε anita παίρνει-

730
00:40:37,000 --> 00:40:42,000
καλά, γιατί δεν πάμε σε ό, τι Anita είναι στραμμένο προς και στη συνέχεια κάντε. το επόμενο βήμα;

731
00:40:42,000 --> 00:40:45,000
Με άλλα λόγια, πάμε να Ραμόν, ο οποίος κρατάει τον αριθμό 22,

732
00:40:45,000 --> 00:40:51,000
και στη συνέχεια. επόμενο είναι σαν Anita θα αντιγράφοντας το αριστερό δείκτη του χεριού του.

733
00:40:51,000 --> 00:40:54,000
Αλλά δεν θα πάω μακρύτερα από ό, τι Ramon επειδή βρήκαμε 22.

734
00:40:54,000 --> 00:40:56,000
Αλλά αυτό θα ήταν η ιδέα. Τώρα, αυτό είναι ένας θεός-φοβερό χάος.

735
00:40:56,000 --> 00:40:59,000
Ειλικρινά, κανείς δεν θα θυμάται ποτέ αυτήν τη σύνταξη, και έτσι ευτυχώς,

736
00:40:59,000 --> 00:41:04,000
είναι πραγματικά λίγο σκόπιμη-OH, δεν έχετε πραγματικά να δείτε τι έγραψα.

737
00:41:04,000 --> 00:41:08,000
Αυτό θα ήταν πιο συναρπαστικό, αν μπορούσε. Voila!

738
00:41:08,000 --> 00:41:10,000
>> Πίσω από τις σκηνές, είχα την επίλυση του προβλήματος με αυτόν τον τρόπο.

739
00:41:10,000 --> 00:41:14,000
Anita, να κάνουμε αυτό το βήμα προς τα αριστερά,

740
00:41:14,000 --> 00:41:18,000
Αρχικά, πηγαίνουν στη διεύθυνση που Anita είναι στραμμένο προς

741
00:41:18,000 --> 00:41:23,000
όπου και θα βρείτε όχι μόνο ν, που μόλις ελέγχονται για σκοπούς σύγκρισης,

742
00:41:23,000 --> 00:41:25,000
αλλά θα βρείτε επίσης επόμενο - στην περίπτωση αυτή,

743
00:41:25,000 --> 00:41:28,000
Αριστερό χέρι του Ramon δείχνοντας στον επόμενο κόμβο της λίστας.

744
00:41:28,000 --> 00:41:32,000
Αλλά αυτό είναι ο θεός-φοβερό χάος στην οποία αναφέρθηκα νωρίτερα,

745
00:41:32,000 --> 00:41:34,000
αλλά βγάζει C μας επιτρέπει να απλοποιήσει αυτό.

746
00:41:34,000 --> 00:41:40,000
Αντί της γραφής (* anita), μπορούμε να γράψει αντί απλώς anita-> n,

747
00:41:40,000 --> 00:41:45,000
και αυτό είναι ακριβώς το ίδιο πράγμα λειτουργικά, αλλά είναι πολύ πιο έξυπνο,

748
00:41:45,000 --> 00:41:48,000
και είναι πολύ πιο συνεπής με την εικόνα που έχουμε την κατάρτιση

749
00:41:48,000 --> 00:41:50,000
όλο αυτό το διάστημα χρησιμοποιώντας τα βέλη.

750
00:41:50,000 --> 00:41:57,000
>> Τέλος, τι πρέπει να κάνουμε στο τέλος αυτού του προγράμματος;

751
00:41:57,000 --> 00:42:00,000
Υπάρχει μία γραμμή κώδικα που απομένουν.

752
00:42:00,000 --> 00:42:02,000
Επιστροφή τι;

753
00:42:02,000 --> 00:42:05,000
Λάθος, γιατί αν έχουμε όλο το while loop

754
00:42:05,000 --> 00:42:10,000
και Anita είναι, στην πραγματικότητα, μηδενική, αυτό σημαίνει ότι πήγε σε όλη τη διαδρομή μέχρι το τέλος της λίστας

755
00:42:10,000 --> 00:42:12,000
όπου έδειχνε σε-τι είναι το όνομά σας και πάλι;

756
00:42:12,000 --> 00:42:15,000
Ari αριστερό χέρι. >> Αρη, η οποία είναι άκυρη.

757
00:42:15,000 --> 00:42:18,000
Anita είναι πλέον μηδενική, και συνειδητοποιώ είστε ακριβώς στέκεται εδώ αμήχανα στο κενό

758
00:42:18,000 --> 00:42:21,000
επειδή θα πάω μακριά σε ένα μονόλογο εδώ,

759
00:42:21,000 --> 00:42:23,000
αλλά θα σας συμμετοχή και πάλι σε λίγο.

760
00:42:23,000 --> 00:42:27,000
Anita είναι μηδενική σε αυτό το σημείο στην ιστορία, έτσι ο βρόχος τερματίζεται, ενώ,

761
00:42:27,000 --> 00:42:30,000
και θα πρέπει να επιστρέψει ψευδείς, διότι αν πήρε όλη τη διαδρομή μέχρι δείκτη null Αρη

762
00:42:30,000 --> 00:42:34,000
τότε δεν υπήρχε αριθμός ότι ζήτησε από τη λίστα.

763
00:42:34,000 --> 00:42:39,000
Μπορούμε να καθαρίσει αυτό πάρα πολύ, αλλά αυτό είναι μια πολύ καλή εφαρμογή τότε

764
00:42:39,000 --> 00:42:43,000
από μια συνάρτηση διάσχισης, μια λειτουργία της αναζήτησης για μια συνδεδεμένη λίστα.

765
00:42:43,000 --> 00:42:48,000
Είναι ακόμα γραμμική αναζήτηση, αλλά δεν είναι τόσο απλό όσο μια + + δείκτης

766
00:42:48,000 --> 00:42:52,000
+ + ή μια μεταβλητή i, διότι τώρα δεν μπορούμε να μαντέψει

767
00:42:52,000 --> 00:42:54,000
όπου κάθε ένα από αυτούς τους κόμβους είναι στη μνήμη.

768
00:42:54,000 --> 00:42:57,000
Πρέπει να ακολουθήσει κυριολεκτικά το ίχνος της πορείες ή, πιο συγκεκριμένα,

769
00:42:57,000 --> 00:43:00,000
δείκτες, για να πάρει από τον ένα κόμβο στον άλλο.

770
00:43:00,000 --> 00:43:02,000
>> Τώρα ας προσπαθήσουμε ένα άλλο. Anita, θέλετε να επιστρέψετε εδώ;

771
00:43:02,000 --> 00:43:06,000
Γιατί δεν πάμε μπροστά και να διαθέσει ένα άλλο πρόσωπο από το κοινό;

772
00:43:06,000 --> 00:43:08,000
Malloc-τι είναι το όνομά σου; >> Rebecca.

773
00:43:08,000 --> 00:43:10,000
Rebecca. Rebecca έχει malloced από το κοινό,

774
00:43:10,000 --> 00:43:13,000
και αυτή είναι τώρα αποθηκεύει τον αριθμό 55.

775
00:43:13,000 --> 00:43:17,000
Και ο στόχος είναι στο χέρι τώρα Anita για να εισάγετε

776
00:43:17,000 --> 00:43:22,000
Rebecca στη συνδεδεμένη λίστα εδώ στην κατάλληλη θέση.

777
00:43:22,000 --> 00:43:24,000
Ελάτε εδώ για μια στιγμή.

778
00:43:24,000 --> 00:43:28,000
Έχω κάνει κάτι τέτοιο.

779
00:43:28,000 --> 00:43:32,000
Έχω κάνει κόμβο *. Και τι είναι το όνομά σας και πάλι;

780
00:43:32,000 --> 00:43:34,000
Rebecca. >> Rebecca, εντάξει.

781
00:43:34,000 --> 00:43:41,000
Rebecca παίρνει malloc (sizeof (κόμβος)).

782
00:43:41,000 --> 00:43:44,000
Ακριβώς όπως έχουμε διαθέσει τα πράγματα όπως τους φοιτητές και εταζέρα στο παρελθόν,

783
00:43:44,000 --> 00:43:46,000
χρειαζόμαστε το μέγεθος του κόμβου, έτσι και τώρα Rebecca

784
00:43:46,000 --> 00:43:49,000
δείχνει σε τι;

785
00:43:49,000 --> 00:43:52,000
Rebecca έχει δύο πεδία μέσα της, ένα από τα οποία είναι 55.

786
00:43:52,000 --> 00:43:55,000
Ας κάνουμε ό, τι, rebecca-> = 55.

787
00:43:55,000 --> 00:44:00,000
Στη συνέχεια, όμως rebecca-> επόμενο θα πρέπει να-όπως τώρα, το χέρι της είναι το είδος του ποιος ξέρει;

788
00:44:00,000 --> 00:44:03,000
Είναι δείχνοντας κάποια αξία σκουπίδια, οπότε γιατί να μην το κάνει για το καλό μέτρο

789
00:44:03,000 --> 00:44:07,000
εμείς τουλάχιστον το κάνουμε αυτό, έτσι ώστε το αριστερό χέρι είναι τώρα στο πλευρό της.

790
00:44:07,000 --> 00:44:09,000
Τώρα, Anita, πάρτε από εδώ.

791
00:44:09,000 --> 00:44:11,000
Έχετε Rebecca έχουν διατεθεί.

792
00:44:11,000 --> 00:44:20,000
Προχωρήστε και βρείτε πού θα πρέπει να βάλουμε Rebecca.

793
00:44:20,000 --> 00:44:25,000
Καλό, πολύ καλό.

794
00:44:25,000 --> 00:44:28,000
Εντάξει, καλά, και τώρα θα πρέπει να παρέχουν ένα κομμάτι της κατεύθυνσης,

795
00:44:28,000 --> 00:44:30,000
έτσι έχετε φτάσει Ari.

796
00:44:30,000 --> 00:44:33,000
Το αριστερό του χέρι είναι μηδενική, αλλά Rebecca ανήκει σαφώς στα δεξιά,

797
00:44:33,000 --> 00:44:36,000
ναι, πώς πρέπει να αλλάξει αυτή συνδεδεμένη λίστα

798
00:44:36,000 --> 00:44:38,000
προκειμένου να τοποθετήσετε Rebecca στην κατάλληλη θέση;

799
00:44:38,000 --> 00:44:42,000
Αν μπορούσε να κινηθεί αριστερά κυριολεκτικά τα χέρια των ανθρώπων γύρω, όπως απαιτείται,

800
00:44:42,000 --> 00:44:48,000
θα λύσει το πρόβλημα με αυτόν τον τρόπο.

801
00:44:48,000 --> 00:44:52,000
Εντάξει, καλά, και εν τω μεταξύ, το αριστερό χέρι της Ρεβέκκας είναι τώρα από την πλευρά της.

802
00:44:52,000 --> 00:44:54,000
>> Αυτό ήταν πάρα πολύ εύκολο.

803
00:44:54,000 --> 00:44:57,000
Ας προσπαθήσουμε κατανομή-εργαζόμαστε σχεδόν τελειώσει, 20.

804
00:44:57,000 --> 00:44:59,000
Εντάξει, έλα επάνω.

805
00:44:59,000 --> 00:45:04,000
20 έχει διατεθεί, οπότε επιτρέψτε μου να προχωρήσει και να πω και πάλι εδώ

806
00:45:04,000 --> 00:45:07,000
έχουμε κάνει μόνο κόμβο Saad *.

807
00:45:07,000 --> 00:45:11,000
Έχουμε malloc (sizeof (κόμβος)).

808
00:45:11,000 --> 00:45:16,000
Κάνουμε λοιπόν την ίδια ακριβώς σύνταξη, όπως κάναμε πριν για 20,

809
00:45:16,000 --> 00:45:20,000
και εγώ θα κάνουμε στη συνέχεια NULL =, και τώρα είναι στο χέρι Anita

810
00:45:20,000 --> 00:45:23,000
για την εισαγωγή σας στην συνδεδεμένη λίστα, αν θα μπορούσε να παίξει αυτό το ρόλο ακριβώς το ίδιο.

811
00:45:23,000 --> 00:45:30,000
Εκτέλεση.

812
00:45:30,000 --> 00:45:32,000
Εντάξει, καλά.

813
00:45:32,000 --> 00:45:38,000
Τώρα σκεφτείτε προσεκτικά πριν αρχίσει να κινείται αριστερά χέρια γύρω.

814
00:45:38,000 --> 00:45:46,000
Μπορείτε από τώρα πήρε την πιο δύσκολη ρόλο σήμερα.

815
00:45:46,000 --> 00:45:59,000
Ποιανού το χέρι θα πρέπει να μετακινηθεί πρώτα;

816
00:45:59,000 --> 00:46:02,000
Εντάξει, περιμένετε, ακούω κάποια δεν είναι.

817
00:46:02,000 --> 00:46:07,000
Αν κάποιοι λαοί θα ήθελα ευγενικά να βοηθήσει στην επίλυση μια δύσκολη κατάσταση εδώ.

818
00:46:07,000 --> 00:46:11,000
Ποιανού το αριστερό χέρι θα πρέπει να ενημερώνονται πρώτα ίσως; Ναι.

819
00:46:11,000 --> 00:46:13,000
[Φοιτητικό] του Saad.

820
00:46:13,000 --> 00:46:15,000
Εντάξει, είναι Saad, γιατί όμως;

821
00:46:15,000 --> 00:46:17,000
[Ακούγεται ανταπόκριση των φοιτητών]

822
00:46:17,000 --> 00:46:19,000
Καλό, γιατί αν κινηθούμε-τι είναι το όνομά σου; >> Μάρσαλ.

823
00:46:19,000 --> 00:46:22,000
Marshall, αν κινούμαστε πρώτος το χέρι του κάτω σε null,

824
00:46:22,000 --> 00:46:25,000
τώρα έχουμε κυριολεκτικά ορφανά τέσσερα άτομα σε αυτήν τη λίστα

825
00:46:25,000 --> 00:46:29,000
επειδή ήταν το μόνο πράγμα που δείχνει στο Ραμόν και ο καθένας προς τα αριστερά,

826
00:46:29,000 --> 00:46:31,000
έτσι ότι η ενημέρωση δείκτης πρώτη ήταν κακή.

827
00:46:31,000 --> 00:46:33,000
Ας ανατρέψουμε.

828
00:46:33,000 --> 00:46:37,000
Καλό, και τώρα να προχωρήσει και να μετακινήσετε το κατάλληλο αριστερό χέρι δείχνοντας Ραμόν.

829
00:46:37,000 --> 00:46:39,000
Αυτό αισθάνεται λίγο περιττή.

830
00:46:39,000 --> 00:46:41,000
Τώρα υπάρχουν δύο άνθρωποι που δείχνουν στο Ramon, αλλά ότι είναι εντάξει

831
00:46:41,000 --> 00:46:43,000
γιατί τώρα πώς αλλιώς δεν θα επικαιροποιεί τον κατάλογο;

832
00:46:43,000 --> 00:46:48,000
Ποια άλλη πλευρά πρέπει να κινηθεί;

833
00:46:48,000 --> 00:46:53,000
Εξαιρετική, τώρα έχουμε χάσει κάθε μνήμη;

834
00:46:53,000 --> 00:46:57,000
Όχι, τόσο καλά, ας δούμε αν μπορούμε να μην μπορεί να σπάσει αυτό για μια ακόμη φορά.

835
00:46:57,000 --> 00:47:00,000
>> Mallocing για μια τελευταία φορά, αριθμός 5.

836
00:47:00,000 --> 00:47:04,000
Όλος ο τρόπος στην πλάτη, έλα κάτω.

837
00:47:04,000 --> 00:47:08,000
Είναι πολύ συναρπαστικό.

838
00:47:08,000 --> 00:47:15,000
[Χειροκροτήματα]

839
00:47:15,000 --> 00:47:17,000
Ποιο είναι το όνομά σου; >> Ρον.

840
00:47:17,000 --> 00:47:19,000
Ron, εντάξει, σας malloced τον αριθμό 5.

841
00:47:19,000 --> 00:47:23,000
Έχουμε εκτελούνται μόνο κώδικα που είναι σχεδόν ίδια με αυτά

842
00:47:23,000 --> 00:47:26,000
μόνο με ένα διαφορετικό όνομα.

843
00:47:26,000 --> 00:47:28,000
Εξαιρετική.

844
00:47:28,000 --> 00:47:38,000
Τώρα, Anita, καλή τύχη εισάγοντας τον αριθμό 5 στην λίστα τώρα.

845
00:47:38,000 --> 00:47:43,000
Καλό, και;

846
00:47:43,000 --> 00:47:47,000
Εξαιρετική, έτσι αυτό είναι πραγματικά η τρίτη από τις τρεις συνολικά περιπτώσεις.

847
00:47:47,000 --> 00:47:49,000
Είχαμε πρώτη φορά που κάποιος στο τέλος, Ρεβέκκα.

848
00:47:49,000 --> 00:47:51,000
Είχαμε τότε κάποιος στη μέση.

849
00:47:51,000 --> 00:47:53,000
Τώρα έχουμε κάποιον στην αρχή, και σε αυτό το παράδειγμα,

850
00:47:53,000 --> 00:47:56,000
τώρα έπρεπε να ενημερώσει Lucas για πρώτη φορά

851
00:47:56,000 --> 00:48:00,000
επειδή το πρώτο στοιχείο στη λίστα έχει τώρα με το σημείο σε ένα νέο κόμβο,

852
00:48:00,000 --> 00:48:03,000
ο οποίος, με τη σειρά του, δείχνει στον κόμβο αριθμό 9.

853
00:48:03,000 --> 00:48:06,000
>> Αυτή ήταν μια εξαιρετικά δύσκολη επίδειξη, είμαι βέβαιος,

854
00:48:06,000 --> 00:48:08,000
έτσι ένα μεγάλο χειροκρότημα για αυτά τα παιδιά, αν μπορούσε.

855
00:48:08,000 --> 00:48:11,000
Όμορφα γίνει.

856
00:48:11,000 --> 00:48:17,000
Αυτό είναι όλο. Μπορείτε να κρατήσετε τα κομμάτια σας από το χαρτί ως μια μικρή μνήμη.

857
00:48:17,000 --> 00:48:22,000
Αποδεικνύεται ότι το κάνουμε αυτό σε κώδικα

858
00:48:22,000 --> 00:48:26,000
δεν είναι τόσο απλή όσο ακριβώς κινείται γύρω από τα χέρια

859
00:48:26,000 --> 00:48:28,000
και δείχνοντας δείκτες σε διαφορετικά πράγματα.

860
00:48:28,000 --> 00:48:31,000
Αλλά συνειδητοποιούν ότι όταν έρχεται η ώρα να εφαρμόσει κάτι σαν

861
00:48:31,000 --> 00:48:34,000
μια συνδεδεμένη λίστα ή μια παραλλαγή του αυτό, αν επικεντρωθεί σε πραγματικά

862
00:48:34,000 --> 00:48:38,000
αυτά τα βασικά μεγέθη, οι δάγκωμα-μεγέθους προβλήματα που έχω να καταλάβω,

863
00:48:38,000 --> 00:48:43,000
είναι αυτό το χέρι ή το χέρι, να συνειδητοποιήσουν ότι αυτό που κατά τα άλλα είναι ένα αρκετά πολύπλοκο πρόγραμμα

864
00:48:43,000 --> 00:48:47,000
μπορεί, στην πραγματικότητα, να μειωθεί σε αρκετά απλή δομικά σαν αυτό.

865
00:48:47,000 --> 00:48:51,000
>> Ας πάρουμε όμως τα πράγματα σε μια πιο εξελιγμένη κατεύθυνση ακόμα.

866
00:48:51,000 --> 00:48:53,000
Έχουμε τώρα την έννοια του συνδεδεμένη λίστα.

867
00:48:53,000 --> 00:48:57,000
Έχουμε επίσης-χάρη στην πρόταση-πίσω υπάρχει μια διπλά συνδεδεμένη λίστα,

868
00:48:57,000 --> 00:49:01,000
η οποία φαίνεται σχεδόν το ίδιο, αλλά τώρα έχουμε δύο δείκτες στο εσωτερικό του struct

869
00:49:01,000 --> 00:49:05,000
αντί για ένα, και θα μπορούσαμε να καλέσετε πιθανώς οι δείκτες προηγούμενο και επόμενο

870
00:49:05,000 --> 00:49:08,000
ή αριστερά ή δεξιά, αλλά εμείς, στην πραγματικότητα, χρειάζονται δύο από αυτούς.

871
00:49:08,000 --> 00:49:10,000
Ο κωδικός θα είναι λίγο πιο περίπλοκη.

872
00:49:10,000 --> 00:49:12,000
Anita θα έπρεπε να κάνει περισσότερη δουλειά εδώ στη σκηνή.

873
00:49:12,000 --> 00:49:15,000
Αλλά θα μπορούσαμε να εφαρμόσουμε σίγουρα αυτό το είδος της δομής.

874
00:49:15,000 --> 00:49:19,000
Από την άποψη της διάρκειας, όμως, τι θα ήταν ο χρόνος εκτέλεσης

875
00:49:19,000 --> 00:49:24,000
Anita για την εξεύρεση αριθμό n σε μια συνδεδεμένη λίστα τώρα;

876
00:49:24,000 --> 00:49:27,000
Ακόμα μεγάλη Ξ n, έτσι δεν είναι καλύτερη από ό, τι γραμμική αναζήτηση.

877
00:49:27,000 --> 00:49:29,000
Δεν μπορούμε να κάνουμε δυαδική αναζήτηση, όμως, και πάλι.

878
00:49:29,000 --> 00:49:34,000
Γιατί ήταν ότι η υπόθεση; Δεν μπορείτε να ρίξουν μια ματιά.

879
00:49:34,000 --> 00:49:36,000
Ακόμα κι αν βλέπουμε προφανώς το σύνολο των ανθρώπων πάνω στη σκηνή,

880
00:49:36,000 --> 00:49:39,000
Anita και θα μπορούσε να το eyeballed και είπε: «Εδώ είναι η μέση της λίστας,"

881
00:49:39,000 --> 00:49:42,000
ότι δεν θα ξέρει ότι αν ήταν το πρόγραμμα του υπολογιστή

882
00:49:42,000 --> 00:49:47,000
γιατί το μόνο πράγμα που είχε να προσδεθούμε σε κατά την έναρξη του σεναρίου

883
00:49:47,000 --> 00:49:50,000
ήταν Lucas, ο οποίος ήταν ο πρώτος δείκτης.

884
00:49:50,000 --> 00:49:53,000
Αυτή θα πρέπει αναγκαστικά να ακολουθήσει αυτούς τους δεσμούς,

885
00:49:53,000 --> 00:49:56,000
μετρώντας τον τρόπο της μέχρι να βρεθεί περίπου στη μέση,

886
00:49:56,000 --> 00:49:58,000
και ακόμα και τότε, δεν πρόκειται να ξέρει όταν έχει φτάσει στη μέση

887
00:49:58,000 --> 00:50:01,000
εκτός αν πηγαίνει σε όλη τη διαδρομή μέχρι το τέλος για να καταλάβουμε πόσα υπάρχουν,

888
00:50:01,000 --> 00:50:05,000
στη συνέχεια υπαναχωρεί, και ότι επίσης θα είναι δύσκολο αν δεν είχε

889
00:50:05,000 --> 00:50:07,000
μια διπλά συνδεδεμένη λίστα κάποιου είδους.

890
00:50:07,000 --> 00:50:10,000
>> Επίλυση κάποια προβλήματα σήμερα, αλλά την εισαγωγή τους άλλους.

891
00:50:10,000 --> 00:50:12,000
Τι θα γίνει με μια διαφορετική δομή δεδομένων εντελώς;

892
00:50:12,000 --> 00:50:15,000
Αυτή είναι μια φωτογραφία των δίσκων σε Mather House,

893
00:50:15,000 --> 00:50:19,000
και σε αυτή την περίπτωση, έχουμε μια δομή δεδομένων που έχουμε, επίσης, το είδος των ήδη μιλάμε.

894
00:50:19,000 --> 00:50:22,000
Μιλήσαμε για μια στοίβα στο πλαίσιο της μνήμης,

895
00:50:22,000 --> 00:50:26,000
και ότι είναι είδος που ονομάζεται σκόπιμα επειδή μια στοίβα με τους όρους της μνήμης

896
00:50:26,000 --> 00:50:31,000
είναι ουσιαστικά μια δομή δεδομένων που έχει όλο και περισσότερα πράγματα σε επίπεδα πάνω από αυτό.

897
00:50:31,000 --> 00:50:35,000
Αλλά το ενδιαφέρον πράγμα για μια στοίβα, όπως είναι η περίπτωση, στην πραγματικότητα,

898
00:50:35,000 --> 00:50:38,000
είναι ότι είναι ένα ιδιαίτερο είδος των δεδομένων δομής.

899
00:50:38,000 --> 00:50:42,000
Είναι μια δομή δεδομένων οπότε το πρώτο στοιχείο στην

900
00:50:42,000 --> 00:50:46,000
είναι το τελευταίο στοιχείο έξω.

901
00:50:46,000 --> 00:50:50,000
Αν είστε ο πρώτος δίσκος να τεθεί στη στοίβα,

902
00:50:50,000 --> 00:50:53,000
εσείς πρόκειται να είναι, δυστυχώς, ο τελευταίος δίσκος που πρέπει να ληφθούν από τη στοίβα,

903
00:50:53,000 --> 00:50:55,000
και ότι δεν είναι απαραίτητα ένα καλό πράγμα.

904
00:50:55,000 --> 00:50:58,000
Αντίθετα, μπορείτε να σκεφτείτε το αντίστροφο,

905
00:50:58,000 --> 00:51:02,000
το τελευταίο είναι η πρώτη έξω.

906
00:51:02,000 --> 00:51:05,000
>> Τώρα, μην τυχόν σενάρια έρχονται στο μυαλό, όπου έχει μια στοίβα

907
00:51:05,000 --> 00:51:08,000
δομή δεδομένων όπου θα έχουν αυτό το ακίνητο

908
00:51:08,000 --> 00:51:13,000
από την τελευταία in, first out, είναι πραγματικά συναρπαστικό;

909
00:51:13,000 --> 00:51:16,000
Είναι αυτό ένα καλό πράγμα; Είναι αυτό ένα κακό πράγμα;

910
00:51:16,000 --> 00:51:19,000
Είναι σίγουρα ένα κακό πράγμα, αν οι δίσκοι δεν ήταν όλα ίδια

911
00:51:19,000 --> 00:51:21,000
και ήταν όλοι ειδική διαφορετικά χρώματα ή οτιδήποτε,

912
00:51:21,000 --> 00:51:24,000
και το χρώμα που θέλετε είναι όλος ο τρόπος στο κάτω μέρος.

913
00:51:24,000 --> 00:51:26,000
Φυσικά, δεν μπορείτε να πάρετε ότι χωρίς μεγάλη προσπάθεια.

914
00:51:26,000 --> 00:51:28,000
Θα πρέπει να ξεκινήσει από την κορυφή και το έργο το δρόμο σας προς τα κάτω.

915
00:51:28,000 --> 00:51:31,000
Ομοίως, τι αν ήταν ένα από αυτά τα αγόρια ανεμιστήρα

916
00:51:31,000 --> 00:51:34,000
ο οποίος περιμένει μέχρι όλη τη νύχτα προσπαθώντας να πάρει ένα iPhone και γραμμές μέχρι

917
00:51:34,000 --> 00:51:36,000
σε ένα μέρος όπως αυτό;

918
00:51:36,000 --> 00:51:40,000
Δεν θα ήταν ωραίο αν το κατάστημα της Apple

919
00:51:40,000 --> 00:51:42,000
ήταν μία δομή δεδομένων στοίβα;

920
00:51:42,000 --> 00:51:44,000
Yay; Nay;

921
00:51:44,000 --> 00:51:47,000
Είναι μόνο καλό για τους ανθρώπους που εμφανίζονται στην τελευταία στιγμή

922
00:51:47,000 --> 00:51:50,000
και στη συνέχεια να πάρει βγαλμένα από την ουρά.

923
00:51:50,000 --> 00:51:52,000
Και στην πραγματικότητα, το γεγονός ότι ήμουν τόσο την τάση να πούμε ουρά

924
00:51:52,000 --> 00:51:56,000
είναι πραγματικά συνεπής με αυτό που θα ονομάζαμε αυτό το είδος των δεδομένων δομής,

925
00:51:56,000 --> 00:51:59,000
ένα στην πραγματικότητα, όπου η σειρά έχει σημασία,

926
00:51:59,000 --> 00:52:02,000
και θέλετε το πρώτο, για να είναι η πρώτη από

927
00:52:02,000 --> 00:52:04,000
έστω και μόνο για χάρη της ανθρώπινης δικαιοσύνης.

928
00:52:04,000 --> 00:52:07,000
Θα καλέσετε γενικά ότι μια δομή δεδομένων ουρά.

929
00:52:07,000 --> 00:52:11,000
>> Βγάζει εκτός από συνδεδεμένες λίστες, μπορούμε να αρχίσετε να χρησιμοποιείτε τις ίδιες βασικές ιδέες

930
00:52:11,000 --> 00:52:15,000
και να αρχίσει η δημιουργία νέων και διαφορετικών τύπων των λύσεων στα προβλήματα.

931
00:52:15,000 --> 00:52:19,000
Για παράδειγμα, στην περίπτωση ενός σωρού, θα μπορούσαμε να αντιπροσωπεύουν μια στοίβα

932
00:52:19,000 --> 00:52:22,000
χρησιμοποιώντας μια δομή δεδομένων, όπως αυτό, θα ήθελα να προτείνω.

933
00:52:22,000 --> 00:52:26,000
Σε αυτή την περίπτωση, έχω δηλώσει ένα struct, και έχω πει μέσα από αυτή τη δομή

934
00:52:26,000 --> 00:52:30,000
είναι μία σειρά από αριθμούς και στη συνέχεια μια μεταβλητή που ονομάζεται μέγεθος,

935
00:52:30,000 --> 00:52:33,000
και εγώ είμαι πρόκειται να καλέσετε αυτό το πράγμα μια στοίβα.

936
00:52:33,000 --> 00:52:35,000
Τώρα, γιατί αυτό πραγματικά εργασία;

937
00:52:35,000 --> 00:52:43,000
Στην περίπτωση μιας στοίβας, θα μπορούσε να αντλήσει αποτελεσματικά αυτή την οθόνη, όπως μια σειρά.

938
00:52:43,000 --> 00:52:47,000
Εδώ είναι το stack μου. Αυτοί είναι οι αριθμοί μου.

939
00:52:47,000 --> 00:52:50,000
Και εμείς θα τους επιστήσει όπως αυτό, αυτό, αυτό, αυτό, αυτό.

940
00:52:50,000 --> 00:52:53,000
Και τότε έχω κάποιο άλλο μέλος εδώ δεδομένων,

941
00:52:53,000 --> 00:52:58,000
το οποίο ονομάζεται μέγεθος, έτσι αυτό είναι το μέγεθος, και αυτό είναι αριθμοί,

942
00:52:58,000 --> 00:53:02,000
και συλλογικά, ολόκληρο το iPad εδώ αντιπροσωπεύει μια δομή στοίβας.

943
00:53:02,000 --> 00:53:07,000
Τώρα, από προεπιλογή, το μέγεθος έχει κατά πάσα πιθανότητα έχεις να αρχικοποιείται σε 0,

944
00:53:07,000 --> 00:53:11,000
και τι είναι μέσα από τη σειρά των αριθμών που αρχικά

945
00:53:11,000 --> 00:53:14,000
όταν διαθέτουν για πρώτη φορά ένα πίνακα;

946
00:53:14,000 --> 00:53:16,000
Σκουπίδια. Ποιος ξέρει; Και δεν πειράζει πραγματικά.

947
00:53:16,000 --> 00:53:20,000
Δεν έχει σημασία αν αυτό είναι 1, 2, 3, 4, 5, εντελώς τυχαία

948
00:53:20,000 --> 00:53:25,000
από κακή τύχη αποθηκεύονται στη δομή μου, γιατί εφ 'όσον ξέρω ότι το μέγεθος της στοίβας

949
00:53:25,000 --> 00:53:29,000
είναι 0, τότε ξέρω προγραμματισμό, δεν φαίνονται σε κανένα από τα στοιχεία του πίνακα.

950
00:53:29,000 --> 00:53:31,000
Δεν έχει σημασία τι υπάρχει εκεί.

951
00:53:31,000 --> 00:53:34,000
Μην κοιτάτε τους, καθώς θα είναι η επίπτωση της μέγεθος 0.

952
00:53:34,000 --> 00:53:38,000
>> Αλλά ας υποθέσουμε τώρα να προχωρήσει και να τοποθετήσετε κάτι στο σωρό.

953
00:53:38,000 --> 00:53:42,000
Θέλω να εισαγάγετε τον αριθμό 5, έτσι έβαλα εδώ αριθμό 5,

954
00:53:42,000 --> 00:53:45,000
και στη συνέχεια, τι μπορώ να τοποθετήσω εδώ κάτω;

955
00:53:45,000 --> 00:53:48,000
Τώρα θα ήθελα πραγματικά βάλει κάτω 1 για το μέγεθος,

956
00:53:48,000 --> 00:53:50,000
και τώρα η στοίβα έχει μέγεθος 1.

957
00:53:50,000 --> 00:53:53,000
Τι θα συμβεί αν πάω μπροστά και τοποθετήστε τον αριθμό, ας πούμε, 7 επόμενη;

958
00:53:53,000 --> 00:53:57,000
Αυτό στη συνέχεια παίρνει ενημερώνεται σε 2, και στη συνέχεια θα κάνουμε 9,

959
00:53:57,000 --> 00:54:02,000
και στη συνέχεια αυτό παίρνει ενημερωθεί σε 3.

960
00:54:02,000 --> 00:54:05,000
Αλλά το ενδιαφέρον χαρακτηριστικό τώρα αυτής της στοίβας είναι ότι

961
00:54:05,000 --> 00:54:09,000
Είμαι υποτίθεται για να αφαιρέσετε το οποίο στοιχείο αν θέλω να σκάσει

962
00:54:09,000 --> 00:54:12,000
κάτι μακριά από το σωρό, να το πω έτσι;

963
00:54:12,000 --> 00:54:14,000
9 θα ήταν το πρώτο πράγμα που πρέπει να πάνε.

964
00:54:14,000 --> 00:54:18,000
Πώς θα πρέπει η εικόνα να αλλάξει αν θέλω να σκάσει ένα στοιχείο από τη στοίβα,

965
00:54:18,000 --> 00:54:20,000
Μοιάζει πολύ με ένα δίσκο στο Mather;

966
00:54:20,000 --> 00:54:22,000
Ναι. >> [Φοιτητικό] Σετ για το μέγεθος 2.

967
00:54:22,000 --> 00:54:27,000
Ακριβώς, το μόνο που κάνετε είναι να ρυθμίσετε το μέγεθος σε 2, και τι μπορώ να κάνω με τη σειρά;

968
00:54:27,000 --> 00:54:29,000
Δεν έχω να κάνω τίποτα.

969
00:54:29,000 --> 00:54:32,000
Θα μπορούσα, ακριβώς για να είναι πρωκτική, βάλτε εκεί ένα 0 ή -1 ή κάτι για να δηλώσουν

970
00:54:32,000 --> 00:54:34,000
ότι αυτό δεν είναι ένα legit αξία, αλλά αυτό δεν έχει σημασία γιατί

971
00:54:34,000 --> 00:54:37,000
Μπορώ να καταγράφουν εκτός του πίνακα η ίδια πόσο καιρό είναι

972
00:54:37,000 --> 00:54:41,000
έτσι ώστε να ξέρω μόνο να δούμε τα δύο πρώτα στοιχεία αυτού του πίνακα.

973
00:54:41,000 --> 00:54:47,000
Τώρα, αν πάω και να προσθέσετε τον αριθμό 8 του παρόντος πίνακα, πώς να αλλάξει η εικόνα το επόμενο βήμα;

974
00:54:47,000 --> 00:54:50,000
Αυτό γίνεται 8, και αυτό γίνεται 3.

975
00:54:50,000 --> 00:54:52,000
Είμαι κοπή μερικές γωνίες εδώ.

976
00:54:52,000 --> 00:54:56,000
Τώρα έχουμε 5, 7, 8, και είμαστε πίσω σε μέγεθος 3.

977
00:54:56,000 --> 00:54:58,000
Αυτό είναι αρκετά απλό στην εφαρμογή του,

978
00:54:58,000 --> 00:55:06,000
αλλά όταν θα πάμε να λύπη την απόφαση αυτή του σχεδιασμού;

979
00:55:06,000 --> 00:55:09,000
Πότε αρχίζουν τα πράγματα να πάνε πολύ, πολύ λάθος; Ναι.

980
00:55:09,000 --> 00:55:11,000
[Ακούγεται ανταπόκριση των φοιτητών]

981
00:55:11,000 --> 00:55:13,000
Όταν θέλετε να πάτε πίσω και να πάρει το πρώτο στοιχείο που βάζετε μέσα

982
00:55:13,000 --> 00:55:18,000
>> Αποδεικνύεται εδώ ακόμη και αν μια στοίβα είναι ένας πίνακας κάτω από την κουκούλα,

983
00:55:18,000 --> 00:55:21,000
αυτές οι δομές δεδομένων που έχουμε αρχίσει να μιλάμε για επίσης γενικά γνωστό ως

984
00:55:21,000 --> 00:55:25,000
αφηρημένες δομές δεδομένων σύμφωνα με την οποία το πώς είστε εφαρμογή

985
00:55:25,000 --> 00:55:27,000
είναι εντελώς εκτός από το σημείο.

986
00:55:27,000 --> 00:55:31,000
Μια δομή δεδομένων, όπως μια στοίβα υποτίθεται για να προσθέσετε υποστήριξη

987
00:55:31,000 --> 00:55:35,000
επιχειρήσεις όπως ωθήσεως, το οποίο ωθεί ένα δίσκο πάνω στην στοίβα,

988
00:55:35,000 --> 00:55:39,000
και ποπ, που διαγράφει ένα στοιχείο από τη στοίβα, και αυτό είναι αυτό.

989
00:55:39,000 --> 00:55:43,000
Εάν επρόκειτο να κατεβάσετε τον κώδικα κάποιου άλλου που ήδη εφαρμόζονται

990
00:55:43,000 --> 00:55:46,000
αυτό το πράγμα που ονομάζεται μια στοίβα, το πρόσωπο αυτό θα είχε γράψει

991
00:55:46,000 --> 00:55:49,000
μόνο δύο λειτουργίες για σας, πιέστε και ποπ, της οποίας μοναδικός σκοπός στη ζωή

992
00:55:49,000 --> 00:55:51,000
θα ήταν να κάνει ακριβώς αυτό.

993
00:55:51,000 --> 00:55:54,000
Εσείς ή αυτόν ή αυτήν που εφαρμόζεται το πρόγραμμα

994
00:55:54,000 --> 00:55:58,000
θα ήταν εντελώς ο ένας να αποφασίσουν πώς θα εφαρμόσουν

995
00:55:58,000 --> 00:56:00,000
η σημασιολογία του να πιέζει και να βρεθώ κάτω από την κουκούλα

996
00:56:00,000 --> 00:56:03,000
ή η λειτουργικότητα του να πιέζει και σκάει.

997
00:56:03,000 --> 00:56:07,000
Και έχω κάνει μια κάπως κοντόφθαλμη απόφαση εδώ

998
00:56:07,000 --> 00:56:10,000
με την εφαρμογή stack μου με αυτή την απλή δομή δεδομένων για ποιο λόγο;

999
00:56:10,000 --> 00:56:12,000
Όταν κάνει αυτό το διάλειμμα δομή δεδομένων;

1000
00:56:12,000 --> 00:56:18,000
Σε ποιο σημείο μπορώ να επιστρέψει ένα σφάλμα όταν ο χρήστης καλεί ώθηση, για παράδειγμα;

1001
00:56:18,000 --> 00:56:20,000
[Φοιτητικό] Εάν δεν υπάρχει περισσότερος χώρος.

1002
00:56:20,000 --> 00:56:23,000
Ακριβώς, αν δεν είναι κανένα περισσότερο χώρο, αν έχω υπέρβαση της ικανότητας,

1003
00:56:23,000 --> 00:56:27,000
που είναι όλα τα καλύμματα, γιατί δείχνει ότι είναι κάποιο είδος της παγκόσμιας σταθεράς.

1004
00:56:27,000 --> 00:56:30,000
Καλά, τότε είμαι απλώς πρόκειται να πρέπει να πω, "Συγγνώμη, δεν μπορώ να πιέσω άλλο αξία

1005
00:56:30,000 --> 00:56:32,000
στη στοίβα, "όπως και σε Mather.

1006
00:56:32,000 --> 00:56:36,000
>> Σε κάποιο σημείο, από όπου και αν πρόκειται να χτυπήσει το πάνω μέρος του αυτό το μικρό υπουργικό συμβούλιο.

1007
00:56:36,000 --> 00:56:39,000
Δεν υπάρχει περισσότερο χώρο ή χωρητικότητα στη στοίβα, σε σημείο που δεν υπάρχει κάποιο είδος του λάθους.

1008
00:56:39,000 --> 00:56:42,000
Θα πρέπει να θέσει το στοιχείο κάπου αλλού, ο δίσκος κάπου αλλού,

1009
00:56:42,000 --> 00:56:44,000
ή πουθενά καθόλου.

1010
00:56:44,000 --> 00:56:47,000
Τώρα, με την ουρά, θα μπορούσαμε να εφαρμόσουμε το λίγο διαφορετικά.

1011
00:56:47,000 --> 00:56:50,000
Μια ουρά είναι λίγο διαφορετικό από το ότι κάτω από την καλύπτρα, μπορεί να εφαρμοστεί

1012
00:56:50,000 --> 00:56:54,000
ως μια σειρά, αλλά γιατί, στην περίπτωση αυτή, είμαι προτείνοντας

1013
00:56:54,000 --> 00:56:59,000
να έχουν επίσης ένα στοιχείο κεφαλής που αντιπροσωπεύει την κεφαλή της λίστας,

1014
00:56:59,000 --> 00:57:06,000
το μπροστινό μέρος της λίστας, το πρώτο πρόσωπο στη γραμμή στο κατάστημα της Apple, εκτός από το μέγεθος;

1015
00:57:06,000 --> 00:57:14,000
Γιατί χρειάζομαι ένα επιπλέον κομμάτι των δεδομένων εδώ;

1016
00:57:14,000 --> 00:57:16,000
Σκεφτείτε πίσω σε ό, τι είναι οι αριθμοί

1017
00:57:16,000 --> 00:57:18,000
αν έχω σχεδιάσει αυτό ως εξής.

1018
00:57:18,000 --> 00:57:21,000
Ας υποθέσουμε ότι αυτή είναι τώρα μια ουρά αντί ενός σωρού,

1019
00:57:21,000 --> 00:57:24,000
η διαφορά είναι-όπως ακριβώς και το κατάστημα Apple-ουρά είναι δίκαιη.

1020
00:57:24,000 --> 00:57:27,000
Το πρώτο πρόσωπο στη γραμμή κατά την έναρξη της λίστας, αριθμός 5 σε αυτή την περίπτωση,

1021
00:57:27,000 --> 00:57:30,000
αυτός ή αυτή πρόκειται να αφήσει στο κατάστημα πρώτα.

1022
00:57:30,000 --> 00:57:32,000
Ας το κάνουμε αυτό.

1023
00:57:32,000 --> 00:57:35,000
Ας υποθέσουμε ότι αυτή είναι η κατάσταση της ουράς μου αυτή τη στιγμή, και τώρα το κατάστημα της Apple

1024
00:57:35,000 --> 00:57:39,000
ανοίγει και το πρώτο πρόσωπο, ο αριθμός 5, οδηγείται μέσα στο κατάστημα.

1025
00:57:39,000 --> 00:57:43,000
Πώς μπορώ να αλλάξω την εικόνα τώρα που έχω απο-ουρά το πρώτο πρόσωπο

1026
00:57:43,000 --> 00:57:47,000
στο μέτωπο της γραμμής;

1027
00:57:47,000 --> 00:57:50,000
Τι είναι αυτό; >> [Φοιτητικό] Αλλάξτε την ουρά.

1028
00:57:50,000 --> 00:57:52,000
Αλλάξτε το κεφάλι, οπότε 5 εξαφανίζεται.

1029
00:57:52,000 --> 00:57:56,000
Στην πραγματικότητα, είναι σαν-τον καλύτερο τρόπο για να το κάνουμε αυτό;

1030
00:57:56,000 --> 00:58:00,000
Στην πραγματικότητα, είναι σαν αυτός ο τύπος εξαφανίζεται.

1031
00:58:00,000 --> 00:58:03,000
Τι θα κάνει νούμερο 7 σε ένα πραγματικό κατάστημα;

1032
00:58:03,000 --> 00:58:05,000
Θα κάνουμε ένα μεγάλο βήμα προς τα εμπρός.

1033
00:58:05,000 --> 00:58:08,000
>> Αλλά αυτό που έχουμε έρθει να εκτιμήσουν, όταν πρόκειται για πίνακες

1034
00:58:08,000 --> 00:58:10,000
και κινείται γύρω από τα πράγματα;

1035
00:58:10,000 --> 00:58:12,000
Αυτό είναι το είδος του ένα χάσιμο του χρόνου σας, έτσι δεν είναι;

1036
00:58:12,000 --> 00:58:16,000
Γιατί πρέπει να είναι τόσο πρωκτική ώστε να έχουν τον πρώτο πρόσωπο

1037
00:58:16,000 --> 00:58:21,000
κατά την έναρξη της γραμμής στα σωματικά την έναρξη της κομμάτι της μνήμης;

1038
00:58:21,000 --> 00:58:23,000
Αυτό είναι εντελώς περιττό. Γιατί;

1039
00:58:23,000 --> 00:58:26,000
Τι θα μπορούσα να θυμάμαι μόνο αντ 'αυτού; >> [απάντηση ακούγεται φοιτητής]

1040
00:58:26,000 --> 00:58:30,000
Ακριβώς, θα μπορούσα απλά να θυμάστε με αυτό το πρόσθετο μέλος κεφάλι δεδομένων

1041
00:58:30,000 --> 00:58:34,000
ότι σήμερα ο επικεφαλής της λίστας δεν είναι πλέον 0, το οποίο ήταν μια στιγμή πριν.

1042
00:58:34,000 --> 00:58:39,000
Τώρα είναι στην πραγματικότητα ο αριθμός 1. Με τον τρόπο αυτό, να πάρω μια μικρή βελτιστοποίηση.

1043
00:58:39,000 --> 00:58:44,000
Ακριβώς επειδή έχω απο-ουρά κάποιος από τη γραμμή στην αρχή της γραμμής στο κατάστημα της Apple

1044
00:58:44,000 --> 00:58:47,000
δεν σημαίνει ότι ο καθένας πρέπει να αλλάξει, το οποίο ανάκληση είναι μια γραμμική λειτουργία.

1045
00:58:47,000 --> 00:58:50,000
Μπορώ να περάσουν αντί σταθερό χρόνο μόνο

1046
00:58:50,000 --> 00:58:53,000
και να επιτευχθεί στη συνέχεια μια πολύ ταχύτερη απόκριση.

1047
00:58:53,000 --> 00:58:56,000
Αλλά η τιμή είμαι πληρώνουν ό, τι είναι να κερδίσει αυτό το επιπλέον απόδοση

1048
00:58:56,000 --> 00:58:58,000
και δεν χρειάζεται να αλλάξει ο καθένας;

1049
00:58:58,000 --> 00:59:01,000
Ναι. >> [Ακούγεται ανταπόκριση των φοιτητών]

1050
00:59:01,000 --> 00:59:04,000
Μπορεί να προσθέσει περισσότερους ανθρώπους, καλά, ότι το πρόβλημα είναι ορθογώνια

1051
00:59:04,000 --> 00:59:07,000
για το γεγονός ότι δεν είμαστε μετατόπιση ανθρώπους γύρω.

1052
00:59:07,000 --> 00:59:11,000
Είναι ακόμα μια σειρά, έτσι ώστε αν ή όχι ο καθένας αλλαγή ή όχι-

1053
00:59:11,000 --> 00:59:13,000
OH, βλέπω τι εννοείς, εντάξει.

1054
00:59:13,000 --> 00:59:16,000
Στην πραγματικότητα, συμφωνώ με αυτό που λες στο ότι είναι σχεδόν σαν να

1055
00:59:16,000 --> 00:59:19,000
είμαστε τώρα ποτέ δεν πρόκειται να χρησιμοποιήσετε την έναρξη αυτού του πίνακα πια

1056
00:59:19,000 --> 00:59:22,000
γιατί αν μπορώ να αφαιρέσω 5, τότε μπορώ να αφαιρέσω 7.

1057
00:59:22,000 --> 00:59:24,000
Αλλά έβαλα μόνο τους ανθρώπους προς τα δεξιά.

1058
00:59:24,000 --> 00:59:28,000
>> Νιώθω σαν να είμαι σπατάλη χώρου, και τελικά ουρά μου διαλύεται σε τίποτα δεν σε όλα,

1059
00:59:28,000 --> 00:59:31,000
έτσι θα μπορούσαμε να έχουμε ακριβώς τους ανθρώπους περιτύλιξης,

1060
00:59:31,000 --> 00:59:35,000
και θα μπορούσαμε να σκεφτούμε αυτού του πίνακα πραγματικά ως ένα είδος κυκλικού οικοδομήματος,

1061
00:59:35,000 --> 00:59:38,000
αλλά χρησιμοποιούμε τον τελεστή σε C για να κάνει αυτό το είδος της περιτύλιξης;

1062
00:59:38,000 --> 00:59:40,000
[Ακούγεται ανταπόκριση των φοιτητών] >> Ο χειριστής modulo.

1063
00:59:40,000 --> 00:59:43,000
Θα ήταν λίγο ενοχλητικό να σκεφτεί μέσω πώς κάνετε το περιτύλιξης,

1064
00:59:43,000 --> 00:59:46,000
αλλά θα μπορούσαμε να το κάνουμε, και θα μπορούσαμε να αρχίζουν να βάζουν τους ανθρώπους σε ό, τι χρησιμοποιείται για να είναι το μέτωπο της γραμμής,

1065
00:59:46,000 --> 00:59:52,000
αλλά απλά να θυμάστε αυτή τη μεταβλητή με το κεφάλι ποιος είναι ο πραγματικός αρχηγός της γραμμής είναι στην πραγματικότητα.

1066
00:59:52,000 --> 00:59:57,000
Τι θα συμβεί αν, αντ 'αυτού, στόχος μας τελικά, αν και,

1067
00:59:57,000 --> 01:00:00,000
ήταν να δούμε τους αριθμούς, όπως κάναμε εδώ στη σκηνή με Anita,

1068
01:00:00,000 --> 01:00:02,000
αλλά θέλουμε πραγματικά το καλύτερο όλων αυτών των κόσμων;

1069
01:00:02,000 --> 01:00:05,000
Θέλουμε περισσότερη πολυπλοκότητα από σειρά επιτρέπει

1070
01:00:05,000 --> 01:00:09,000
γιατί θέλουμε την ικανότητα να αναπτύσσονται δυναμικά τη δομή των δεδομένων.

1071
01:00:09,000 --> 01:00:12,000
Αλλά δεν θέλουμε να χρειαστεί να καταφύγουν σε κάτι που επισημάναμε

1072
01:00:12,000 --> 01:00:15,000
στην πρώτη διάλεξη δεν ήταν ένας αλγόριθμος βέλτιστης,

1073
01:00:15,000 --> 01:00:17,000
εκείνη της γραμμικής αναζήτησης.

1074
01:00:17,000 --> 01:00:21,000
Αποδεικνύεται ότι μπορείτε να, στην πραγματικότητα, να επιτύχουν

1075
01:00:21,000 --> 01:00:24,000
ή τουλάχιστον κοντά σε σταθερό χρόνο, σύμφωνα με την οποία κάποιος σαν Anita,

1076
01:00:24,000 --> 01:00:27,000
αν διαμορφώνει δομή δεδομένων της να μην είναι μια συνδεδεμένη λίστα,

1077
01:00:27,000 --> 01:00:30,000
να μην είναι μια στοίβα, να μην είναι μια ουρά, θα μπορούσε, στην πραγματικότητα,

1078
01:00:30,000 --> 01:00:33,000
καταλήξουμε σε μια δομή δεδομένων η οποία της επιτρέπει να δούμε τα πράγματα,

1079
01:00:33,000 --> 01:00:37,000
ακόμη και οι λέξεις, όχι μόνο αριθμούς, σε ό, τι θα καλέσουμε σταθερό χρόνο.

1080
01:00:37,000 --> 01:00:40,000
>> Και στην πραγματικότητα, κοιτάζοντας μπροστά, μία από τις psets σε αυτή την τάξη είναι σχεδόν πάντα

1081
01:00:40,000 --> 01:00:43,000
μια υλοποίηση ενός ορθογράφος, οπότε

1082
01:00:43,000 --> 01:00:46,000
σας δίνουμε και πάλι περίπου 150.000 αγγλικές λέξεις και ο στόχος είναι να

1083
01:00:46,000 --> 01:00:51,000
φορτώσετε στη μνήμη εκείνων γρήγορα και να είναι σε θέση να απαντήσει στις ερωτήσεις του εντύπου

1084
01:00:51,000 --> 01:00:54,000
είναι αυτή η λέξη είναι γραμμένες σωστά;

1085
01:00:54,000 --> 01:00:58,000
Και θα ήταν πραγματικά πιπιλίζουν αν έπρεπε να επαναλάβει σε όλα τα 150.000 λέξεις για να απαντήσω σε αυτό.

1086
01:00:58,000 --> 01:01:02,000
Αλλά, στην πραγματικότητα, θα δούμε ότι μπορούμε να το κάνουμε σε πολύ, πολύ γρήγορο χρόνο.

1087
01:01:02,000 --> 01:01:06,000
Και πρόκειται να συνεπάγεται την εφαρμογή κάτι που ονομάζεται ένα πίνακα κατακερματισμού,

1088
01:01:06,000 --> 01:01:09,000
και παρόλο που με την πρώτη ματιά αυτό το πράγμα που ονομάζεται hash πίνακας πρόκειται να

1089
01:01:09,000 --> 01:01:12,000
ας την επίτευξη αυτών των σούπερ ταχεία χρόνους απόκρισης,

1090
01:01:12,000 --> 01:01:18,000
αποδεικνύεται ότι υπάρχει πράγματι ένα πρόβλημα.

1091
01:01:18,000 --> 01:01:23,000
Όταν έρχεται η ώρα να εφαρμόσει αυτό το πράγμα που ονομάζεται-και πάλι, το κάνω και πάλι.

1092
01:01:23,000 --> 01:01:25,000
Είμαι ο μόνος εδώ.

1093
01:01:25,000 --> 01:01:28,000
Όταν έρχεται η ώρα για την εφαρμογή αυτό το πράγμα που ονομάζεται hash πίνακα,

1094
01:01:28,000 --> 01:01:30,000
θα πάμε να πρέπει να πάρει μια απόφαση.

1095
01:01:30,000 --> 01:01:32,000
Πόσο μεγάλη θα πρέπει αυτό το πράγμα να είναι στην πραγματικότητα;

1096
01:01:32,000 --> 01:01:36,000
Και όταν θα αρχίσουμε την εισαγωγή αριθμών σε αυτό το hash πίνακα,

1097
01:01:36,000 --> 01:01:38,000
πώς θα πάμε να τις αποθηκεύσετε με τέτοιο τρόπο

1098
01:01:38,000 --> 01:01:42,000
ότι μπορούμε να τα πάρει πίσω το συντομότερο εμείς τους πήρε μέσα;

1099
01:01:42,000 --> 01:01:45,000
Αλλά θα δούμε πριν από καιρό ότι αυτό το θέμα

1100
01:01:45,000 --> 01:01:48,000
όταν τα γενέθλια του καθενός είναι στην κατηγορία θα είναι πολύ σχετικός.

1101
01:01:48,000 --> 01:01:51,000
Αποδεικνύεται ότι σε αυτό το δωμάτιο, έχουμε μερικές εκατοντάδες άνθρωποι,

1102
01:01:51,000 --> 01:01:56,000
έτσι οι πιθανότητες ότι δύο από μας έχουν τα ίδια γενέθλια είναι μάλλον αρκετά υψηλή.

1103
01:01:56,000 --> 01:01:58,000
Τι θα συμβεί αν υπήρχαν μόνο 40 από εμάς σε αυτή την αίθουσα;

1104
01:01:58,000 --> 01:02:02,000
Ποιες είναι οι πιθανότητες των δύο ανθρώπων που έχουν την ίδια γενέθλια;

1105
01:02:02,000 --> 01:02:04,000
[Φοιτητές] Πάνω από το 50%.

1106
01:02:04,000 --> 01:02:06,000
Ναι, πάνω από 50%. Στην πραγματικότητα, ακόμη και έφερα ένα γράφημα.

1107
01:02:06,000 --> 01:02:08,000
Αποδεικνύεται-και αυτό είναι πραγματικά ακριβώς ένα sneak preview-

1108
01:02:08,000 --> 01:02:12,000
εάν υπάρχει μόνο 58 από εμάς σε αυτή την αίθουσα, η πιθανότητα 2 of us

1109
01:02:12,000 --> 01:02:16,000
έχουν την ίδια γενέθλια είναι εξαιρετικά υψηλό, σχεδόν το 100%,

1110
01:02:16,000 --> 01:02:20,000
και ότι πρόκειται να προκαλέσει ένα σωρό κακό για μας την Τετάρτη.

1111
01:02:20,000 --> 01:02:24,000
>> Με αυτόν εν λόγω, ας αναβάλουμε εδώ. Θα σας δούμε την Τετάρτη.

1112
01:02:24,000 --> 01:02:28,000
[Χειροκροτήματα]

1113
01:02:28,000 --> 01:02:30,000
[CS50.TV]