الأخبار التكنولوجية والاستعراضات والنصائح!
blogs5

قالب مقابلة Leetcode Coding لأنماط الكود الشائعة

ستساعدك المقالة التالية: قالب مقابلة Leetcode Coding لأنماط الكود الشائعة

مؤشرين: مدخل واحد ، ونهايات متقابلة

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16public int fn (int[] arr) {int left = 0 ؛ int right = arr.length – 1 ؛ عدد الجواب = 0 ؛ بينما (يسار <يمين) {// افعل بعض المنطق هنا مع اليسار واليمين إذا (CONDITION) {left ++؛ } else {right--؛ }} عودة الجواب؛ }

مؤشرين: مدخلين ، استنفاد كلاهما

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24public int fn (int[] arr1 ، كثافة العمليات[] arr2) {int i = 0 ، j = 0 ، الجواب = 0 ؛ while (i

نافذة منزلقة

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16public int fn (int[] arr) {int left = 0 ، الجواب = 0 ، تيار = 0 ؛ لـ (int right = 0؛ right

بناء مجموع البادئة

1 2 3 4 5 6 7 8 9 10كثافة العمليات العامة[] fn (int[] arr) {int[] البادئة = int[arr.length]؛ بادئة[0] = ار[0]؛ لـ (int i = 1 ؛ i

بناء سلسلة فعالة

1 2 3 4 5 6 7 8سلسلة عامة fn (char[] arr) {StringBuilder sb = new StringBuilder () ، لـ (char c: arr) {sb.append (c) ؛ } return sb.toString ()؛ }

في JavaScript ، تُظهر المقارنة المعيارية أن التسلسل مع + = أسرع من استخدام .join ().

القائمة المرتبطة: مؤشر سريع وبطيء

1 2 3 4 5 6 7 8 9 10 11 12 13public int fn (ListNode head) {ListNode slow = head ؛ ListNode fast = الرأس ؛ عدد الجواب = 0 ؛ while (fast! = null && fast.next! = null) {// do logic slow = slow.next؛ سريع = fast.next.next ؛ } عودة الجواب؛ }

عكس قائمة مرتبطة

1 2 3 4 5 6 7 8 9 10 11 12ListNode العامة fn (رأس ListNode) {ListNode Current = head ؛ ListNode prev = فارغ ؛ while (current! = null) {ListNode nextNode = current.next؛ Current.next = prev ؛ سابق = تيار ؛ تيار = nextNode ؛ } عودة prev؛ }

ابحث عن عدد من المصفوفات الفرعية التي تناسب معيارًا دقيقًا

1 2 3 4 5 6 7 8 9 10 11 12 13public int fn (int[] arr، int k) {Map counts = new HashMap <> ()؛ counts.put (0 ، 1) ؛ الجواب int = 0 ، تيار = 0 ؛ لـ (int num: arr) {// do logic to change current ans + = counts.getOrDefault (current – k، 0)؛ counts.put (تيار ، counts.getOrDefault (تيار ، 0) + 1) ؛ } عودة الجواب؛ }

مكدس متزايد رتيب

يمكن تطبيق نفس المنطق للحفاظ على قائمة انتظار رتيبة.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16public int fn (int[] arr) {Stack stack = new Stack <> () ؛ عدد الجواب = 0 ؛ لـ (int num: arr) {// للتقليل الرتيب ، ما عليك سوى قلب> إلى num) {// do logic stack.pop () ؛ } stack.push (num) ؛ } عودة الجواب؛ }

الشجرة الثنائية: DFS (تكراري)

1 2 3 4 5 6 7 8 9 10 11public int dfs (TreeNode root) {if (root == null) {return 0؛ } int ans = 0 ؛ // do logic dfs (root.left) ؛ dfs (root.right) ؛ عودة الجواب }

الشجرة الثنائية: DFS (تكراري)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18public int dfs (TreeNode root) {Stack stack = new Stack <> () ؛ المكدس (الجذر) ؛ عدد الجواب = 0 ؛ while (! stack.empty ()) {TreeNode node = stack.pop ()؛ // do logic if (node.left! = null) {stack.push (node.left)؛ } if (node.right! = null) {stack.push (node.right)؛ }} عودة الجواب؛ }

الشجرة الثنائية: BFS

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23public int fn (TreeNode root) {Queue queue = new LinkedList <> () ؛ queue.add (الجذر) ؛ عدد الجواب = 0 ؛ while (! queue.isEmpty ()) {int currentLength = queue.size ()؛ // do logic for Current level for (int i = 0؛ i

الرسم البياني: DFS (تكراري)

بالنسبة لقوالب الرسم البياني ، افترض أن العقد مرقمة من 0 إلى n – 1 وأن ​​الرسم البياني معطى كقائمة مجاورة. اعتمادًا على المشكلة ، قد تحتاج إلى تحويل الإدخال إلى قائمة مجاورة مكافئة قبل استخدام القوالب.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19تعيين ينظر = جديد HashSet <> () ؛ public int fn (int[][] رسم بياني) {see.add (START_NODE)؛ إرجاع dfs (START_NODE ، رسم بياني) ؛ } public int dfs (int node، int[][] الرسم البياني) {int ans = 0 ؛ // قم ببعض المنطق لـ (intighbor: graph[node]) {if (! see.contains (neighbour)) {see.add (Neighbor)؛ الجواب + = dfs (الجار ، الرسم البياني) ؛ }} عودة الجواب؛ }

الرسم البياني: DFS (تكراري)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20public int fn (int[][] الرسم البياني) {Stack stack = new Stack <> () ؛ تعيين ينظر = جديد HashSet <> () ؛ stack.push (START_NODE) ​​؛ رأيت.إضافة (START_NODE) ​​، عدد الجواب = 0 ؛ while (! stack.empty ()) {int node = stack.pop ()؛ // قم ببعض المنطق لـ (intighbor: graph[node]) {if (! see.contains (neighbour)) {see.add (Neighbor)؛ stack.push (الجار) ؛ }}} إرجاع الجواب؛ }

الرسم البياني: BFS

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20public int fn (int[][] الرسم البياني) {Queue queue = new LinkedList <> () ؛ تعيين ينظر = جديد HashSet <> () ؛ queue.add (START_NODE) ​​، رأيت.إضافة (START_NODE) ​​، عدد الجواب = 0 ؛ while (! queue.isEmpty ()) {int node = queue.remove ()؛ // قم ببعض المنطق لـ (intighbor: graph[node]) {if (! see.contains (neighbour)) {see.add (Neighbor)؛ queue.add (الجار) ؛ }}} إرجاع الجواب؛ }

ابحث عن أفضل عناصر k باستخدام الكومة

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16كثافة العمليات العامة[] fn (int[] arr، int k) {PriorityQueue heap = new PriorityQueue <> (CRITERIA) ؛ لـ (int num: arr) {heap.add (num)؛ إذا (heap.size ()> k) {heap.remove () ؛ }} عدد صحيح[] الجواب = كثافة العمليات الجديدة[k]؛ لـ (int i = 0 ؛ i
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19public int fn (int[] arr، int target) {int left = 0؛ int right = arr.length – 1 ؛ بينما (يسار <= يمين) {int mid = left + (يمين - يسار) / 2 ؛ إذا (arr[mid] == الهدف) {// فعل شيء يعود في منتصفه ؛ } إذا (arr[mid] > الهدف) {right = mid – 1؛ } آخر {يسار = منتصف + 1 ؛ }} // left هي نقطة الإدراج التي ترجع إلى اليسار ؛ }

بحث ثنائي: عناصر مكررة ، أقصى اليسار نقطة إدخال

1 2 3 4 5 6 7 8 9 10 11 12 13 14public int fn (int[] arr، int target) {int left = 0؛ int right = arr.length ؛ بينما (يسار <يمين) {int mid = left + (يمين - يسار) / 2 ؛ إذا (arr[mid] > = الهدف) {right = mid} وإلا {left = mid + 1؛ }} رجوع يسار؛ }

بحث ثنائي: عناصر مكررة ، نقطة إدخال في أقصى اليمين

1 2 3 4 5 6 7 8 9 10 11 12 13 14public int fn (int[] arr، int target) {int left = 0؛ int right = arr.length ؛ بينما (يسار <يمين) {int mid = left + (يمين - يسار) / 2 ؛ إذا (arr[mid] > الهدف) {right = mid؛ } آخر {يسار = منتصف + 1 ؛ }} رجوع يسار؛ }

بحث ثنائي: عن مشاكل الجشع

إذا كنت تبحث عن حد أدنى:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19public int fn (int[] arr) {int left = MINIMUM_POSSIBLE_ANSWER ، int right = MAXIMUM_POSSIBLE_ANSWER ، بينما (يسار <= يمين) {int mid = left + (يمين - يسار) / 2 ؛ إذا (تحقق (منتصف)) {يمين = منتصف - 1 ؛ } آخر {يسار = منتصف + 1 ؛ }} رجوع يسار؛ } التحقق المنطقي العام (int x) {// يتم تنفيذ هذه الوظيفة اعتمادًا على مشكلة إرجاع BOOLEAN ؛ }

إذا كنت تبحث عن حد أقصى:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19public int fn (int[] arr) {int left = MINIMUM_POSSIBLE_ANSWER ، int right = MAXIMUM_POSSIBLE_ANSWER ، بينما (يسار <= يمين) {int mid = left + (يمين - يسار) / 2 ؛ إذا (تحقق (منتصف)) {يسار = منتصف + 1 ؛ } آخر {right = mid - 1؛ }} حق العودة ؛ } التحقق المنطقي العام (int x) {// يتم تنفيذ هذه الوظيفة اعتمادًا على مشكلة إرجاع BOOLEAN ؛ }

التراجع

1 2 3 4 5 6 7 8 9 10 11 12 13public int backtrack (STATE current، OTHER_ARGUMENTS …) {if (BASE_CASE) {// قم بتعديل الإجابة بإرجاع 0 ؛ } int ans = 0 ؛ لـ (ITERATE_OVER_INPUT) {// تعديل الحالة الحالية ans + = تراجع (تيار ، OTHER_ARGUMENTS …) // التراجع عن تعديل الحالة الحالية}}

البرمجة الديناميكية: حفظ الذاكرة من أعلى إلى أسفل

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19الخريطة memo = new HashMap <> ()؛ public int fn (int[] arr) {return dp (STATE_FOR_WHOLE_INPUT، arr) ؛ } public int dp (STATE، int[] arr) {if (BASE_CASE) {return 0؛ } if (memo.contains (STATE)) {return memo.get (STATE)؛ } int ans = RECURRENCE_RELATION (STATE) ، memo.put (STATE ، الجواب) ؛ عودة الجواب }

بناء ثلاثي

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29// note: يعد استخدام فئة ضروريًا فقط إذا كنت تريد تخزين البيانات في كل عقدة. // خلاف ذلك ، يمكنك تنفيذ trie باستخدام خرائط التجزئة فقط. class TrieNode {// يمكنك تخزين البيانات في العقد إذا كنت ترغب في بيانات int ؛ تعيين الأطفال <حرف ، TrieNode> ؛ TrieNode () {this.children = new HashMap <> ()؛ }} العامة TrieNode buildTrie (String[] الكلمات) {TrieNode root = new TrieNode () ؛ لـ (String word: Words) {TrieNodeurr = root؛ لـ (char c: word.toCharArray ()) {if (! } Current =urr.children.get (c) ؛ } // في هذه المرحلة ، لديك كلمة كاملة في cur // يمكنك إجراء المزيد من المنطق هنا لإعطاء سمة الحالية الحالية إذا كنت تريد} عودة الجذر ؛ }

نحن نوصيك: