โคลนต้นไม้ไบนารีด้วยตัวชี้แบบสุ่ม

ระดับความยาก ยาก
ถามบ่อยใน แอคโคไลท์ อเมซอน ซิสโก้ ข้อเท็จจริง fanatics Google ไมโครซอฟท์ ทำงาน Snapchat
กัญชา ต้นไม้เข้าชม 129

คำชี้แจงปัญหา

คุณจะได้รับที่สมบูรณ์ ต้นไม้ไบนารี ด้วยตัวชี้แบบสุ่ม ตัวชี้แบบสุ่มหมายถึงโหนดที่ทุกโหนดชี้ไปที่อื่นที่ไม่ใช่ลูกทางซ้ายและขวา ดังนั้นสิ่งนี้ยังเปลี่ยนโครงสร้างมาตรฐานของโหนดในต้นไม้ไบนารีอย่างง่าย ตอนนี้โหนดของต้นไม้ไบนารีจะเก็บข้อมูลไว้ที่โหนดปัจจุบันและตัวชี้ไปทางซ้ายขวาและตัวชี้แบบสุ่ม ดังนั้นตอนนี้เราพร้อมที่จะไปกับสิ่งที่ปัญหาถาม? ปัญหา“ โคลนต้นไม้ไบนารีด้วยตัวชี้แบบสุ่ม” ขอให้สร้างต้นไม้ไบนารีใหม่ซึ่งเป็นสำเนาที่ถูกต้องของต้นไม้เริ่มต้นที่กำหนด ดังนั้นในทรีที่สร้างขึ้นใหม่หากเราเลือกโหนดทางซ้ายขวาและตัวชี้แบบสุ่มหมายถึงโหนดในทรีใหม่นี้ซึ่งสอดคล้องกับโหนดในทรีดั้งเดิม

ตัวอย่าง

อินพุต

โคลนต้นไม้ไบนารีด้วยตัวชี้แบบสุ่มหมุด

Inorder traversal of original binary tree is [current node data, random pointer data]:
[1 2], [2 7], [3 9], [5 1], [7 1], [9 5],

Inorder traversal of cloned binary tree is[current node data, random pointer data]:
[1 2], [2 7], [3 9], [5 1], [7 1], [9 5],

คำอธิบาย

โหนดซ้ายและขวาของต้นไม้ไบนารีจะแสดงตามปกติทางซ้ายและขวาของแต่ละโหนด และตัวชี้อื่น ๆ ทั้งหมดตัวชี้ซ้ายและขวาคือตัวชี้แบบสุ่ม ขอบบางด้านมีลูกศรคู่ (ซึ่งชี้ไปทั้งสองทิศทาง) ทิศทางไปยังพาเรนต์ใด ๆ ของโหนดแสดงว่าโหนดมีตัวชี้สุ่มไปยังพาเรนต์ เอาต์พุตถูกกำหนดในรูปแบบ [ข้อมูลโหนดปัจจุบัน / ข้อมูลโหนดสุ่ม]

วิธีการแฮช

ดังที่เราทราบดีว่าเราจำเป็นต้องสร้างต้นไม้ใหม่ซึ่งเป็นสำเนาที่ถูกต้องของต้นไม้เริ่มต้น เราสามารถเรียกใช้การข้ามผ่านตามลำดับและสร้างสำเนาได้ แต่เราจะประสบปัญหากับพอยน์เตอร์แบบสุ่มเนื่องจากบางโหนดอาจชี้ไปยังโหนดที่ยังไม่ได้สร้าง เพื่อกำจัดข้อผิดพลาดนี้ ก่อนอื่นเราจะสร้างต้นไม้ใหม่ จากนั้นใช้ไฟล์ HashMap ซึ่งเก็บแอดเดรสของโหนดใหม่ที่สอดคล้องกับแต่ละโหนดในทรีดั้งเดิม ดังนั้นเราจึงเรียกใช้การข้ามผ่านตามลำดับอีกครั้งและสร้างพอยน์เตอร์แบบสุ่มไปยังโหนดของทรีใหม่ (ซึ่งเก็บเป็นค่าใน HashMap)

แนวทางที่มีประสิทธิภาพ

ในแนวทางข้างต้นเราต้องเก็บไฟล์ HashMap ซึ่งเก็บที่อยู่โหนดโคลนที่สอดคล้องกับแต่ละโหนดในทรีดั้งเดิม ดังนั้นแทนที่จะทำอย่างนั้นเราจะทำบางอย่างเหมือนที่ทำเพื่อโคลนก รายการที่เชื่อมโยง ด้วยตัวชี้แบบสุ่ม เราจะผลักโหนดที่สร้างขึ้นใหม่ระหว่างชายด์ด้านซ้ายและโหนดที่เกี่ยวข้องในทรีดั้งเดิม จนถึงตอนนี้เราได้เปลี่ยนโครงสร้างของต้นไม้เริ่มต้น ในการตั้งค่าตัวชี้แบบสุ่มเรารู้ว่าโหนดใหม่ที่ตรงกับโหนดนั้นจะเป็นโหนดลูกทางซ้ายเสมอ ดังนั้นเราเพียงแค่ตั้งค่าตัวชี้แบบสุ่มไปที่ชายด์ด้านซ้ายของโหนดในแผนผังอินพุต แต่เรายังมีสิ่งหนึ่งที่ต้องดูแล เราจำเป็นต้องกู้คืนชายด์ด้านซ้ายของโหนดของต้นไม้เริ่มต้น & โคลน เมื่อเสร็จแล้วเราได้โคลนต้นไม้ไบนารีด้วยพอยน์เตอร์แบบสุ่ม

รหัส

รหัส C ++ เพื่อโคลนต้นไม้ไบนารีด้วยตัวชี้แบบสุ่ม

#include <iostream>
using namespace std;

struct node{
    int data;
  node *left, *right, *random;
};

node* create(int data){
  node* tmp = new node();
  tmp->data = data;
  tmp->left = tmp->right = tmp->random = NULL;
}

// print inorder traversal of the given tree in [node, random node] format
void inorder(node* root)
{
  if(root == NULL)
    return;
  // print inorder traversal of left tree
  inorder(root->left);
  // print in [current node, random node] format
  cout << "[" << root->data << " ";
  if (root->random == NULL)
    cout << "NULL], ";
  else
    cout << root->random->data << "], ";
  // print inorder traversal of right tree
  inorder(root->right);
}

// insert clone nodes between the original node and its left child
node* insertCloneNode(node* originalNode)
{
  if (originalNode == NULL)
    return NULL;

  node* left = originalNode->left;
  originalNode->left = create(originalNode->data);
  originalNode->left->left = left;
  if(left != NULL)
    left->left = insertCloneNode(left);

  originalNode->left->right = insertCloneNode(originalNode->right);
  return originalNode->left;
}

// sets the random pointers in clone tree
void setRandomNode(node* originalNode, node* cloneNode)
{
  if (originalNode == NULL)
    return;
  if(originalNode->random != NULL)
    cloneNode->random = originalNode->random->left;
  else
    cloneNode->random = NULL;

  if(originalNode->left != NULL && cloneNode->left != NULL)
    setRandomNode(originalNode->left->left, cloneNode->left->left);
  setRandomNode(originalNode->right, cloneNode->right);
}

// after all the work restore the left pointers in original and clone tree
void restoreTreeLeftNode(node* originalNode, node* cloneNode)
{
  if (originalNode == NULL)
    return;
  if (cloneNode->left != NULL)
  {
    node* cloneLeft = cloneNode->left->left;
    originalNode->left = originalNode->left->left;
    cloneNode->left = cloneLeft;
  }
  else
    originalNode->left = NULL;

  restoreTreeLeftNode(originalNode->left, cloneNode->left);
  restoreTreeLeftNode(originalNode->right, cloneNode->right);
}

// constructs the new clone tree
node* cloneTree(node* originalNode)
{
  if (originalNode == NULL)
    return NULL;
  node* cloneNode = insertCloneNode(originalNode);
  setRandomNode(originalNode, cloneNode);
  restoreTreeLeftNode(originalNode, cloneNode);
  return cloneNode;
}


int main()
{
  node *root = create(3);
  node* two = create(2);
  node* one = create(1);
  node* seven = create(7);
  node* five = create(5);
  node* nine = create(9);

  root->left = two;
  root->left->left = one;
  root->right = seven;
  root->right->left = five;
  root->right ->right = nine;

  root->random = nine;
  root->left->random = seven;
  root->left->left->random = two;
  root->right->random = one;
  root->right->left->random = one;
  root->right->right->random = five;

  cout << "Inorder traversal of original binary tree is [current node data, random pointer data]: \n";
  inorder(root);

  node *clone = cloneTree(root);

  cout << "\n\nInorder traversal of cloned binary tree is[current node data, random pointer data]: \n";
  inorder(clone);

  return 0;
}
Inorder traversal of original binary tree is [current node data, random pointer data]:
[1 2], [2 7], [3 9], [5 1], [7 1], [9 5],

Inorder traversal of cloned binary tree is[current node data, random pointer data]:
[1 2], [2 7], [3 9], [5 1], [7 1], [9 5],

รหัส Java เพื่อโคลนต้นไม้ไบนารีด้วยตัวชี้แบบสุ่ม

import java.util.*;
// Class that denotes a node of the tree
class node
{ 
    int data; 
    node left, right, random; 
 
    public node(int data) 
    { 
        this.data = data;
        left = right = random = null; 
    } 
}
 
class Tree 
{ 
    static node root;
  static node create(int data) {
    node tmp = new node(data);
    return tmp;
  }
  // print inorder traversal of the given tree in [node, random node] format
  static void inorder(node root){
    if(root != null){
      // print inorder traversal of left tree
      inorder(root.left);
      // print in [current node, random node] format
      System.out.print("[" + root.data + " ");
      if(root.random == null)
        System.out.print("null], ");
      else
        System.out.print(root.random.data +"], ");
      // print inorder traversal of right tree
      inorder(root.right);
    }
  }
 
  // insert clone nodes between the original node and its left child
  static node insertCloneNode(node originalNode) 
  { 
    if (originalNode == null) 
      return null; 
 
    node left = originalNode.left; 
    originalNode.left = create(originalNode.data); 
    originalNode.left.left = left; 
    if(left != null) 
      left.left = insertCloneNode(left); 
 
    originalNode.left.right = insertCloneNode(originalNode.right); 
    return originalNode.left; 
  } 
 
  // sets the random pointers in clone tree
  static void setRandomNode(node originalNode, node cloneNode) 
  { 
    if (originalNode != null){
      if(originalNode.random != null) 
        cloneNode.random = originalNode.random.left; 
      else
        cloneNode.random = null; 
 
      if(originalNode.left != null && cloneNode.left != null) 
        setRandomNode(originalNode.left.left, cloneNode.left.left); 
      setRandomNode(originalNode.right, cloneNode.right); 
    }
  } 
 
  // after all the work restore the left pointers in original and clone tree
  static void restoreTreeLeftNode(node originalNode, node cloneNode) 
  { 
    if (originalNode != null) {
      if (cloneNode.left != null) 
      { 
        node cloneLeft = cloneNode.left.left; 
        originalNode.left = originalNode.left.left; 
        cloneNode.left = cloneLeft; 
      } 
      else
        originalNode.left = null; 
 
      restoreTreeLeftNode(originalNode.left, cloneNode.left); 
      restoreTreeLeftNode(originalNode.right, cloneNode.right); 
    }
  } 
 
  // constructs the new clone tree
  static node cloneTree(node originalNode) 
  { 
    if (originalNode == null)
      return null;
    node cloneNode = insertCloneNode(originalNode); 
    setRandomNode(originalNode, cloneNode); 
    restoreTreeLeftNode(originalNode, cloneNode); 
    return cloneNode; 
  } 
 
  public static void main(String[] args) {
    node root = create(3);
    node two = create(2);
    node one = create(1);
    node seven = create(7);
    node five = create(5);
    node nine = create(9);
 
    root.left = two;
    root.left.left = one;
    root.right = seven;
    root.right.left = five;
    root.right .right = nine;
 
    root.random = nine;
    root.left.random = seven;
    root.left.left.random = two;
    root.right.random = one;
    root.right.left.random = one;
    root.right.right.random = five;
 
    System.out.print("Inorder traversal of original binary tree is[current node data, random pointer data]: \n");
    inorder(root);
 
    node clone = cloneTree(root);
 
    System.out.print("\n\nInorder traversal of cloned binary tree is[current node data, random pointer data]: \n");
    inorder(clone);
  }
}
Inorder traversal of original binary tree is[current node data, random pointer data]: 
[1 2], [2 7], [3 9], [5 1], [7 1], [9 5], 

Inorder traversal of cloned binary tree is[current node data, random pointer data]: 
[1 2], [2 7], [3 9], [5 1], [7 1], [9 5],

การวิเคราะห์ความซับซ้อนเพื่อโคลนทรีไบนารีด้วยตัวชี้แบบสุ่ม

ความซับซ้อนของเวลา 

บน), เราเพิ่งข้ามโหนดในต้นไม้ไบนารีและเนื่องจากมีโหนด N ในต้นไม้ไบนารี ดังนั้นความซับซ้อนของเวลาจึงเป็นเชิงเส้น

ความซับซ้อนของอวกาศ

O (1), เนื่องจากเราไม่ได้จัดเก็บข้อมูลใด ๆ ในอาร์เรย์หรือแผนที่ ดังนั้นความซับซ้อนของพื้นที่จึงคงที่

คำถามสัมภาษณ์ยอดนิยม

S.No คำถามสัมภาษณ์ ถามมากี่ครั้งแล้ว
1ลบโหนดในรายการที่เชื่อมโยงแบบทวีคูณ2826
2โปรแกรม Java เพื่อค้นหาจำนวนโหนดใน Binary Tree2506
3ย้อนกลับสตริงโดยไม่มีผลต่ออักขระพิเศษ2467
4ลบโหนดของรายการที่เชื่อมโยงในตำแหน่งที่กำหนด1981
5Palindrome ใช้การเรียกซ้ำ1878
6แทรกโหนดในรายการที่เชื่อมโยงในลักษณะที่เรียงลำดับ (จากน้อยไปมาก)1667
7ค้นหาคู่องค์ประกอบจากอาร์เรย์ที่มีผลรวมเท่ากับตัวเลข1654
8จัดเรียงองค์ประกอบตามความถี่ของการเกิดขึ้น1637
9เขียนโปรแกรมเพื่อพิมพ์การเรียงสับเปลี่ยนทั้งหมดของสตริงที่กำหนด1611
10ค้นหาระยะห่างต่ำสุดระหว่างตัวเลขสองตัวในอาร์เรย์1479
11สร้างรายการที่เชื่อมโยงเป็นทวีคูณ1450
12จัดเรียงด่วน1423
13ย้อนกลับอาร์เรย์1416
14หน้าต่างที่เล็กที่สุดในสตริงที่มีอักขระทั้งหมดของสตริงอื่น1399
15ค้นหาสามเท่าที่รวมเป็นมูลค่าที่กำหนด1363
16ลบรายการที่ซ้ำกันทั้งหมดซ้ำ ๆ1359
17องค์ประกอบที่ทำซ้ำครั้งแรก1346
18จัดเรียงเลขคู่และเลขคี่เพื่อให้คี่มาหลังคู่1325
19ผลรวมของตัวเลขในสตริง1322
20จำนวนบวกที่เล็กที่สุดที่ขาดหายไปในอาร์เรย์ที่ไม่ได้เรียงลำดับ1290
21ตรวจสอบว่าองค์ประกอบของอาร์เรย์ติดต่อกันหรือไม่1259
22ตรวจหาลูปในรายการที่เชื่อมโยง1243
23Subarray ที่ต่อเนื่องกันที่ใหญ่ที่สุด1234
24จัดเรียงอย่างรวดเร็วในรายการที่เชื่อมโยงแบบ SIngly1220
25Subarray กับผลรวมที่ได้รับ1216
26พิมพ์ชุดค่าผสม R ที่เป็นไปได้ทั้งหมดในอาร์เรย์ขนาด N ที่กำหนด1207
27ฟังก์ชันเรียกซ้ำเพื่อค้นหาสตริงย่อย1202
28ค้นหาจำนวนการทำซ้ำสูงสุดในอาร์เรย์1160
29การส่งผ่านคำสั่ง Binary Tree Level ใน Java1129
30ค้นหาองค์ประกอบที่เล็กที่สุดอันดับหนึ่งและสอง1126
31ตรวจสอบว่ารายการที่เชื่อมโยงสองรายการเหมือนกันหรือไม่1110
32ผลรวม Subarray สูงสุดโดยใช้ Divide และ Conquer1105
33ลบอักขระออกจากสตริงแรกซึ่งอยู่ในวินาที1073
34ค้นหาผู้นำในอาร์เรย์1064
35สลับโหนดในรายการที่เชื่อมโยง1041
36ค้นหาจำนวนครั้งที่เกิดขึ้นคี่ในอาร์เรย์1008
37จัดเรียงหมายเลขที่กำหนดให้เป็นหมายเลขที่ใหญ่ที่สุด II996
38ค้นหาตัวละครที่พบบ่อยเป็นอันดับสอง991
39กำหนดให้สตริงค้นหาอักขระที่ไม่ซ้ำกันตัวแรก973
40ค้นหา Triplet ในอาร์เรย์ด้วยผลรวมที่กำหนด968
41จำนวนครั้งทั้งหมดของรายการที่ระบุในรายการที่เชื่อมโยง958
42รับอาร์เรย์ที่เรียงลำดับและหมายเลข x ให้ค้นหาคู่ในอาร์เรย์ที่มีผลรวมใกล้เคียงกับ x958
43โปรแกรมตรวจสอบว่าสตริงมีการหมุนซึ่งกันและกันหรือไม่949
44พิมพ์คำที่เป็นไปได้ทั้งหมดจากหมายเลขโทรศัพท์937
45ค้นหาหมายเลขที่หายไป928
46จัดเรียงตัวเลขบวกและลบใหม่อีกทางหนึ่งในอาร์เรย์925
47สตริงย่อย Palindromic ที่ยาวที่สุด907
48แยกโหนดคู่และคี่ในรายการที่เชื่อมโยง888
49พิมพ์ลำดับต่อมาที่ยาวที่สุด885
50สหภาพและจุดตัดของรายการที่เชื่อมโยงสองรายการ877
51แปลงสตริงหนึ่งไปเป็นอีกสตริงโดยใช้จำนวนขั้นต่ำของการดำเนินการที่กำหนด872
52ตรวจสอบสตริงที่จัดเรียงใหม่สามารถสร้าง palindrome ได้853
53จัดเรียงอาร์เรย์ที่กำหนดใหม่ในรูปแบบขั้นต่ำสูงสุด850
54นับสามเหลี่ยมที่เป็นไปได้823
55การใช้งานแบบวนซ้ำของการเรียงลำดับด่วน822
56การคูณสองเมทริกซ์806
57ตรวจสอบว่ารายการที่เชื่อมโยงคือ palindrome หรือไม่800
58จำนวนสามเท่าที่มีผลรวมน้อยกว่ามูลค่าที่ระบุ796
59หมุนรายการที่เชื่อมโยง796
60ซื้อหุ้นขายเพื่อเพิ่มผลกำไร795
61การเชื่อมต่อของสองสาย766
62ชักเย่อ764
63พิมพ์รายการที่ซ้ำกันทั้งหมดในสตริงอินพุต759
64นับจำนวนสตริงย่อยด้วย K อักขระที่แตกต่างกัน758
65ค้นหาองค์ประกอบที่ยิ่งใหญ่และเล็กที่สุดที่ใกล้ที่สุด750
66ค้นหา Pythagorean Triplets จาก Array741
67ปัญหาคนดัง741
68สตริงย้อนกลับโดยไม่มีตัวแปรชั่วคราว735
69ลบ 'b' และ 'ac' ออกจากสตริงที่กำหนด734
70ค้นหาองค์ประกอบทั่วไปทั้งหมดในอาร์เรย์เรียงลำดับสามตัวที่กำหนด731
71ลบรายการที่ซ้ำกันทั้งหมดในรายการที่เชื่อมโยงที่ไม่ได้เรียงลำดับ713
72ค้นหาแถวที่มีจำนวนสูงสุด 1712
73ค้นหา Peak Element จาก Array704
74ค้นหา subarray ที่มีผลรวมเท่ากับจำนวน X ที่กำหนด697
75ลบอักขระขั้นต่ำเพื่อให้สองสตริงกลายเป็นแอนนาแกรม694
76ค้นหาหมายเลขที่ขาดน้อยที่สุดในอาร์เรย์ที่เรียงลำดับ691
77การเพิ่มสองเมทริกซ์690
78ปริศนาอาร์เรย์ผลิตภัณฑ์689
79เรียงลำดับการแทรก688
80สร้างสตริงไบนารีทั้งหมดโดยไม่ต้องต่อเนื่อง 1679
81ใช้สอง Stacks ในอาร์เรย์679
82ผลรวมสูงสุดขององค์ประกอบที่ไม่ต่อเนื่องกัน672
83Subarray ผลิตภัณฑ์สูงสุด II660
84อันดับพจนานุกรมของสตริง658
85การคูณก่อนหน้าและถัดไป651
86ตรวจสอบว่าเมทริกซ์ที่กำหนดสองรายการเหมือนกันหรือไม่650
87การลบเมทริกซ์สองตัว639
88ผสาน K เรียงลำดับอาร์เรย์และพิมพ์เอาต์พุตที่เรียงลำดับ636
89ย้ายศูนย์ทั้งหมดไปที่จุดสิ้นสุดของอาร์เรย์ที่กำหนด634
90อัลกอริทึมออนไลน์สำหรับการตรวจสอบ Palindrome ในสตรีม627
91สร้างจำนวนขั้นต่ำจากลำดับที่กำหนดของ D และฉัน626
92แบ่งสตริงเป็น N ส่วนเท่า ๆ กัน626
93ตรวจสอบว่าสองสายเป็นแอนนาแกรมของกันและกันหรือไม่619
94ลบตัวเลขที่เกิดซ้ำในหมายเลขที่กำหนด618
95ผลรวม Subarray Circular สูงสุด616
96จัดเรียงสแต็กโดยใช้สแต็กชั่วคราว612
97จัดเรียงรายการที่เชื่อมโยงซึ่งเรียงลำดับสลับจากน้อยไปมากและจากมากไปหาน้อย611
98ค้นหาองค์ประกอบขั้นต่ำในอาร์เรย์ที่เรียงและหมุน609
99ย้ายองค์ประกอบสุดท้ายของรายการที่เชื่อมโยงไปที่ตำแหน่งแรก605
100Subarray และผลที่ตามมา603
101ทัวร์แบบวงกลมครั้งแรกเพื่อเยี่ยมชมตู้เติมน้ำมันทั้งหมด603
102Subarray ที่ใหญ่ที่สุดที่มีจำนวนเท่ากับ 0 และ 1600
103การแบนรายการที่เชื่อมโยง598
104เปรียบเทียบสองสตริง (รายการที่เชื่อมโยง)597
105องค์ประกอบสูงสุดในอาร์เรย์ซึ่งเพิ่มขึ้นแล้วลดลง593
106Palindrome Permutations ของสตริง587
107องค์ประกอบปรากฏมากกว่า N / K เท่าใน Array584
108Palindromes ในช่วงที่กำหนด581
109องค์ประกอบเสียงข้างมาก581
110เรียกใช้การเข้ารหัสความยาว577
111พิมพ์การเรียงสับเปลี่ยนทั้งหมดด้วยการทำซ้ำ575
112การตรวจสอบ Pangram574
113การแทรกขั้นต่ำเพื่อสร้างพาลินโดรมที่สั้นที่สุด573
114รวมรายการที่เชื่อมโยงเข้ากับรายการอื่นที่ตำแหน่งอื่น569
115อักขระขั้นต่ำที่จะเพิ่มที่ด้านหน้าเพื่อสร้าง String Palindrome569
116ลบรายการที่ซ้ำกันทั้งหมดในรายการที่เชื่อมโยงที่เรียงลำดับ567
117อักขระที่ซ้ำกันมากที่สุดในสตริง566
118จัดเรียงรายการที่เชื่อมโยงใหม่ในสถานที่564
119จำนวนขั้นต่ำของ Merge Operations เพื่อสร้าง Array Palindrome564
120หมุนสตริงเพื่อรับสตริงขั้นต่ำตามศัพท์560
121ซ้ำตามมาของความยาวสองหรือมากกว่า558
122พิมพ์แอนนาแกรมทั้งหมดเข้าด้วยกันตามลำดับคำ556
123เรียงลำดับอาร์เรย์ใหม่ตามดัชนีที่กำหนด555
124ปัญหาการเรียงลำดับแพนเค้ก545
125โซลูชัน Sum Leetcode สองรายการ542
126ผสานช่วงเวลาที่ทับซ้อนกัน II540
127โซลูชัน 3Sum Leetcode539
128โคลนรายการที่เชื่อมโยงด้วยตัวชี้ถัดไปและแบบสุ่ม538
129การเปลี่ยนเมทริกซ์530
130ขนาดของ Subarray ที่มีผลรวมสูงสุด529
131ลบพื้นที่พิเศษออกจากสตริง525
132การลบ Spaces ออกจากสตริงโดยใช้ stringstream525
133ลบรายการที่ซ้ำกันออกจากสตริง524
134ผลรวมสูงสุดที่เพิ่มขึ้นตามมา522
135Palindrome ที่เล็กที่สุดหลังการเปลี่ยน522
136ตรวจสอบว่าสตริงที่กำหนดเป็นการหมุนของพาลินโดรมหรือไม่521
137ปัญหาเกี่ยวกับพาร์ติชัน518
138Palindrome ที่ยาวที่สุดสามารถสร้างขึ้นได้โดยการลบหรือจัดเรียงอักขระใหม่518
139ตรวจสอบว่าสตริงห่างกัน K หรือไม่509
140สร้างสตริงไบนารีทั้งหมดจากรูปแบบที่กำหนด506
141แทรกโหนดในรายการที่เชื่อมโยงที่เรียงลำดับ504
142หาศูนย์ที่จะพลิกเพื่อให้จำนวนของการต่อเนื่อง 1 ถูกขยายใหญ่สุด504
143ลบรายการล่าสุด504
144ความยาวของสตริงย่อยที่ยาวที่สุดที่ถูกต้อง501
145ตรวจสอบว่าสตริงที่กำหนดสองสายเป็นไอโซมอร์ฟิกซึ่งกันและกันหรือไม่496
146ความแตกต่างสูงสุดระหว่างสององค์ประกอบเช่นองค์ประกอบที่ใหญ่กว่าเกิดขึ้นหลังจากเล็กลง490
147โปรแกรมสลับอักขระทั้งหมดในสตริง487
148สตริงที่ระบุเป็นการแทรกระหว่างสตริงอื่น ๆ อีกสองสตริงหรือไม่486
149นับขั้นตอนขั้นต่ำเพื่อรับ Array ที่กำหนด483
150จำนวนองค์ประกอบที่เล็กกว่าทางด้านขวา481
151รวมการจัดเรียงที่ดีกว่าการจัดเรียงอย่างรวดเร็วสำหรับรายการที่เชื่อมโยง480
152ค้นหาคู่กับความแตกต่างที่ได้รับ478
153ตรวจสอบความยาวของสตริงเท่ากับตัวเลขที่ต่อท้าย478
154ตรวจสอบว่าแถวทั้งหมดของเมทริกซ์เป็นแบบวงกลมของกันและกันหรือไม่473
155ค้นหาโหนดที่ n ของรายการที่เชื่อมโยงจากท้าย473
156คำนำหน้าทั่วไปที่ยาวที่สุดโดยใช้ Divide and Conquer471
157ค้นหาจุดคงที่ในอาร์เรย์ที่กำหนด467
158จัดเรียง 0s 1s และ 2s ใน Array466
159พิมพ์ interleavings ทั้งหมดของสองสตริงที่กำหนด462
160กลับคำในสตริงที่กำหนด459
161ค้นหา Subarray ของความยาวที่กำหนดด้วยค่าเฉลี่ยน้อยที่สุด458
162เปรียบเทียบตัวเลขสองเวอร์ชัน457
163ค่ามัธยฐานของสอง Sorted Arrays LeetCode Solution455
164แยกรายการที่เชื่อมโยงโดยใช้โหนดอื่น454
165พิมพ์ย้อนกลับของสตริง (การเรียกซ้ำ)454
166รวมรายการที่เชื่อมโยงที่เรียงลำดับสองรายการเพื่อให้รายการที่ผสานอยู่ในลำดับย้อนกลับ454
167เรียงลำดับอาร์เรย์ใหม่โดยใช้ดัชนีที่กำหนด454
168พิมพ์สตริงความยาวคี่ในรูปแบบ 'X'444
169ค้นหา K Length Subarray ของค่าเฉลี่ยสูงสุด440
170ค้นหาองค์ประกอบโดยใช้การค้นหาแบบไบนารีในอาร์เรย์ที่เรียงลำดับ438
171Swap Kth Node จากจุดเริ่มต้นด้วย Kth Node จาก End437
172พิมพ์พาร์ติชัน Palindromic ทั้งหมดของสตริง432
173ค้นหารายการที่ซ้ำกันในอาร์เรย์ด้วยวิธีที่มีประสิทธิภาพสูงสุด431
174พิมพ์พาร์ติชัน palindromic ทั้งหมด423
175ปัญหา Superstring ที่สั้นที่สุด419
176ความยาวสูงสุดของคู่โซ่419
177แบนรายการที่เชื่อมโยงหลายระดับ418
178ตรวจสอบว่าสตริงตามลำดับของอักขระตามรูปแบบหรือไม่415
179การเรียงลำดับ K เรียงอาร์เรย์412
180จัดเรียงสตริงตามสตริงอื่น409
181ช่วงที่ยาวที่สุดที่มีผลรวมเท่ากันในสองอาร์เรย์ไบนารี II403
182ย้อนกลับรายการที่เชื่อมโยงในกลุ่ม401
183ค้นหาลำดับที่ตามมาของขนาด 3400
184โปรแกรมเพิ่มเลขฐานสองสองหลัก396
185พิมพ์ประโยคทั้งหมดซ้ำ ๆ ที่สามารถสร้างขึ้นจากรายการคำศัพท์394
186ค้นหาตัวเลขสองตัวที่มีโอกาสคี่ในอาร์เรย์ที่ไม่เรียงลำดับ391
187คำนำหน้าทั่วไปที่ยาวที่สุดโดยใช้ Binary Search II388
188ซีซาร์ไซเฟอร์385
189ย้อนกลับรายการที่เชื่อมโยงแบบเดี่ยว (ซ้ำ / ไม่เกิดซ้ำ)385
190ตรวจสอบว่า String สามารถว่างเปล่าได้หรือไม่โดยการลบ Substring ที่กำหนดซ้ำ ๆ383
191อักขระที่ไม่ซ้ำ Kth383
192การเรียงลำดับแพนเค้ก379
193จัดเรียงรายการที่เชื่อมโยงใหม่ใน Zig-Zag379
194หมุนภาพ 90 องศา379
195คำนำหน้าทั่วไปที่ยาวที่สุดโดยการจับคู่คำ373
196การเรียงลำดับของสตริงที่กำหนดโดยใช้ STL372
197สตริงย้อนกลับที่สมบูรณ์แบบ370
198การผสานสองอาร์เรย์ที่เรียงลำดับ367
199การเพิ่มผลที่ตามมาของความยาวที่สามด้วยผลิตภัณฑ์สูงสุด365
200จัดเรียงรายการที่เชื่อมโยงด้วย 0s, 1s และ 2s364
201ค้นหาจุดที่ฟังก์ชันที่เพิ่มขึ้นอย่างจำเจกลายเป็นบวกในครั้งแรก363
202ค้นหาอักขระที่ไม่ซ้ำตัวแรกในสตริง362
203ส่วนเสริม 1 และ 2 ของเลขฐานสอง362
204สร้างรายการที่เชื่อมโยงผลรวมสูงสุดจากรายการที่เชื่อมโยงที่เรียงลำดับสองรายการที่มีโหนดทั่วไปบางโหนด362
205แสดงรายการที่มีอักขระทั้งหมดของคำที่กำหนด355
206สี่องค์ประกอบที่รวมที่จะให้355
207ลบโหนดหลังจาก M354
208คำนำหน้าทั่วไปที่ยาวที่สุดโดยใช้อักขระโดยการจับคู่อักขระ351
209นับจำนวนครั้งที่เกิดขึ้นในอาร์เรย์ที่เรียงลำดับ350
210แยกสตริง345
211สตริง Palindrome (ตัวเลข)344
212อักขระขั้นต่ำที่จะถูกลบออกเพื่อสร้าง Binary String Alternate341
213การใช้งานซ้ำของ atoi ()339
214ตรวจสอบว่ารายการสตริงที่เชื่อมโยงเป็น Palindrome หรือไม่336
215พิมพ์องค์ประกอบที่แตกต่างทั้งหมดของอาร์เรย์335
216แม้แต่ Substring Count333
217แปลงสตริงที่เป็นการทำซ้ำของสตริงย่อยของความยาว K332
218วงเล็บที่ถูกต้อง โซลูชัน LeetCode332
219การเรียงลำดับอาร์เรย์ของสตริง332
220ย้อนกลับรายการที่เชื่อมโยงเดี่ยวแบบวนซ้ำ331
221ค้นหาหมายเลขซ้ำแรกในอาร์เรย์ที่กำหนด330
222อักขระที่เกิดขึ้นสูงสุดในสตริง330
223พิมพ์เส้นทางที่สั้นที่สุดเพื่อพิมพ์สตริงบนหน้าจอ326
224เราสามารถย้อนกลับรายการที่เชื่อมโยงในเวลาน้อยกว่า O (n) ได้หรือไม่?326
225ไบนารีทรีไปยังรายการที่เชื่อมโยงแบบทวีคูณ324
226ย้อนกลับสตริงโดยใช้ Stack323
227แปลง string1 เป็น string2 ในการแก้ไขครั้งเดียว323
228อักขระ N ในสตริงทศนิยมที่ต่อกัน322
229การจับคู่อักขระตัวแทน320
230จัดเรียงองค์ประกอบตามความถี่ II320
231โซลูชัน Subarray Leetcode สูงสุด320
232ตัวพิมพ์เล็กเป็นตัวพิมพ์ใหญ่317
233นับจำนวนคำ315
234ผสานสองอาร์เรย์ที่เรียงลำดับ314
235ค้นหาองค์ประกอบที่หายไปจากอาร์เรย์ที่ซ้ำกัน312
236แยกสี่สายที่แตกต่างกัน311
237ค้นหาตรงกลางของรายการที่เชื่อมโยง310
238ผลที่ตามมาที่ยาวที่สุดด้วยการเรียงสับเปลี่ยน306
239นับคู่ในระยะทางเดียวกันกับตัวอักษรภาษาอังกฤษ302
240การคูณเมทริกซ์เชนโดยใช้การเขียนโปรแกรมแบบไดนามิก299
241องค์ประกอบที่ยิ่งใหญ่ถัดไปในอาร์เรย์296
242การเรียงสับเปลี่ยน Palindrome293
243โรมันเป็นจำนวนเต็ม Leetcode โซลูชั่น290
244ค้นหาคู่ทั้งหมดด้วยความแตกต่างที่ได้รับ287
245ค้นหา Nth Node286
246การค้นหาโหนดในโครงสร้างการค้นหาแบบไบนารี285
247Triplet จากสามรายการที่เชื่อมโยงกับผลรวมที่กำหนด285
248สตริง (แทนจำนวนเต็ม) เป็นค่า282
249ลบทรี281
250โซลูชัน Leetcode ของ Word Search281
251ย้อนกลับสตริง280
252ย้อนกลับบิต279
253พิมพ์วิธีที่เป็นไปได้ทั้งหมดในการแบ่งสตริงในรูปแบบ Bracket278
254ต้นไม้ไบนารี276
255วิธีการใช้ k Stacks อย่างมีประสิทธิภาพใน Single Array?275
256ลบโหนดภายใต้เงื่อนไขที่กำหนด275
257เปลี่ยนเพศของสตริงที่กำหนด274
258จัดเรียงอาร์เรย์ของสตริง273
259องค์ประกอบแรกที่ไม่ซ้ำ272
260ห้องประชุม II โซลูชั่น LeetCode271
261นับคู่ด้วยผลรวมที่ได้รับ270
262จำนวนสตริงย่อยที่รวมซ้ำได้สูงสุด 9269
263นามสกุลทั่วไปที่ยาวที่สุด269
264ลบจุดกลางในรายการที่เชื่อมโยงของส่วนบรรทัด269
265รูปแบบสตริงย่อยซ้ำ268
266เมทริกซ์ Toeplitz267
267ย้ายองค์ประกอบเชิงลบทั้งหมดไปที่ด้านหนึ่งของอาร์เรย์266
268LeetCode Solution สตริงย่อย Palindromic ที่ยาวที่สุด264
269ลบช่องว่างออกจากสตริง263
270สลับอาร์เรย์ที่กำหนด263
271กองต่ำ262
272ไม่มีปัญหาราชินี261
273จำนวนเกาะ โซลูชั่น LeetCode257
274โปรแกรมลำดับนกกาเหว่า257
275อัลกอริทึม Dijkstra256
276ลดความแตกต่างสูงสุดระหว่างความสูง253
277โซลูชั่นปล้นบ้าน Leetcode253
278กองซ้อนสูงสุด253
279ค้นหาอักขระที่สองบ่อย252
280องค์ประกอบที่พบบ่อยที่สุดในอาร์เรย์251
281ค้นหาแทรกตำแหน่ง Leetcode โซลูชัน250
282โคลนรายการที่เชื่อมโยงด้วยตัวชี้ถัดไปและแบบสุ่ม (Hashing)249
283การประเมินนิพจน์247
284โซลูชัน Palindrome Leetcode ที่ถูกต้อง247
285จัดเรียงลิงก์ซึ่งเรียงตามค่าสัมบูรณ์247
286โซลูชัน Plus One Leetcode246
287KMP อัลกอริทึม246
288ชุดย่อย Leetcode245
289ซูโดกุ Solver245
290กลับคำในสตริง244
291หมายเลขฟีโบนักชี244
292จำนวน 1 บิต243
293รวมผลรวม Leetcode Solution243
294Min Stack Leetcode โซลูชัน243
295การประเมิน Postfix Expression242
296วิธีการลบรายการที่เชื่อมโยง242
297ค้นหาคำ240
298ตั้งค่า Matrix Zeroes236
299Backspace String เปรียบเทียบ236
300ผสานโซลูชัน Leetcode อาร์เรย์ที่เรียงลำดับ234
301คู่ของค่าเชิงลบที่เป็นบวกในอาร์เรย์233
302Sqrt (x) โซลูชัน Leetcode233
303Subarray ที่มี 0 ผลรวม232
304การกลับคิว232
305อัลกอริทึม Rabin Karp231
306ประกอบด้วย Duplicate II Leetcode Solution230
307องค์ประกอบทั่วไปในทุกแถวของเมทริกซ์ที่กำหนด230
308ผลิตภัณฑ์ของอาร์เรย์ยกเว้นตัวเอง229
309หอคอยแห่งฮานอย228
310ลบองค์ประกอบตรงกลางของสแต็ก228
311โซลูชันจำนวนเต็มเป็นโรมัน Leetcode227
312ผลรวมรวม227
313Leetcode สามเหลี่ยมปาสคาล226
314จุดตัดของโซลูชัน Leetcode สองอาร์เรย์ II226
315ย้อนกลับคำแต่ละคำ224
316การบีบอัดสตริง224
317การแลกเปลี่ยนขั้นต่ำที่จำเป็นเพื่อนำองค์ประกอบทั้งหมดที่น้อยกว่าหรือเท่ากับ k มารวมกัน222
318ค้นหาหมายเลข K สูงสุด (หรือบ่อยที่สุด) ในสตรีม222
319เทคนิคหน้าต่างบานเลื่อน222
320การประเมินนิพจน์ทางคณิตศาสตร์221
321สร้างไบนารีทรีจากการสั่งซื้อล่วงหน้าและการสั่งซื้อล่วงหน้า221
322นับ subarrays ด้วยจำนวน 1 และ 0 เท่ากัน221
323โซลูชัน Leetcode หมายเลขเดียว221
324จำนวนคู่ดัชนีที่มีองค์ประกอบเท่ากันในอาร์เรย์221
325อัลกอริทึม Bellman Ford220
326การนำ Deque ไปใช้งานโดยใช้ Doubly Linked List220
327มูลค่าขั้นต่ำที่จะได้รับการบวกทีละขั้นตอน Sum Leetcode Solution219
328ประกอบด้วย Duplicate219
329เพิ่ม Binary Leetcode Solution219
330จัดเรียงองค์ประกอบตามความถี่218
331คำที่ซ้ำกันมากที่สุดเป็นอันดับสองในลำดับ218
332Palindrome Linked List Leetcode โซลูชัน218
333แยกเลขคู่และเลขคี่218
334Pow (x, n) โซลูชัน Leetcode218
335Postfix เป็น Infix Conversion216
336อัลกอริทึมการเปลี่ยนหน้าในระบบปฏิบัติการ216
337นับเลขคี่ในโซลูชัน Leetcode ช่วงช่วงเวลา216
338ออกแบบสแต็กที่รองรับ getMin () ใน O (1) เวลาและ O (1) พื้นที่พิเศษ216
339ค้นหาผลรวมขององค์ประกอบที่ไม่ซ้ำกัน (แตกต่างกัน) องค์ประกอบในอาร์เรย์216
340การเรียงลำดับถัดไป215
341อัลกอริทึม Kruskal215
342จำนวนลูกโป่งสูงสุดของโซลูชัน Leetcode215
343โซลูชัน Leetcode จำนวนสูงสุดอันดับสาม214
344กลุ่มคำที่มีชุดอักขระเดียวกัน214
345ผลรวมขององค์ประกอบต่ำสุดและสูงสุดของ subarrays ขนาด k ทั้งหมด212
346K-th องค์ประกอบที่เล็กที่สุดในเมทริกซ์ที่เรียงลำดับ212
347Subarray ที่เล็กที่สุดพร้อม k ตัวเลขที่แตกต่างกัน212
348อัลกอริธึม Convex Hull212
349พีชคณิต Leetcode Solution211
350สตริงย่อยที่ยาวที่สุดโดยไม่ใช้อักขระซ้ำ LeetCode Solution211
351โซลูชัน Leetcode คำนำหน้าทั่วไปที่ยาวที่สุด210
352ค้นหา Town Judge Leetcode Solution210
353คำที่ใช้บ่อย K ยอดนิยม210
354การเรียงลำดับอาร์เรย์โดยใช้ Stacks209
355Subarray สูงสุด209
356ค้นหา Lucky Integer ใน Array Leetcode Solution209
357โซลูชัน Leetcode องค์ประกอบส่วนใหญ่209
358โซลูชัน LeetCode เมทริกซ์เกลียว208
359ค้นหาตัวเลขด้วยโซลูชัน Leetcode จำนวนคู่208
360สตริงการแย่งชิง208
361นับ subarrays ที่มีองค์ประกอบที่แตกต่างกันทั้งหมดเหมือนกับอาร์เรย์ดั้งเดิม207
362Swap Nodes ในคู่ Leetcode Solutions207
363องค์ประกอบแรกเกิดขึ้น k ครั้งในอาร์เรย์207
364การดำเนินการขั้นต่ำเพื่อทำให้องค์ประกอบทั้งหมดเท่ากันในอาร์เรย์206
365จำนวนคู่ที่ดีโซลูชัน Leetcode206
366คำนำหน้าในการแปลง Infix206
367ประเมินกอง206
368กำหนดอาร์เรย์ที่ไม่เรียงลำดับสองรายการให้ค้นหาคู่ทั้งหมดที่มีผลรวมเป็น x205
369หมายเลขพิเศษ205
370หมายเลขที่หายไป โซลูชัน Leetcode205
371ค้นหาใน Rotated Sorted Array Leetcode Solution205
372ผลรวมเส้นทางขั้นต่ำ205
373ผสานโซลูชัน Leetcode แบบเรียงลำดับสองรายการ205
374Count Primes Leetcode Solutions204
375ตรวจสอบว่าอาร์เรย์สองอาร์เรย์เท่ากันหรือไม่204
376เวลาที่ดีที่สุดในการซื้อและขาย Stock II Leetcode Solution204
377ย้อนกลับตัวเลขโดยใช้กอง203
378การเข้ารหัส Huffman203
379โซลูชัน Leetcode ความแตกต่างสัมบูรณ์ขั้นต่ำ203
380พลังของโซลูชัน Leetcode สองตัว202
381โซลูชัน Leetcode Triangle II ของ Pascal202
382การย้อนกลับองค์ประกอบ K แรกของคิว202
383องค์ประกอบที่พบบ่อย K ยอดนิยม202
384ค้นหาตัวเลขทั้งหมดที่หายไปในโซลูชัน Array Leetcode202
385จัดเรียงอาร์เรย์โดยการเพิ่มความถี่ Leetcode Solution202
386ขั้นต่ำในการบรรลุเป้าหมายโดยอัศวิน201
387โซลูชัน Leetcode เส้นทางที่ไม่ซ้ำใคร201
388ความแตกต่างสูงสุดที่เป็นไปได้ของสองชุดย่อยของอาร์เรย์201
389ค้นหารายการที่ซ้ำกันในอาร์เรย์ที่กำหนดเมื่อองค์ประกอบไม่ จำกัด เฉพาะช่วง201
390จัตุรัสสูงสุด201
391House Robber II โซลูชัน Leetcode201
392กลุ่มแอนนาแกรม201
393Fizz Buzz Leetcode200
394หมายเลขเดียว200
395โซลูชัน Matrix Diagonal Sum Leetcode200
396การเรียกใช้ผลรวมของโซลูชัน Leetcode อาร์เรย์ 1d199
397จำนวนตัวเลขที่เล็กกว่าโซลูชัน Leetcode จำนวนปัจจุบัน199
398ระยะห่างสูงสุดระหว่างการเกิดองค์ประกอบเดียวกันสองครั้งในอาร์เรย์199
399การเรียงลำดับโดยใช้ฟังก์ชันแฮชเล็กน้อย199
400ค้นหาขั้นต่ำในอาร์เรย์เรียงลำดับที่หมุน199
401Leetcode เรียงลำดับ198
402จัดเรียงจำนวนเต็มตามจำนวน 1 บิต Leetcode Solution198
403Range Sum Query 2D – โซลูชัน Leetcode ที่ไม่เปลี่ยนรูป197
404เงินเดือนเฉลี่ยไม่รวมโซลูชัน Leetcode เงินเดือนขั้นต่ำและสูงสุด197
405วิธีการติดตั้ง Stack โดยใช้ Priority Queue หรือ Heap197
406Coin Change 2 Leetcode โซลูชั่น197
407แฮปปี้ นัมเบอร์ ลีทโค้ด โซลูชั่น197
408ค้นหาหมายเลข Palindrome ที่ใกล้ที่สุด197
409เส้นทางที่ไม่ซ้ำใคร197
410นิพจน์มีวงเล็บสำรองหรือไม่196
411โซลูชัน Leetcode แบบต่อเนื่องสูงสุด196
412ความแตกต่างระหว่างความถี่สูงสุดและความถี่ต่ำสุดในอาร์เรย์195
413แปลงสตริงเป็น Int195
414โซลูชัน LeetCode อาร์เรย์โมโนโทนิก195
415การแปลงซิกแซก195
416ถอดรหัสสตริง195
417ลบรายการที่ซ้ำกันออกจาก Sorted Array Leetcode Solution195
418ค้นหาผู้ชนะใน Tic Tac Toe Game Leetcode Solution195
419ความยาวของ subarray ที่ใหญ่ที่สุดที่มีองค์ประกอบที่อยู่ติดกัน195
420ค้นหาจำนวนพนักงานภายใต้พนักงานทุกคน195
421ผลรวม Subarray เท่ากับ k195
422หมายเลขฟีโบนักชี โซลูชัน LeetCode194
423ค้นหาสามอันดับแรกที่ซ้ำกันในอาร์เรย์194
424จำนวนเต็มย้อนกลับ194
425ตรวจสอบว่าอาร์เรย์ประกอบด้วยจำนวนเต็มต่อเนื่องที่อนุญาตให้ทำซ้ำหรือไม่194
426Subarray Sum เท่ากับ K LeetCode Solution194
427องค์ประกอบที่เล็กที่สุดซ้ำ K ครั้ง194
428เวลาที่ดีที่สุดในการซื้อและขาย Stock III Leetcode Solution194
429ใช้ Stack และ Queue โดยใช้ Deque193
430ค้นหาหมายเลขที่ซ้ำกัน193
431แบบสอบถามสตริงย่อย Palindrome193
432ปัญหาผลรวมย่อย193
433ค้นหาค่ามัธยฐานจากสตรีมข้อมูล193
434ความสามารถในการจัดส่งพัสดุภายใน D Days Leetcode Solution193
435ลบผลิตภัณฑ์และผลรวมของตัวเลขของ Integer Leetcode Solution193
436Reverse Vowels ของ String Leetcode Solution193
437ตรวจสอบว่า N และโซลูชัน Leetcode มีอยู่สองชั้นหรือไม่192
438ย้อนกลับคำในสตริง III LeetCode Solution192
439ย้อนกลับกองโดยใช้การเรียกซ้ำ192
440ลบโหนดจากรายการที่เชื่อมโยงโดยไม่มีตัวชี้หัว192
441การเรียงสับเปลี่ยนกรณีจดหมาย192
442พิมพ์องค์ประกอบที่แตกต่างทั้งหมดของอาร์เรย์จำนวนเต็มที่ระบุ191
443สร้างสตริงที่มีอักขระที่มีโซลูชัน Leetcode จำนวนคี่191
444สลับโซลูชัน Array Leetcode191
445การใช้งานแคช LRU191
446หมายเลขคาตาลันที่ N191
447ความลึกสูงสุดของโซลูชัน Leetcode แบบไบนารีทรี191
448จัดเรียงสแต็กโดยใช้การเรียกซ้ำ191
449ลำดับความสำคัญโดยใช้รายการที่เชื่อมโยงเดี่ยว190
450Subarrays ที่มีองค์ประกอบที่แตกต่างกัน190
451ค้นหาองค์ประกอบที่ซ้ำกัน190
452ดักจับน้ำฝน Leetcode Solution190
453อัลกอริทึมของ Prim190
454กราฟ Bipartite190
455ความถี่สะสมของการนับของแต่ละองค์ประกอบในอาร์เรย์ที่ไม่เรียงลำดับ190
456นับสตริงย่อยด้วยจำนวน 0s, 1s และ 2s ที่เท่ากัน189
457ค้นหาอักขระทั่วไป Leetcode Solution189
458ผลรวมเป้าหมาย189
459ย้อนกลับสตริง189
460การเรียงลำดับคิวโดยไม่ต้องเว้นวรรค189
461องค์ประกอบที่ใหญ่ที่สุด Kth ใน Array Leetcode Solutions189
462หมายเลขคอลัมน์ของแผ่นงาน Excel Leetcode Solution189
463ค้นหาคู่ทั้งหมด (a, b) ในอาร์เรย์เพื่อให้ a% b = k188
464ค้นหาองค์ประกอบที่เกิดซ้ำครั้งแรกในอาร์เรย์ของจำนวนเต็ม188
465จำนวนเต็มเป็นคำภาษาอังกฤษ188
466หอคอยซ้ำแห่งฮานอย188
467ลำดับต่อมาที่ยาวที่สุด188
468ค้นหาความแตกต่าง Leetcode Solution188
469พิมพ์ subarrays ทั้งหมดด้วยผลรวม 0188
470ผลรวมของช่วง Subarray Leetcode Solution188
471แถวที่อ่อนแอที่สุด K ในโซลูชัน Matrix Leetcode187
472การต่อกันของ Array LeetCode Solution187
473Word Ladder โซลูชัน LeetCode187
474โซลูชัน Leetcode ต้นไม้ไบนารีที่สมดุล187
475ขั้นต่ำการย้ายไปยัง Equal Array Elements Leetcode Solution187
476ค้นหาองค์ประกอบที่มีอยู่ในอาร์เรย์แรกไม่ใช่ในวินาที187
477ค้นหาตำแหน่งแรกและตำแหน่งสุดท้ายขององค์ประกอบในเรียงลำดับอาร์เรย์ Leetcode Solution187
478เด็ก ๆ ที่มี Candies Leetcode Solution จำนวนมากที่สุด187
479Fizz Buzz187
480ผสานสองรายการที่เชื่อมโยงที่เรียงลำดับ187
481นับคู่จากรายการที่เชื่อมโยงสองรายการซึ่งผลรวมเท่ากับค่าที่กำหนด186
482อัลกอริทึม Floyd Warshall186
483จำนวนขั้นตอนในการลดจำนวนเป็น Zero Leetcode Solution186
484Kth องค์ประกอบที่ใหญ่ที่สุดในโซลูชัน Leetcode แบบสตรีม185
485ผสานช่วงเวลาที่ทับซ้อนกัน185
486ต่อไป Greater Element I Leetcode Solution185
487การจัดข้อความให้เหมาะสม โซลูชัน LeetCode185
488แก้ไขระยะทาง184
489ย้อนกลับรายการที่เชื่อมโยง184
490นับและพูด184
491ซิกแซกการแปลง LeetCode โซลูชั่น184
492คำนำหน้าทั่วไปที่ยาวที่สุดโดยใช้ Trie184
493โซลูชัน Leetcode คูณสตริง184
494ออกแบบระบบจอดรถ Leetcode Solution184
495นับและพูด Leetcode Solution183
496ปัญหาปุ่มกดตัวเลขบนมือถือ183
497ปัญหาช่วงเวลาของสต็อก183
498ระดับของอาร์เรย์183
499ดัชนีสูงสุดในอาร์เรย์ภูเขา183
500พื้นที่สูงสุดของเกาะ183
501คำนำหน้าในการแปลง Postfix183
502ลบจำนวนองค์ประกอบขั้นต่ำที่ไม่มีองค์ประกอบทั่วไปอยู่ในทั้งสองอาร์เรย์183
503โซลูชัน Leetcode ที่สำคัญช้าที่สุด183
504ย้ายศูนย์ LeetCode Solution183
505น้ำท่วมเติม LeetCode183
506ความยาวของ Last Word Leetcode Solution183
507ค้นหาองค์ประกอบที่แตกต่างกันทั่วไปสำหรับทุกแถวของเมทริกซ์182
508โซลูชัน Leetcode แบบสุ่ม182
509จุดตัดของสองอาร์เรย์182
510องค์ประกอบความถี่ที่ยิ่งใหญ่ถัดไป182
511อัลกอริทึม MiniMax182
512ใช้สแต็กโดยใช้คิวเดียว182
513น้ำหนักหินสุดท้าย181
514มุมมองด้านบนของ Binary Tree181
515สตริงย่อยที่มีการต่อคำทั้งหมด181
516กระโดดเกม โซลูชัน Leetcode181
517ลำดับความสำคัญใน C ++181
518ค้นหา subarray ด้วยผลรวมที่กำหนด (จัดการกับ Negative Numbers)181
519Palindrome ที่สั้นที่สุด181
520สตริงวงเล็บที่ถูกต้อง181
521แปลงอาร์เรย์เป็นแบบซิกแซก181
522ค้นหา N จำนวนเต็มที่ไม่ซ้ำกันรวมเป็น Zero Leetcode Solution180
523Postfix เป็น Prefix Conversion180
524subarray ที่ยาวที่สุดที่ไม่มีองค์ประกอบที่แตกต่างกันมากกว่า K180
525การเรียงลำดับแบบวนซ้ำของทรีไบนารี179
526ค้นหาองค์ประกอบการทำซ้ำหลายรายการในอาร์เรย์แบบอ่านอย่างเดียว179
527โซลูชัน Leetcode เรียงลำดับอาร์เรย์179
528จับคู่กับผลิตภัณฑ์ที่กำหนด179
529Koko กินกล้วย Leetcode Solution179
530ค้นหาดัชนีของวงเล็บปิดสำหรับวงเล็บเปิดที่กำหนดในนิพจน์179
531Leetcode อาร์เรย์ที่ต่อเนื่องกัน179
532Recursion179
533ลบโหนดในรายการที่เชื่อมโยง Leetcode Solution178
534ตรวจสอบว่าอาร์เรย์ที่ระบุมีองค์ประกอบที่ซ้ำกันภายในระยะ k จากกันหรือไม่178
535คำนำหน้าทั่วไปที่ยาวที่สุดโดยใช้การเรียงลำดับ178
536ค้นหาสี่องค์ประกอบที่รวมเป็นค่าที่กำหนด (Hashmap)178
537Excel Sheet ชื่อคอลัมน์ Leetcode โซลูชัน178
538Subarray ที่เล็กที่สุดเมื่อเกิดองค์ประกอบที่พบบ่อยที่สุดทั้งหมด178
539ภาชนะที่มีน้ำมากที่สุด178
540โซลูชัน Leetcode หมายเลข N-th Tribonacci178
541นับจำนวนแฝดที่มีผลิตภัณฑ์เท่ากับจำนวนที่กำหนด178
542ใช้ Stack โดยใช้ Queues178
543แปลง BST ปกติเป็น BST สมดุล177
544ค้นหาองค์ประกอบที่ขาดหายไปของช่วง177
545โซลูชัน Leetcode ของ Isomorphic Strings177
546จำนวนเต็มลบแรกในทุกหน้าต่างขนาด k177
547เวลาที่ดีที่สุดในการซื้อและขายหุ้น177
548เป็นโซลูชัน Leetcode ที่ตามมา177
549โซลูชันอัญมณีและหิน Leetcode177
550การดำเนินการขั้นต่ำในการแปลง X เป็น Y177
551กำหนดคุกกี้ Leetcode Solution176
552ลบองค์ประกอบรายการที่เชื่อมโยง Leetcode โซลูชัน176
553โซลูชัน Leetcode สามเหลี่ยมปริมณฑลที่ใหญ่ที่สุด176
554การใช้งาน Deque โดยใช้อาร์เรย์แบบวงกลม176
555ผลรวมด้านซ้ายออกจาก Leetcode Solutions176
556องค์ประกอบที่แตกต่างของ K-th ในอาร์เรย์176
557วงจรรายการที่เชื่อมโยง II โซลูชัน LeetCode175
558สลับอาร์เรย์175
559โซลูชัน Leetcode ของ Island Perimeter175
560ค้นหาคำที่สามารถสร้างขึ้นโดยอักขระ Leetcode Solution175
561การกลับวงเล็บขั้นต่ำ175
56201 โซลูชัน Matrix LeetCode175
563ตรวจสอบวงเล็บสมดุลในนิพจน์175
564Anagrams ที่ถูกต้อง175
565สร้างอาร์เรย์จากโซลูชันการเรียงสับเปลี่ยน Leetcode175
566Sudoku ที่ถูกต้อง175
567Subarray ที่ต่อเนื่องกันที่ใหญ่ที่สุด174
568สี่เหลี่ยมผืนผ้าผลรวมสูงสุดในเมทริกซ์ 2 มิติ174
569จัดเรียงตัวเลขที่กำหนดให้เป็นตัวเลขที่ใหญ่ที่สุด174
570แปลงอาร์เรย์ที่เรียงลำดับเป็นโซลูชัน Leetcode ต้นไม้ค้นหาแบบไบนารี174
571สรุปช่วง Leetcode โซลูชัน174
572เปลี่ยนอาร์เรย์เป็นการเรียงลำดับของตัวเลขจาก 1 เป็น N174
573การเกิดกลุ่มขององค์ประกอบอาร์เรย์หลายครั้งเรียงลำดับตามการเกิดครั้งแรก174
574ชุดค่าผสม Leetcode174
575แจกจ่ายขนมให้กับผู้คน Leetcode Solution174
576วิธีถอดรหัส174
577จำนวนเต็มเป็นโรมัน174
578ระยะการขัดขวาง173
579หมุนรายการ Leetcode โซลูชัน173
580การดำเนินการลบขั้นต่ำเพื่อทำให้องค์ประกอบทั้งหมดของอาร์เรย์เหมือนกัน173
581ค้นหาค่าจำนวนเต็มบวกที่เล็กที่สุดที่ไม่สามารถแสดงเป็นผลรวมของชุดย่อยใด ๆ ของอาร์เรย์ที่กำหนด173
582ปัญหาเหมืองทอง173
583แทรก Interval Leetcode Solution173
584ต้นไม้ค้นหาไบนารีที่ไม่ซ้ำใคร173
585LRU Cache LeetCode Solution173
586นับลำดับต่อมาทั้งหมดที่มีผลิตภัณฑ์น้อยกว่า K173
587นับจำนวนโหนดในระดับที่กำหนดในแผนภูมิโดยใช้ BFS173
588ระยะห่างระหว่างบัสหยุด Leetcode Solution172
589จำนวนขั้นต่ำขององค์ประกอบที่แตกต่างกันหลังจากลบรายการ m172
5903Sum โซลูชั่น LeetCode ที่ใกล้ที่สุด172
591อัศวินขั้นต่ำย้ายโซลูชัน LeetCode172
592ระยะทางสูงสุดในอาร์เรย์172
593ผลรวมเส้นทางสูงสุดในรูปสามเหลี่ยม172
594ดักน้ำฝน LeetCode Solution172
595ปัญหากระเป๋าเป้172
596จำนวนช็อคโกแลตสูงสุดที่จะแจกจ่ายในหมู่นักเรียน k เท่า ๆ กัน172
597หมุนภาพ โซลูชัน LeetCode171
598เส้นทางที่สั้นที่สุดในตารางที่มีการขจัดอุปสรรค LeetCode Solution171
599จัดเรียงสตริงไบนารีใหม่เป็นรายการ x และ y สำรอง171
600เกมหิน LeetCode170
601โซลูชัน LeetCode ต้นไม้เดียวกัน170
602การเรียงสับเปลี่ยนในสตริง Leetcode Solution170
603ตะแกรงของ Eratosthenes170
604K ช่องว่าง LeetCode170
605จำนวนขั้นต่ำของชุดย่อยที่มีองค์ประกอบที่แตกต่างกัน170
606แทนที่องค์ประกอบด้วยองค์ประกอบที่ยิ่งใหญ่ที่สุดบนโซลูชัน Leetcode ด้านขวา169
607จัดเรียงอาร์เรย์ตาม Parity LeetCode Solution169
608ค้นหาความแตกต่างขั้นต่ำระหว่างสององค์ประกอบใด ๆ169
609ลบการเกิดขึ้นทั้งหมดของสตริงย่อย LeetCode Solution169
610ระยะห่างของเซลล์ที่ใกล้ที่สุดโดยมี 1 ในเมทริกซ์ไบนารี168
611เวลาที่ดีที่สุดในการซื้อและขายหุ้น LeetCode Solution168
612จัดเรียงอักขระตามความถี่ โซลูชัน LeetCode168
613ค้นหาโซลูชัน LeetCode หมายเลขที่ซ้ำกัน168
614การพิมพ์วงเล็บในปัญหาการคูณเมทริกซ์168
615การติดตามองค์ประกอบสูงสุดในปัจจุบันในกอง168
616จำนวนต่อเนื่องสูงสุดที่มีอยู่ในอาร์เรย์168
617การจัดรูปแบบคีย์ใบอนุญาตโซลูชัน Leetcode168
618การประยุกต์ใช้การค้นหาแรกกว้างและการค้นหาครั้งแรกเชิงลึก168
619ปัญหาการตัดคำ168
620การทำงานของ XOR ในโซลูชัน Array Leetcode168
621รูปแบบคำ168
622โจรปล้นบ้าน168
623การกำหนดที่อยู่ IP โซลูชัน Leetcode168
624จะตรวจสอบได้อย่างไรว่าสองชุดที่กำหนดไม่ปะติดปะต่อกัน?168
625ปัญหาการเปลี่ยนเหรียญ167
626การแทรกขั้นต่ำเพื่อสร้าง palindrome ที่อนุญาตการเรียงสับเปลี่ยน167
627ค้นหาผลรวมของผลรวมอาร์เรย์ย่อยที่ไม่ซ้ำกันทั้งหมดสำหรับอาร์เรย์ที่กำหนด167
628อัลกอริทึมการทาสีรั้ว167
629ค้นหาว่านิพจน์มีวงเล็บซ้ำหรือไม่167
630ความลึกขั้นต่ำของโซลูชัน Leetcode แบบไบนารีทรี167
631ฐานที่เล็กที่สุด167
632แยก 0s และ 1s ใน Array167
633ความแตกต่างสูงสุดระหว่างดัชนีแรกและดัชนีสุดท้ายขององค์ประกอบในอาร์เรย์167
634กบกระโดด Leetcode โซลูชั่น167
635ผลรวมของโซลูชัน Leetcode Subarrays ความยาวคี่ทั้งหมด166
636แบบสอบถามสำหรับจำนวนองค์ประกอบอาร์เรย์ที่มีค่าในช่วงที่กำหนด166
637จำนวนขั้นต่ำในการสร้างโซลูชัน Anagram Leetcode สองสตริง166
638สตริงย่อยที่ยาวที่สุดที่มีอักขระ K Distinct มากที่สุด LeetCode Solution166
639ตรวจสอบว่าเป็นโซลูชัน Leetcode แบบเส้นตรงหรือไม่166
640ย้อนกลับสแต็กโดยไม่ต้องใช้พื้นที่เพิ่มเติมใน O (n)165
641จำนวนครั้งสูงสุดของโซลูชัน Leetcode ของสตริงย่อย165
642เวลาที่ดีที่สุดในการซื้อและขายหุ้นด้วย Cooldown Leetcode Solution165
643Binary Tree Zigzag Level Order Traversal โซลูชัน LeetCode165
644นับโหนดที่ดีในโซลูชัน Leetcode แบบไบนารีทรี165
645สตริง Isomorphic165
646ผสานสองต้นไม้ค้นหาแบบไบนารีที่สมดุล165
647สตริงย่อยที่ยาวที่สุดที่มีอักขระอย่างน้อย K ซ้ำ LeetCode Solution165
648ต้นทุนขั้นต่ำในการจ้างคนงาน K165
649จำนวนจังหวัด โซลูชั่น Leetcode164
650โซลูชัน LeetCode หมายเลข Strobogrammatic164
651ค้นหาผลรวมระดับสูงสุดใน Binary Tree164
652โซลูชัน LeetCode เวลาว่างของพนักงาน164
653กระดิกเรียง164
654ลบคำเดียวกันที่ต่อเนื่องกันในลำดับ164
655โซลูชัน Leetcode ที่ถูกต้องของ Palindrome II164
656วิธีการวนซ้ำเพื่อหาความสูงของไบนารีทรี164
657ความสมดุลของบัญชีที่เหมาะสมที่สุด โซลูชัน LeetCode164
658GCD ของตัวเลขสองตัว164
659Kth ไม่มีโซลูชัน Leetcode จำนวนบวกที่ขาดหายไป164
660การรวมตัวอักษรของหมายเลขโทรศัพท์164
661Palindrome ที่ถูกต้อง163
662ผลที่ตามมาเพิ่มขึ้นยาวนานที่สุด163
663ค้นหาคู่ที่มีผลรวมที่กำหนดเพื่อให้องค์ประกอบของคู่อยู่ในแถวที่ต่างกัน163
664จัดระเบียบสตริงใหม่163
665พลังของโซลูชัน Leetcode สี่ตัว163
666ค้นหาค่าระยะทางระหว่างสองอาร์เรย์ Leetcode Solution163
667เส้นทางที่มีมูลค่าขั้นต่ำสูงสุด โซลูชัน LeetCode163
668โซลูชัน Leetcode ของ Perfect Square ที่ถูกต้อง163
669ฉลากพาร์ติชั่น LeetCode Solution163
670ผลรวมสองชุดที่ไม่ทับซ้อนกัน163
671แก้ไขระยะทาง LeetCode Solution163
672จัดเรียงอาร์เรย์ใหม่ตามลำดับ - เล็กที่สุดใหญ่สุดอันดับ 2 เล็กสุดอันดับ 2162
673ลำดับการเรียงสับเปลี่ยน LeetCode Solution162
674พิมพ์หมายเลขฟีโบนักชีตามลำดับย้อนกลับ162
675ค่าเฉลี่ยเคลื่อนที่จาก Data Stream Leetcode Solution162
676จำนวนเหรียญสูงสุดที่คุณสามารถรับโซลูชัน Leetcode162
677ลดจาน LeetCode Solution162
678กู้คืนโครงสร้างการค้นหาแบบไบนารี162
679เพื่อลด Leetcode Solution ตัวพิมพ์เล็ก161
680สตริงเป็นจำนวนเต็ม (atoi) LeetCode Solution161
681ค้นหา d ที่ใหญ่ที่สุดใน Array เพื่อให้ a + b + c = d161
682แปลงอาร์เรย์เป็นรูปแบบย่อ161
683โซลูชัน Leetcode จำนวนที่น่าเกลียด161
684เส้นทางที่ยาวที่สุดในเมทริกซ์ LeetCode Solution161
685จัดเรียงอาร์เรย์โดยการเพิ่มความถี่ Leetcode Solution161
686พื้นฐานการเขียนโปรแกรมแบบไดนามิก161
687Inorder Successor ของโหนดใน Binary Tree161
688พลิกโซลูชัน LeetCode ของรูปภาพ161
689จะสร้าง Mergable Stack ได้อย่างไร?161
690BFS กับ DFS สำหรับ Binary Tree161
691สร้างตัวเลขขั้นต่ำจากลำดับที่กำหนด160
692ผลิตภัณฑ์สูงสุดของสององค์ประกอบในโซลูชัน Array Leetcode160
693โซลูชัน Leetcode องค์ประกอบส่วนใหญ่ II160
694ค้นหาว่าอาร์เรย์เป็นส่วนย่อยของอาร์เรย์อื่นหรือไม่160
695ย้อนกลับเฉพาะตัวอักษร LeetCode Solution160
696ค้นหาใบของ Binary Tree LeetCode Solution160
697กู้คืนที่อยู่ IP โซลูชัน Leetcode160
698ตรวจสอบว่าสามารถจัดเรียงคิวเป็นคิวอื่นโดยใช้สแต็กได้หรือไม่160
699ชุดย่อย Sum Leetcode160
700แฟกทอเรียลต่อท้าย Zeroes Leetcode Solution160
701ตรวจสอบว่าอาร์เรย์สองสตริงเป็นโซลูชัน Leetcode ที่เทียบเท่าหรือไม่160
702การเติมตัวชี้ทางขวาถัดไปในแต่ละโหนด160
703จำนวนลูกเต๋าทอยด้วยผลรวมเป้าหมาย โซลูชัน LeetCode160
704K ช่องว่าง160
705การสุ่มตัวอย่างอ่างเก็บน้ำ160
706พาร์ติชันอาร์เรย์ออกเป็นสามส่วนด้วยโซลูชัน Leetcode ที่เท่ากัน160
707การย้อนกลับคิวโดยใช้การเรียกซ้ำ160
708สร้าง BST จาก Preorder Traversal ที่กำหนด159
709Binary Tree ลำดับระดับซิกแซก Traversal159
710การเพิ่มโซลูชัน Leetcode สตริงที่ลดลง159
711ลบโหนด Nth จากส่วนท้ายของรายการที่เชื่อมโยงที่กำหนด159
712Add and Search Word - การออกแบบโครงสร้างข้อมูล LeetCode159
713โซลูชัน Leetcode เส้นทางที่ไม่ซ้ำ II159
714ลบวงเล็บไม่ถูกต้อง Leetcode Solution159
715ผสานสอง Binary Trees LeetCode Solution158
716ต้นทุนขั้นต่ำสำหรับตั๋ว โซลูชัน Leetcode158
717ดำเนินการเปลี่ยนสตริง Leetcode158
718ค้นหาผลคูณที่ใหญ่ที่สุดของ 3158
719หุ่นยนต์ทำความสะอาดห้อง Leetcode Solution158
720ค้นหาตัวหารที่เล็กที่สุดที่ได้รับ Threshold Leetcode Solution158
721ค้นหาคู่กับผลิตภัณฑ์ที่ดีที่สุดใน Array158
722Lucky Numbers ในโซลูชัน Matrix Leetcode158
723แปลงตัวเลขเป็นเลขฐานสิบหก Leetcode Solution158
724ตัวสลับหลอดไฟ โซลูชัน LeetCode158
725โซลูชัน Leetcode แถวแป้นพิมพ์157
726ค้นหาโหนดที่มีค่าต่ำสุดในโครงสร้างการค้นหาแบบไบนารี157
727ผลรวมของ f (a [i], a [j]) เหนือทุกคู่ในอาร์เรย์ของจำนวนเต็ม n157
728คลายการบีบอัดโซลูชัน Leetcode รายการที่เข้ารหัสความยาวรัน157
729มอร์ริส Traversal157
730อักขระที่ไม่ซ้ำตัวแรกในสตริง LeetCode Solution157
731ค่าสัมประสิทธิ์ทวินาม157
732บันทึกการเข้าเรียนของนักเรียน I Leetcode Solution156
733การจัดเรียงฟองโดยใช้สองกอง156
734โซลูชัน Leetcode ระยะทางที่ติดขัด156
735โซลูชัน LeetCode Array ที่ไม่ลดลง156
736อันดับ Transform ของ Array Leetcode Solution156
737ผลิตภัณฑ์สูงสุดของ LeetCode Solution สามตัวเลข156
738ผสาน K เรียงลำดับรายการที่เชื่อมโยง155
739ค้นหาค่ามัธยฐานจากสตรีมข้อมูล LeetCode Solution155
740จุดนัดพบที่ดีที่สุด โซลูชัน LeetCode155
741เส้นทแยงมุมของต้นไม้ไบนารี155
742พลิกโซลูชัน LeetCode Binary Tree155
743Binary Tree ค่าสูงสุดของเส้นทางรวม LeetCode Solution155
744องค์ประกอบที่จะเพิ่มเพื่อให้องค์ประกอบทั้งหมดของช่วงมีอยู่ในอาร์เรย์155
745โซลูชัน Leetcode จำนวนสูงสุด 69 หมายเลข155
746ค้นหาองค์ประกอบที่ใกล้เคียงที่สุด K155
747จัดเรียงรายการที่เชื่อมโยงเป็น BST ที่สมดุล155
748ระยะห่างขั้นต่ำระหว่าง BST Nodes Leetcode Solution155
749รูปแบบคำ โซลูชัน LeetCode155
750จำนวนเกาะ II โซลูชัน LeetCode154
751ความแตกต่างสูงสุดระหว่างองค์ประกอบที่เพิ่มขึ้น โซลูชัน LeetCode154
752ประเมินการย้อนกลับของสัญกรณ์โปแลนด์ LeetCode Solution154
753ค้นหาว่ามีเส้นทางอยู่ในกราฟ Leetcode Solution154
754โซลูชันการบีบอัดสตริง LeetCode154
755เวลาขั้นต่ำที่ต้องใช้ในการเน่าส้มทั้งหมด154
756Kth บรรพบุรุษของโหนดในไบนารีทรี154
757สร้างอาร์เรย์ที่เรียงลำดับที่เป็นไปได้ทั้งหมดจากองค์ประกอบทางเลือกของอาร์เรย์ที่จัดเรียงสองรายการที่กำหนด154
758ค้นหาอักขระที่ไม่ซ้ำกันในสตริง154
759แยกสตริงใน Balanced Strings Leetcode Solution154
760ปัญหาการปูกระเบื้อง154
761Stack Permutations (ตรวจสอบว่าอาร์เรย์เป็นการเรียงลำดับแบบสแต็กของอื่น ๆ หรือไม่)154
762ความลึกสูงสุดของ N-ary Tree Leetcode Solution154
763ค้นหาโซลูชัน Leetcode 2D Matrix II154
764งูและบันได LeetCode Solution154
765แนวทางตามคิวสำหรับอักขระที่ไม่ซ้ำตัวแรกในสตรีม154
766เมทริกซ์ย่อยรูปสี่เหลี่ยมผืนผ้าที่ใหญ่ที่สุดซึ่งมีผลรวมเป็น 0154
767ต้นไม้ที่มีความสูงต่ำสุด154
768ความยาวสูงสุดของสตริงที่ต่อกันด้วยอักขระที่ไม่ซ้ำ Leetcode Solution154
769อาร์เรย์พิเศษที่มีองค์ประกอบ X มากกว่าหรือเท่ากับ X Leetcode โซลูชัน154
770โซลูชัน Leetcode ต้นไม้สมมาตร154
771ค้นหารายการที่ซ้ำกันทั้งหมดใน Array LeetCode Solution154
772subarray ที่ใหญ่ที่สุดโดยมีจำนวน 0 และ 1 เท่ากัน154
773ตัวเลขที่มีความถี่เฉพาะมากกว่าหรือเท่ากับ k153
774ราคาสุดท้ายพร้อมส่วนลดพิเศษใน Shop Leetcode Solution153
775เกมกระโดด153
776การลบในทรีไบนารี153
777องค์ประกอบที่ขาดหายไป k-th ในลำดับที่เพิ่มขึ้นซึ่งไม่มีอยู่ในลำดับที่กำหนด153
778ช่วงที่ยาวที่สุดที่มีผลรวมเดียวกันในอาร์เรย์ไบนารีสองอาร์เรย์153
779โซลูชัน LeetCode ของรถแข่ง153
780นับสี่เท่าจากสี่อาร์เรย์ที่เรียงลำดับซึ่งผลรวมเท่ากับค่าที่กำหนด x153
781โซลูชั่น N-Queens LeetCode153
782สี่เหลี่ยมผืนผ้าที่ใหญ่ที่สุดในฮิสโตแกรม LeetCode Solution153
783ตรวจสอบว่า Array Pairs สามารถหารด้วย k LeetCode Solution ได้หรือไม่153
784ลดจำนวนคู่สูงสุดใน Array LeetCode Solution153
785เปลี่ยนกราฟ153
786ค้นหาในโซลูชัน Leetcode Tree Search แบบไบนารี153
787ต้นไม้ช่วงเวลา152
788ลบรายการที่ซ้ำกันออกจากรายการที่จัดเรียง II152
789ลบโหนดที่ N ออกจากจุดสิ้นสุดของรายการ Leetcode Solution152
790จำนวนขั้นต่ำของการกระโดดเพื่อไปให้ถึงจุดสิ้นสุด152
791โปรแกรมสำหรับปัญหา Bridge and Torch152
792ตรวจสอบว่าสองนิพจน์พร้อมวงเล็บเหมือนกันหรือไม่152
793ค้นหาความลึกสูงสุดของวงเล็บที่ซ้อนกันในสตริง152
794จัดเรียงอาร์เรย์ตามลำดับที่กำหนดโดยอาร์เรย์อื่น152
795เวลาขั้นต่ำในการเยี่ยมชมทุกจุด Leetcode Solution152
796สวอปขั้นต่ำเพื่อให้ลำดับเพิ่มขึ้น152
797กำไรสูงสุดในการจัดตารางงาน Leetcode Solution151
798จำนวน NGE ทางด้านขวา151
799โซลูชัน Leetcode โฟลเดอร์บันทึกของ Crawler151
800โซลูชันฐาน 7 Leetcode151
801พิมพ์ต้นไม้ไบนารีตามลำดับแนวตั้ง151
802โซลูชัน Space Optimized DP สำหรับปัญหากระเป๋าเป้ 0-1151
803ลบรายการที่ซ้ำกันออกจากรายการที่เรียงลำดับ LeetCode Solution151
804พาร์ทิชันไปยัง K Equal Sum Subsets Leetcode Solution151
805วงจรรายการที่เชื่อมโยง151
806Last Stone Weight II โซลูชัน LeetCode151
807การเปรียบเทียบสตริงที่มีสัญลักษณ์แทน151
808ลบวงเล็บออกจากสตริงพีชคณิตที่มีตัวดำเนินการ + และ -151
809กระโดดขั้นต่ำเพื่อไปถึงหน้าแรก โซลูชัน LeetCode151
810ตรวจสอบ Palindrome หลังจากแบบสอบถามการแทนที่อักขระทุกครั้ง150
811น้ำหนักรายการที่ซ้อนกัน Sum II โซลูชัน LeetCode150
812หนึ่งแก้ไขระยะทาง LeetCode โซลูชั่น150
813ตารางเรียน II - LeetCode150
814โซลูชันกำแพงอิฐ LeetCode150
815ทางออกที่ใกล้ที่สุดจากทางเข้าใน Maze LeetCode Solution150
816เรียงลำดับ Array ตาม Parity II Leetcode Solution150
817ตัวเลขทั้งหมดที่ไม่มีตัวเลขซ้ำในช่วง150
818ผลรวมซับเรย์ขนาดสูงสุดเท่ากับ k150
819ค้นหาแฝดทั้งหมดที่มีผลรวมเป็นศูนย์150
820โซลูชัน Leetcode ส่วนเติมเต็ม150
821หมายเลขที่ถูกต้อง150
822การสั่งซื้อล่วงหน้าแบบวนซ้ำ150
823เรียงลำดับข้อมูลใหม่ในไฟล์บันทึก LeetCode Solution150
824อันดับสัมพัทธ์ Leetcode Solution150
825รับสูงสุดในโซลูชัน Leetcode อาร์เรย์ที่สร้างขึ้น149
826ตรวจสอบว่า Binary Tree ที่ระบุนั้นสมบูรณ์หรือไม่149
827ค้นหา subarray ที่มีค่าเฉลี่ยน้อยที่สุด149
828นับรายการทั่วไปในทั้งสองรายการ แต่มีราคาต่างกัน149
829รายการพาร์ติชั่น Leetcode Solution149
830ผสานโซลูชัน LeetCode ที่เรียงลำดับแล้ว149
831คิวแบบวงกลม149
832วางดอกไม้ได้ LeetCode Solution149
833สแต็กตามอาร์เรย์ที่เติบโตได้149
834คำที่ใช้บ่อย K อันดับต้น ๆ โซลูชัน LeetCode149
835วงเล็บที่ถูกต้อง โซลูชัน Leetcode149
836แปลง BST เป็น Min Heap149
837ผลิตภัณฑ์ Subarray น้อยกว่า K LeetCode Solution149
838พจนานุกรมคนต่างด้าว โซลูชัน LeetCode149
839เส้นทางที่มีค่าเฉลี่ยสูงสุด149
840ลำดับของความยาวที่กำหนดโดยทุกองค์ประกอบมากกว่าหรือเท่ากับสองเท่าของก่อนหน้านี้148
841ค้นหาเฉพาะองค์ประกอบที่ทำซ้ำระหว่าง 1 ถึง N-1148
842นับองค์ประกอบที่แตกต่างในทุกหน้าต่างขนาด K148
843การเลื่อนระดับคำสั่งในรูปแบบ Spiral148
844ออกแบบ Stack ด้วยการทำงานที่เพิ่มขึ้น Leetcode Solution148
845ลำดับความสำคัญโดยใช้รายการที่เชื่อมโยงแบบทวีคูณ148
846Subarray ที่ยาวที่สุดมีจำนวน 1s มากกว่า Count of 0s148
847ทำให้สองอาร์เรย์เท่ากันโดยการย้อนกลับอาร์เรย์ย่อย Leetcode Solution148
848ค้นหาสูตรอาหารที่เป็นไปได้ทั้งหมดจากวัสดุที่มอบให้ LeetCode Solution148
849ลำดับต่อมาของขนาด K ด้วยโซลูชัน LeetCode จำนวนคู่ที่ใหญ่ที่สุด148
850สร้างจำนวนขั้นต่ำจากลำดับที่กำหนด148
851การจับคู่นิพจน์ทั่วไป148
852เรียงสี148
853ตรวจสอบว่าอาร์เรย์ที่กำหนดสามารถแสดงถึงการสั่งซื้อล่วงหน้าของโครงสร้างการค้นหาแบบไบนารีได้หรือไม่148
854โคลนกราฟ โซลูชัน LeetCode148
855แทรกลงในโซลูชัน Leetcode แบบต้นไม้ค้นหาแบบไบนารี147
856จำนวนก๊อกขั้นต่ำในการรดน้ำสวน LeetCode Solution147
857เซตย่อยที่มีผลรวมหารด้วยม147
858เดาหมายเลขโซลูชัน LeetCode ที่สูงขึ้นหรือต่ำลง147
859ค่าสัมประสิทธิ์การเปลี่ยนแปลง147
860ความลึกของการซ้อนสูงสุดของวงเล็บ Leetcode Solution147
861ปัญหาการจับคู่เพื่อน147
862นับจำนวนลบในโซลูชัน LeetCode Matrix ที่เรียงลำดับ147
863ให้อาร์เรย์ของคู่ค้นหาคู่สมมาตรทั้งหมดในนั้น147
864การค้นหาแบบไบนารีการค้นหาทรีและการแทรก147
865องค์ประกอบที่อยู่ติดกันที่แตกต่างกันในอาร์เรย์146
866จัดเรียงอาร์เรย์ใหม่เพื่อให้ arr [i] เท่ากับ i146
867ตำแหน่งที่สว่างที่สุดบนถนน LeetCode Solution146
868GCD ของช่วงดัชนีที่กำหนดในอาร์เรย์146
869การคูณเมทริกซ์ลูกโซ่146
870ยูเนี่ยนและจุดตัดของรายการที่เชื่อมโยงสองรายการ146
871ออกแบบประวัติเบราว์เซอร์ โซลูชัน LeetCode146
872รูปแบบสตริงย่อยซ้ำ LeetCode Solution146
873เส้นทางผลรวมขั้นต่ำในรูปสามเหลี่ยม146
874โซลูชัน Leetcode ของ Spiral Matrix II146
875ผลรวมของจำนวนที่น้อยกว่าและมากกว่าที่ใกล้ที่สุด146
876Tree Traversal (สั่งซื้อล่วงหน้า, Inorder & Postorder)146
877K'th องค์ประกอบที่ใหญ่ที่สุดใน BST เมื่อไม่อนุญาตให้ปรับเปลี่ยน BST146
878โซลูชัน Leetcode อุณหภูมิรายวัน145
879จัดเรียงอาร์เรย์เป็น BST ที่สมดุล145
880ตรวจสอบว่าองค์ประกอบสแต็กติดต่อกันเป็นคู่หรือไม่145
881จำนวนวันระหว่างสองวัน โซลูชัน LeetCode145
882Swaps ขั้นต่ำเพื่อสร้าง Strings Equal Leetcode Solution145
883การแบ่งอาร์เรย์สามวิธีรอบ ๆ ช่วงที่กำหนด145
884โซลูชัน LeetCode แนวขวางในแนวทแยง145
885Robot Bounded In Circle โซลูชัน LeetCode145
886เวลาที่ดีที่สุดในการซื้อและขายหุ้นพร้อมค่าธรรมเนียมการทำธุรกรรม Leetcode Solution145
887โซลูชัน Leetcode เมืองปลายทาง145
888วิธีที่น่าสนใจในการสร้างเลขฐานสองจาก 1 ถึง n145
889ค้นหาระยะห่างระหว่างสองโหนดของ Binary Tree145
890ค้นหาผลรวมสูงสุดที่เป็นไปได้ของสามกอง145
891ลบและรับ145
892ตรวจสอบว่า Array เป็นแบบเรียงซ้อนได้หรือไม่144
893จำนวนเต็มที่ไม่ซ้ำน้อยที่สุดหลังจากลบ K Leetcode Solution144
894น้ำมะนาวเปลี่ยน Leetcode Solution144
895โซลูชัน LeetCode การข้ามเส้นทแยงมุม144
896คะแนนสูงสุดหลังจากแยกโซลูชัน Leetcode แบบสตริง144
897นับวิธีขึ้นบันไดที่ n โดยใช้ขั้นตอนที่ 1, 2 หรือ 3144
898ผลรวมขั้นต่ำของการคูณของจำนวน n144
899LCS (ลำดับต่อมาที่ยาวที่สุด) ของสามสาย144
900แบบสอบถามผลรวมช่วงที่ไม่มีการอัปเดต144
901เดาตัวเลขสูงกว่าหรือต่ำกว่า II144
902จัดเรียงช่องว่างใหม่ระหว่าง Words Leetcode Solution143
903ผลรวมแนวตั้งในต้นไม้ไบนารีที่กำหนด143
904การแสดงออกที่สมดุลพร้อมการเปลี่ยน143
9054 ซัม143
906ตรวจสอบว่าอาร์เรย์ที่ระบุสามารถแสดงถึงการส่งผ่านของลำดับระดับของ Binary Search Tree หรือไม่143
907ตำแหน่งพิเศษในโซลูชัน Leetcode เมทริกซ์แบบไบนารี143
908ขวดน้ำ Leetcode Solution143
909องค์ประกอบที่ขาดหายไปในโซลูชัน LeetCode ที่เรียงลำดับ143
910โซลูชัน LeetCode ของ Spiral Matrix III143
911แบบสอบถาม LCM ช่วง143
912สร้าง Binary Tree ที่สมบูรณ์จากการเป็นตัวแทนรายการที่เชื่อมโยง143
913ตัดแต่งต้นไม้ค้นหาแบบไบนารี142
914ระบุและทำเครื่องหมายวงเล็บที่ไม่ตรงกันในนิพจน์142
915โซลูชัน Leetcode ระยะทางสั้นที่สุด142
916ข้อความค้นหาสำหรับ GCD ของอาร์เรย์ทั้งหมดยกเว้นองค์ประกอบในช่วงที่กำหนด142
917ตั้งค่าโซลูชัน Leetcode ของเมทริกซ์เป็นศูนย์142
918Palindrome Partitioning Leetcode Solution142
919สร้าง BST จาก Level Order Traversal ที่กำหนด142
920แทรกลบ GetRandom142
921โปรแกรมตรวจสอบว่าต้นไม้ไบนารีเป็น BST หรือไม่142
922จำนวนหมู่เกาะที่แตกต่าง โซลูชัน Leetcode142
923BFS สำหรับ Disconnected Graph142
924พจนานุกรมคนต่างด้าว142
925ที่เก็บคีย์-ค่าตามเวลา LeetCode Solution142
926ลบรายการที่ซ้ำกันออกจากรายการที่เรียงลำดับ II LeetCode Solution142
927ใส่ลงใน Postfix141
928จัดคิวโดยใช้ Stacks141
929Triplets ที่ไม่ซ้ำกันทั้งหมดที่รวมเป็นมูลค่าที่กำหนด141
930แบ่งอาร์เรย์ออกเป็นลำดับต่อเนื่องกัน141
931อาร์เรย์ความแตกต่าง | แบบสอบถามการอัปเดตช่วงใน O (1)141
932อาร์เรย์ไบนารีหลังจากการดำเนินการสลับช่วง M141
933ผลที่ตามมาของ Palindromic ที่ยาวที่สุด141
934เลขพจนานุกรม Leetcode Solution141
935สร้าง Rectangle Leetcode Solution141
936การส่งผ่านหลังการสั่งซื้อซ้ำโดยใช้สองกอง141
937จัดเรียง Array ใหม่เช่น arr [i]> = arr [j] ถ้าฉันเป็นเลขคู่และ arr [i] <= arr [j] ถ้าฉันเป็นเลขคี่และ j <i141
938แปลงรายการที่จัดเรียงเป็นโครงสร้างการค้นหาแบบไบนารี141
939ส่วนประกอบที่เชื่อมต่ออย่างแน่นหนา141
940รวบรวมคะแนนสูงสุดในตารางโดยใช้การข้ามสองครั้ง141
941นับ Subarrays ที่มีองค์ประกอบคู่และคี่เหมือนกัน140
942เมทริกซ์ย่อยรูปสี่เหลี่ยมผืนผ้าที่ใหญ่ที่สุดที่มีจำนวนเท่ากับ 1 และ 0140
943จุดตัดของสองรายการที่เชื่อมโยง LeetCode Solution140
944ค่าเฉลี่ยของระดับในต้นไม้ไบนารี140
945ผสาน Leetcode สองรายการที่เรียงลำดับ140
946ตรวจสอบว่าช่วงเวลาสองช่วงทับซ้อนกันระหว่างช่วงเวลาที่กำหนดหรือไม่140
947การรวมช่วงเวลา140
948โซลูชัน Leetcode กองซ้อนความถี่สูงสุด140
949ค้นหาอักขระทั่วไป Leetcode Solution140
9503 ผลรวม140
951Binary Tree ลำดับต่อเนื่องที่ยาวที่สุด LeetCode Solution140
952นับเมทริกซ์ย่อยด้วยโซลูชัน LeetCode ทั้งหมด140
953จำนวนคู่ที่เทียบเท่ากับโซลูชัน Leetcode ของ Domino140
954ค้นหาแถวที่ได้รับอนุญาตทั้งหมดของแถวที่กำหนดในเมทริกซ์140
955Reverse Nodes ใน K-Group140
956สามารถสร้างความก้าวหน้าทางคณิตศาสตร์จากลำดับ Leetcode Solution139
957พิมพ์ลำดับฟีโบนักชีโดยใช้ 2 ตัวแปร139
958ค้นหาความแตกต่าง Leetcode Solution139
959เกม Stone II Leetcode139
960สลับจำนวนเต็ม 2n เป็น a1-b1-a2-b2-a3-b3 - .. bn โดยไม่ต้องใช้พื้นที่เพิ่ม139
961แบ่งคำ139
962นับคู่กับผลรวมที่ได้รับ139
963ผลิตภัณฑ์ของ Array ยกเว้น Self LeetCode Solution138
964สามโซลูชั่น Leetcode อัตราต่อรองติดต่อกัน138
965Kth องค์ประกอบที่เล็กที่สุดในโซลูชัน BST Leetcode138
966เพิ่มผลรวมอาร์เรย์ให้สูงสุดหลังจาก K Negations Leetcode Solution138
967ต้นไม้ที่มีความสูงขั้นต่ำ โซลูชัน LeetCode138
968วิเคราะห์รูปแบบการเยี่ยมชมเว็บไซต์ของผู้ใช้ LeetCode Solution138
969ค้นหาการส่งผ่านทางไปรษณีย์ของ BST จากการสั่งซื้อล่วงหน้า138
970ความยาวของ Fibonacci ที่ยาวที่สุดต่อมา138
971โซลูชัน LeetCode สตริงย่อยที่ยาวที่สุด138
972การแบ่งพาร์ติชัน Palindrome138
973ความสูงของต้นไม้ทั่วไปจากอาร์เรย์แม่138
974สร้างจำนวนสูงสุด137
975หน้าต่างบานเลื่อนสูงสุด137
976การแบ่งอาร์เรย์ออกเป็นคู่ด้วยผลรวมหารด้วย K137
977ตรวจสอบว่าคำใดเกิดขึ้นเป็นคำนำหน้าของคำใด ๆ ในประโยค Leetcode Solution137
978ต้นไม้สมมาตร137
979การส่งผ่านลำดับระดับของต้นไม้ไบนารี137
980โซลูชัน Boomerang Leetcode ที่ถูกต้อง137
981ค่ามัธยฐานของอาร์เรย์ที่เรียงลำดับสองรายการ137
982เพื่อนวัยที่เหมาะสม LeetCode Solution137
983ผลิตภัณฑ์สูงสุดของดัชนีของมหานครถัดไปทางซ้ายและขวา137
984นับราคาในช่วง137
985สัญลักษณ์ของผลิตภัณฑ์ Array LeetCode Solution137
986เส้นทางที่ไม่ซ้ำกัน II137
987Subarray ผลิตภัณฑ์สูงสุด137
988ชุดย่อยคู่ที่หารไม่ได้ที่ใหญ่ที่สุด137
989การชนกันของดาวเคราะห์น้อย LeetCode Solution136
990การดำเนินการลบทรีค้นหาแบบไบนารี136
991ความยาวสูงสุดของ Subarray ซ้ำ136
992การแปลงน้ำหนักสูงสุดของสตริงที่กำหนด136
993ต้นไม้กลุ่ม136
994เรือกวาดทุ่นระเบิด LeetCode โซลูชั่น136
995ปัญหาพาร์ทิชันของจิตรกร136
996ผลรวม Subarray สูงสุดไม่รวมองค์ประกอบบางอย่าง136
997การส่งผ่านคำสั่งระดับโดยใช้สองคิว136
998ค้นหา Subtrees ที่ซ้ำกัน136
999ปัญหาการจัดวงเล็บแบบบูลีน136
1000ปฏิทินของฉัน I LeetCode Solution136
1001การค้นหาแรกกว้าง (BFS) สำหรับกราฟ136
1002ลำดับนิวแมน - คอนเวย์136
1003K จุดที่ใกล้ที่สุดไปยังแหล่งกำเนิด Leetcode Solution136
1004รูปแบบเกิดขึ้นโดยใช้ Stack136
1005ผลรวมสูงสุดในลำดับต่อมาที่ไม่มีสามตัวติดต่อกัน136
1006จำนวนผลต่อเนื่องที่ยาวที่สุดที่เพิ่มขึ้น136
1007สิ่งแรกที่ขาดหายไปในเชิงบวก136
1008ค้นหาทัวร์รอบแรกที่เยี่ยมชมปั๊มน้ำมันทั้งหมด135
1009การจับคู่สตริงในโซลูชัน Array Leetcode135
1010ถัดไป Greater Element III โซลูชัน LeetCode135
1011ในเวลาต่อมาความแตกต่างระหว่าง adjacents เป็นหนึ่ง135
1012ค้นหาค่าสูงสุดของค่าต่ำสุดสำหรับทุกขนาดหน้าต่างในอาร์เรย์ที่กำหนด135
1013Depth First Search (DFS) สำหรับกราฟ135
1014กราฟต้นไม้ที่ถูกต้อง โซลูชัน LeetCode135
1015สตริงย่อยที่ใหญ่ที่สุดระหว่างโซลูชัน Leetcode สองอักขระที่เท่ากัน135
1016พาร์ติชั่นผลรวมย่อยที่เท่าเทียมกัน135
1017Morris Inorder Traversal135
1018เพิ่มองค์ประกอบแรกเป็นสองเท่าและย้ายศูนย์ไปยังจุดสิ้นสุด135
1019การแทรกในทรีไบนารี135
1020Serialize และ Deserialize Binary Tree135
1021จำนวนวิธีสูงสุดในการแบ่งพาร์ติชันโซลูชัน LeetCode ของอาร์เรย์134
1022ตรวจสอบโครงสร้างการค้นหาแบบไบนารี134
1023การสร้างผลที่ตามมาที่เพิ่มขึ้นยาวนานที่สุด (N log N)134
1024ถอดรหัสสตริงจาก Alphabet เป็น Integer Mapping Leetcode Solution134
1025โซลูชัน Leetcode ของ Word ที่สั้นที่สุด134
1026นับ subarrays ที่สูงสุดรองลงมาก่อนสูงสุด134
1027โซลูชัน Leetcode ที่ใหญ่ที่สุด134
1028การข้ามผ่านขอบเขตของต้นไม้ไบนารี134
1029จัดเรียงอาร์เรย์ใหม่เพื่อให้ 'arr [j]' กลายเป็น 'i' ถ้า 'arr [i]' เป็น 'j'134
1030ไต่บันได134
1031K ผลรวมสูงสุดของอาร์เรย์ย่อยที่ติดกันทับซ้อนกัน134
1032ฆ่ากระบวนการ LeetCode Solution134
1033สร้างอาร์เรย์ด้วยโซลูชัน Leetcode ของ Stack Operations134
1034สร้างโซลูชัน Leetcode ที่ยอดเยี่ยมของ String134
1035โซลูชัน LeetCode Maze III134
1036โซลูชัน LeetCode สตริงการแย่งชิง133
1037Design Hit Counter โซลูชัน LeetCode133
1038จัดเรียงอาร์เรย์ใหม่เพื่อให้ตำแหน่งที่สูงกว่าคี่133
1039ธุรกรรมที่ไม่ถูกต้อง โซลูชัน LeetCode133
1040คำนวณ nCr% p133
1041สร้าง Binary Tree จากการเป็นตัวแทนของ Parent Array133
1042ข้อดีของ BST มากกว่า Hash Table132
1043หมายเลขที่น่าเกลียดสุด ๆ132
1044ผลรวมสูงสุดของ 3 Subarrays ที่ไม่ทับซ้อนกัน132
1045ต้นไม้ค้นหาแบบไบนารี132
1046น่าเกลียดหมายเลข II LeetCode โซลูชั่น132
1047เพิ่มตัวเลขสองตัว132
1048ต้นไม้ไบนารีที่สมดุล132
1049การกำหนดที่อยู่ IP โซลูชัน LeetCode132
1050ย้ายองค์ประกอบเชิงลบทั้งหมดไปสิ้นสุดตามลำดับโดยอนุญาตให้มีพื้นที่ว่างเพิ่มเติม132
1051สามารถจับภาพได้สำหรับ Rook Leetcode Solution132
1052ค้นหาจำนวนคู่ในอาร์เรย์เพื่อให้ XOR เป็น 0132
1053ผลรวมดัชนีขั้นต่ำของสองรายการ132
1054ความลึกแบบวนซ้ำครั้งแรกของกราฟ131
1055กำหนดว่าสามารถรับเมทริกซ์โดยการหมุนโซลูชัน LeetCode หรือไม่131
1056ความแตกต่างสูงสุดระหว่างความถี่ของสององค์ประกอบเช่นองค์ประกอบที่มีความถี่มากขึ้นก็มีค่ามากกว่าเช่นกัน131
1057นับคู่จากอาร์เรย์ที่เรียงลำดับสองอาร์เรย์ซึ่งผลรวมเท่ากับค่าที่กำหนด x131
1058ตัวเลขที่น่าเกลียด131
1059กู้คืนโซลูชัน Leetcode ต้นไม้การค้นหาไบนารี131
1060โซลูชัน Leetcode สตริงการเรียงลำดับแบบกำหนดเอง131
1061Binary Tree มุมมองด้านขวา โซลูชัน LeetCode131
1062การจับคู่นิพจน์ปกติ การจับคู่นิพจน์ปกติ การจับคู่นิพจน์ โซลูชัน LeetCode131
1063ค้นหาโซลูชัน LeetCode ของ Peak Element II131
1064สร้างวงเล็บ Leetcode Solution131
1065Bitwise และช่วงตัวเลข โซลูชัน LeetCode131
1066ใช้ Trie (ทรีคำนำหน้า) Leetcode Solution131
1067จำนวนพา ธ พาลินโดรมิกในเมทริกซ์131
1068Path Sum II LeetCode Solution130
1069ลำดับความยาวสูงสุดที่มีความแตกต่างระหว่างองค์ประกอบที่อยู่ติดกันเป็น 0 หรือ 1130
1070ที่ใหญ่ที่สุด BST Subtree โซลูชัน LeetCode130
1071ความสำคัญของพนักงาน LeetCode Solution130
1072จัดเรียงอาร์เรย์ใหม่เพื่อให้องค์ประกอบดัชนีมีขนาดเล็กลงและองค์ประกอบดัชนีคี่มีค่ามากกว่า130
1073ค้นหา Peak Element130
1074เพิ่มระยะห่างสูงสุดให้กับบุคคลที่ใกล้ที่สุด LeetCode Solution129
1075ค้นหาว่า subarray อยู่ในรูปของภูเขาหรือไม่129
1076Kth ผลิตภัณฑ์ที่เล็กที่สุดของอาร์เรย์ที่เรียงลำดับสองชุด LeetCode Solution129
1077นับขั้นต่ำเพื่อให้ได้อาร์เรย์ที่ต้องการ129
1078ขนาดต่ำสุด Subarray Sum129
1079ค้นหาช่วงที่เล็กที่สุดที่มีองค์ประกอบจาก k Lists129
1080จำนวนนักเรียนที่ทำการบ้านในเวลาที่กำหนดโซลูชัน Leetcode129
1081ผลที่ตามมาของ Bitonic ที่ยาวที่สุด129
1082บรรพบุรุษที่ต่ำที่สุด129
1083ลบรายการที่ซ้ำกันออกจาก Sorted Array II Leetcode Solution129
1084โคลนต้นไม้ไบนารีด้วยตัวชี้แบบสุ่ม129
1085โครงสร้างข้อมูลไบนารีทรี129
1086ทำให้เป็นอันดับและดีซีเรียลไลซ์ Binary Tree LeetCode Solution129
1087Kth องค์ประกอบที่เล็กที่สุดในโซลูชัน LeetCode เมทริกซ์ที่เรียงลำดับ129
1088ผลที่ตามมาที่แตกต่าง129
1089ลบรายการที่ซ้ำกันออกจากอาร์เรย์ที่เรียงลำดับ128
1090จำนวนพี่น้องของโหนดที่กำหนดใน n-ary Tree128
1091การเติมพอยน์เตอร์ขวาถัดไปในแต่ละโหนด Leetcode Solution128
1092เพิ่ม Triplet Subsequence โซลูชัน LeetCode128
1093ค้นหาในเรียงลำดับอาร์เรย์ที่หมุน128
1094ลบ Palindromic Subsequences Leetcode Solution128
1095โซลูชัน Leetcode ภูมิภาคทั่วไปที่เล็กที่สุด128
1096ช่วงเวลาคงที่เพิ่มการดำเนินการในอาร์เรย์128
1097รวมผลรวม IV LeetCode โซลูชั่น128
1098จำนวนเกาะที่ปิด โซลูชัน Leetcode128
1099พิมพ์แฝดทั้งหมดในอาร์เรย์ที่เรียงลำดับซึ่งเป็นรูปแบบ AP128
1100ประเภทของต้นไม้ไบนารี128
1101อาร์เรย์ย่อยที่มี K จำนวนเต็มต่างกัน Leetcode Solution128
1102ค้นหาสามองค์ประกอบจากสามอาร์เรย์ที่แตกต่างกันซึ่ง a + b + c = sum127
1103เส้นทางรูทสู่ลีฟพร้อมผลรวมเป้าหมาย Leetcode Solutions127
1104ผลรวมเส้นทาง127
1105ถัดไป การเรียงสับเปลี่ยน Leetcode Solution127
1106หาระยะห่างต่ำสุดระหว่างตัวเลขสองตัว127
1107พิมพ์คิวรี Q จำนวนมากขึ้นถัดไป126
1108รูปสามเหลี่ยมคะแนนขั้นต่ำของ Polygon Leetcode Solution126
1109สร้าง Binary Tree จากการสั่งซื้อล่วงหน้าและการสั่งซื้อทางไปรษณีย์ LeetCode Solution126
1110วันแห่งปี Leetcode Solution126
1111โซลูชัน Leetcode จำนวนสูงสุดอันดับสาม126
1112การนับคู่หาร126
1113เซลล์ที่มีค่าคี่ในเมทริกซ์ LeetCode Solution126
1114ระดับของแต่ละโหนดใน Tree จากโหนดต้นทาง126
1115ค้นหาความแตกต่างสูงสุดระหว่างองค์ประกอบขนาดเล็กทางซ้ายและขวาที่ใกล้ที่สุด126
1116แปลง BST เป็น Min-Heap โดยไม่ต้องใช้อาร์เรย์125
1117นับโซลูชัน Leetcode กลุ่มที่ใหญ่ที่สุด125
1118Subarray ผลิตภัณฑ์สูงสุด125
1119เขียนโค้ดเพื่อตรวจสอบว่าต้นไม้สองต้นเหมือนกันหรือไม่125
1120ตัวละครต่อเนื่อง LeetCode Solution125
1121Subarray ที่ยาวที่สุดของ 1 หลังจากลบ One Element LeetCode Solution125
1122ฟอร์แมตโซลูชัน String Leetcode125
1123ผลรวมของเลขคู่หลังการสืบค้น125
1124ปัญหาผลรวมย่อยในช่องว่าง O (sum)124
1125โซลูชัน Prime Palindrome LeetCode124
1126โซลูชัน Leetcode ตัวคั่นพัน124
1127พิมพ์มุมมองด้านขวาของทรีไบนารี124
1128ผลิตภัณฑ์ของช่วงในอาร์เรย์124
1129ค่าเฉลี่ยของอาร์เรย์หลังจากลบองค์ประกอบบางส่วน Leetcode Solution124
1130ค้นหาตำแหน่งแทรก124
1131ความแตกต่างขั้นต่ำที่แน่นอนใน BST Leetcode Solution124
1132ลำดับ Moser-de Bruijn124
1133มุมมองด้านล่างของทรีไบนารี124
1134การเรียงลำดับโทโพโลยี124
1135ลำดับโกลอมบ์123
1136ค้นหาสองอาร์เรย์ย่อยที่ไม่ทับซ้อนกันซึ่งแต่ละรายการมีโซลูชัน LeetCode รวมเป้าหมาย123
1137สถานะ LeetCode ที่ถูกต้องของ Tic-Tac-Toe123
1138ต้นไม้ไบนารีสูงสุด123
1139เส้นผ่านศูนย์กลางของ N-Ary Tree LeetCode Solution123
1140ตัดคัน123
1141Palindrome Permutation LeetCode Solution123
1142รวม BST สองตัวเข้ากับพื้นที่พิเศษที่ จำกัด122
1143การสืบค้นจำนวนองค์ประกอบที่แตกต่างใน Subarray122
1144เพิ่มขึ้นต่อเนื่องยาวนานที่สุด122
1145วิธีการซ้ำเพื่อค้นหาบรรพบุรุษของต้นไม้ไบนารีที่กำหนด122
1146สลับโหนดในคู่122
1147ตรวจสอบการสร้างอาร์เรย์ผ่านโซลูชัน Leetcode ที่เชื่อมต่อกัน122
1148ค้นหาองค์ประกอบในเรียงลำดับอาร์เรย์ที่หมุน122
1149โซลูชัน Leetcode มูลค่าการค้นหาไบนารีที่ใกล้เคียงที่สุด122
1150ค้นหาลำดับต่อมาของขนาด 3 ในเวลาเชิงเส้น122
1151โซลูชัน LeetCode แบบสองพาร์ติชั่นที่เป็นไปได้121
1152ขั้นต่ำ Sideway Jumps โซลูชัน LeetCode121
1153สร้าง K Palindrome Strings LeetCode Solution121
1154ผลรวมขั้นต่ำของกำลังสองของจำนวนอักขระในสตริงที่กำหนดหลังจากลบอักขระ k121
1155เส้นทางรถเมล์ Leetcode Solution121
1156ผลิตภัณฑ์สูงสุดของโซลูชัน LeetCode Binary Tree แบบแยกส่วน121
1157พิมพ์อาร์เรย์ที่แก้ไขหลังจากดำเนินการคำสั่งของการบวกและการลบ121
1158Kth จำนวนน้อยที่สุดในตารางสูตรคูณ Leetcode Solution121
1159Binary Tree เป็น Binary Search Tree Conversion121
1160เปรียบเทียบสตริงตามความถี่ของโซลูชัน Leetcode ตัวอักษรที่เล็กที่สุด120
1161ค้นหาตัวคูณเลขฐานสองที่เล็กที่สุดของจำนวนที่กำหนด120
1162ผลที่ตามมาซ้ำซากยาวที่สุด120
1163แนะนำต้นไม้แดง - ดำ120
1164แฟกทอเรียลต่อท้าย Zeroes โซลูชัน LeetCode120
1165ค้นหาลำดับงูที่มีความยาวสูงสุด120
1166ค้นหาค่าที่มากที่สุดในแต่ละ Tree Row LeetCode Solution120
1167แปลง BST เป็น Greater sum Tree120
1168ค้นหาระบบข้อเสนอแนะ LeetCode Solution119
1169การสลับโหนดในรายการที่เชื่อมโยง โซลูชัน Leetcode119
1170ต้นทุนขั้นต่ำในการย้ายชิปไปยังตำแหน่งเดียวกัน โซลูชัน LeetCode119
1171สตริงย่อย Palindromic Leetcode Solution119
1172จำนวนการสั่งซื้อใน Backlog Leetcode Solution119
1173คิวลำดับความสำคัญ119
1174หมุนอาร์เรย์119
1175เพิ่มผลรวมของความแตกต่างที่ต่อเนื่องกันสูงสุดในอาร์เรย์แบบวงกลม119
1176นับลำดับไบนารีที่มีความยาวเท่ากันโดยมีผลรวมของบิตครึ่งแรกและครึ่งหลังเท่ากัน119
1177ลบจำนวนขอบสูงสุดเพื่อให้กราฟสามารถสำรวจได้อย่างเต็มที่ Leetcode Solution118
1178จำนวนส่วนสูงสุดของความยาว a, b และ c118
1179ลดองค์ประกอบเพื่อสร้าง Array Zigzag LeetCode Solution118
1180ต้นไม้ตัดสินใจ118
1181ลบโหนดและส่งคืน Forest Leetcode Solution118
1182subarray bitonic ผลรวมสูงสุด118
1183กราฟและการแสดง118
1184นับคู่ที่มีผลิตภัณฑ์อยู่ในอาร์เรย์118
1185K'th องค์ประกอบที่ใหญ่ที่สุดใน BST โดยใช้ช่องว่างคงที่118
1186โซลูชัน LeetCode ของโปรแกรมรวบรวมข้อมูลเว็บ118
1187การย้ายขั้นต่ำไปยัง Equal Array Elements โซลูชัน LeetCode118
1188การสร้างคิวใหม่ตามความสูง117
1189วิธีพิมพ์จำนวน A สูงสุดโดยใช้ปุ่มสี่ปุ่มที่กำหนด117
1190Matchsticks กับ Square Leetcode Solution117
1191โซลูชัน LeetCode Array ที่ต่อเนื่องกัน117
1192ย้อนกลับเส้นทางใน BST โดยใช้ Queue117
1193บรรพบุรุษร่วมที่ต่ำที่สุดในโครงสร้างการค้นหาแบบไบนารี117
1194หมายเลขสามเหลี่ยมที่ถูกต้อง117
1195กรองร้านอาหารตามอาหารมังสวิรัติ ราคา และระยะทาง โซลูชัน Leetcode116
1196ผลรวมของใบซ้าย LeetCode Solution116
1197ใบไม้ที่ใกล้เคียงที่สุดใน Binary Tree LeetCode Solution116
1198แปลง Sorted Array เป็น Binary Search Tree LeetCode Solutions116
1199ผลรวมสูงสุดของคู่ที่มีความแตกต่างเฉพาะ116
1200แบบสอบถามอาร์เรย์สำหรับการแทนที่และผลิตภัณฑ์แบบทวีคูณ116
1201เวอร์ชันแรกที่ไม่ดี116
1202Kth องค์ประกอบที่เล็กที่สุดใน BST116
1203การเคลื่อนย้ายหินไปจนถึงโซลูชัน Leetcode แบบต่อเนื่อง116
1204การสืบค้นช่วงสำหรับลำดับต่อมา Bracket ที่ถูกต้องยาวที่สุด115
1205เดาคำ115
1206การต่อกันของ Array LeetCode Solution115
1207ด้วยต้นไม้ไบนารีคุณจะลบครึ่งโหนดทั้งหมดได้อย่างไร?115
1208ตัวแบ่งจำนวนเต็ม LeetCode Solution115
1209Swap ขั้นต่ำเพื่อสร้างลำดับที่เพิ่มขึ้นโซลูชัน LeetCode115
1210แผ่โซลูชัน LeetCode เวกเตอร์ 2D ให้เรียบ114
1211แปลงจำนวนเต็มเป็นผลรวมของโซลูชัน Leetcode จำนวนเต็มไม่มีศูนย์สองตัว114
1212หารสองจำนวนเต็ม Leetcode Solution114
1213บรรพบุรุษร่วมที่ต่ำที่สุดของโซลูชัน Leetcode แบบไบนารี114
1214การสืบค้นช่วงผลรวมโดยใช้ตารางกระจัดกระจาย114
1215แทนที่ค่าที่เท่ากันสองค่าติดกันด้วยค่าหนึ่งที่มากกว่า114
1216ฟอร์แมตวันที่ โซลูชัน LeetCode113
1217แชมเปญทาวเวอร์ โซลูชัน LeetCode113
1218ปัจจัยที่ k ของ n Leetcode Solution113
1219โซลูชัน Leetcode เครื่องหมายบวกที่ใหญ่ที่สุด113
1220พลังของสอง113
1221สไลซ์เลขคณิต II – ลำดับต่อมา โซลูชัน LeetCode113
1222โซลูชัน LeetCode Perfect Square ที่ถูกต้อง113
1223LRU Cache Leetcode Solution113
1224โซลูชัน Leetcode ข้ามเส้นทาง113
1225ตรวจสอบความสมบูรณ์ของ Binary Tree LeetCode Solution113
1226Perfect Squares โซลูชัน LeetCode113
1227ความลึกสูงสุดของไบนารีทรี113
1228ผลรวมสูงสุดของเส้นทางในสามเหลี่ยมตัวเลขด้านขวา112
1229ผสานการเรียง112
1230พิมพ์อาร์เรย์ที่แก้ไขหลังจากการดำเนินการเพิ่มช่วงอาร์เรย์หลายรายการ112
1231หลักสูตรคู่ขนาน II โซลูชัน LeetCode112
1232คำนำหน้าทั่วไปที่ยาวที่สุดโดยใช้ Word โดยการจับคู่คำ112
1233ตัวหนาในสตริง LeetCode Solution112
1234ตรวจสอบ BST ที่เหมือนกันโดยไม่ต้องสร้างต้นไม้112
1235ค้นหาขั้นต่ำใน Rotated Sorted Array II LeetCode Solution112
1236เขียนฟังก์ชันเพื่อหาจุดตัดของรายการที่เชื่อมโยงสองรายการ112
1237ใหม่ 21 เกม112
1238ขยายองค์ประกอบให้ใหญ่ที่สุดโดยใช้อาร์เรย์อื่น112
1239คำถามเกี่ยวกับความน่าจะเป็นของเลขคู่หรือเลขคี่ในช่วงที่กำหนด112
1240ค่าเฉลี่ยของช่วงในอาร์เรย์112
1241ตรวจสอบว่าแต่ละโหนดภายในของ BST มีลูกเดียวหรือไม่111
1242การโคลนกราฟ111
1243พิมพ์ n เงื่อนไขของลำดับนิวแมน - คอนเวย์111
1244Symmetric Tree โซลูชัน LeetCode โซลูชัน Leetcode111
1245โซลูชัน Leetcode ค่ามัธยฐานของหน้าต่างบานเลื่อน111
1246BST ไปยังต้นไม้ที่มีผลรวมของคีย์ที่เล็กกว่าทั้งหมด111
1247ค่าสูงสุดที่ดัชนีที่กำหนดในโซลูชัน LeetCode ที่มีขอบเขต111
1248ค้นหาจำนวนขั้นต่ำของการดำเนินการผสานเพื่อสร้างอาร์เรย์พาลินโดรม110
1249ออกแบบ Skiplist โซลูชัน LeetCode110
1250ตรวจสอบว่าทุกระดับของ Binary Tree ทั้งสองเป็นแอนนาแกรมหรือไม่110
1251นับชุดย่อยที่มีเลขคู่ที่แตกต่างกัน110
1252ไม่มีหมายเลข110
1253อาร์เรย์ที่ต่อเนื่องกัน110
1254Subarray ผลิตภัณฑ์สูงสุด110
1255อาร์เรย์สูงสุดจากอาร์เรย์สองอาร์เรย์ที่กำหนดให้มีลำดับเหมือนกัน109
1256โซลูชัน Leetcode ช่วงที่เล็กที่สุด109
1257ชื่อคอลัมน์แผ่นงาน Excel โซลูชัน LeetCode108
1258พิมพ์บรรพบุรุษของโหนดต้นไม้ไบนารีที่กำหนดโดยไม่มีการเรียกซ้ำ108
1259ตรวจสอบว่าสองโหนดอยู่บนเส้นทางเดียวกันใน Tree หรือไม่108
1260ผสาน k เรียงลำดับรายการ Leetcode Solution108
1261นับและสลับการค้นหาในอาร์เรย์ไบนารี108
1262โซลูชัน LeetCode ที่ทับซ้อนกันของรูปภาพ108
1263ต้นทุนขั้นต่ำปีนบันได LeetCode Solution107
1264องค์ประกอบที่ยิ่งใหญ่กว่าถัดไป107
1265ค้นหาองค์ประกอบที่เล็กที่สุดเป็นอันดับที่ k ใน BST (สถิติการสั่งซื้อใน BST)107
1266Koko กินกล้วย LeetCode Solution107
1267ลบขั้นต่ำเพื่อสร้างวงเล็บที่ถูกต้อง LeetCode Solution107
1268จำนวนองค์ประกอบที่น้อยกว่าหรือเท่ากับจำนวนที่กำหนดใน subarray ที่กำหนด107
1269ตรวจสอบว่าสตริงสามารถทำลายโซลูชัน Leetcode สตริงอื่นได้หรือไม่106
1270ตรวจสอบลำดับการสั่งซื้อล่วงหน้าของไบนารีทรี106
1271วิธีต่างๆ ในการเพิ่มวงเล็บ Leetcode Solution106
1272การแบ่งพาร์ติชัน Palindrome106
1273Peeking Iterator โซลูชัน LeetCode105
1274เวลาขั้นต่ำในการรวบรวม Apples ทั้งหมดใน Tree โซลูชัน LeetCode104
1275ผสานอาร์เรย์ที่จัดเรียง103
1276คิวที่เป็นระเบียบ โซลูชั่น LeetCode103
1277ตรวจสอบอาร์เรย์ไบนารีว่าตัวเลขที่แสดงโดย subarray เป็นเลขคี่หรือคู่102
1278นิวแมน - แชงค์ส - วิลเลียมส์ไพรม์102
1279สตริงย่อยที่ยาวที่สุดโดยไม่ใช้อักขระซ้ำ Leetcode Solution102
1280Array Nesting Leetcode Solution101
1281การจัดเรียงเหรียญ โซลูชัน Leetcode101
1282ตรวจสอบว่า X สามารถให้การเปลี่ยนแปลงกับทุกคนในคิวได้หรือไม่101
1283เมทริกซ์ย่อยที่ใหญ่ที่สุดพร้อมการจัดเรียงใหม่ LeetCode Solution101
1284ผลรวมสูงสุดที่เพิ่มขึ้นตามมา100
1285เข้ารหัสสตริงด้วยความยาวที่สั้นที่สุด LeetCode Solution100
1286จำนวนดัชนีที่มีองค์ประกอบเท่ากันในช่วงที่กำหนด98
1287ค้นหา subarray เฉลี่ยสูงสุดของความยาว k98
1288ช่วงการสืบค้นขั้นต่ำ (การสลายตัวของรากที่สองและตารางกระจัดกระจาย)98
1289พื้นที่รวมขั้นต่ำที่สูญเปล่าด้วย K Resizing Operations LeetCode Solution98
1290ผลิตภัณฑ์สูงสุดของลำดับต่อมาที่เพิ่มขึ้น97
1291แบบสอบถามสำหรับค่าทศนิยมของ Subarrays ของ Binary Array97
1292จำนวนคนขั้นต่ำในการสอนโซลูชัน LeetCode97
1293ดัชนีสุ่มเลือก LeetCode Solution97
1294ค้นหาผู้ชนะของเกม Circular โซลูชัน LeetCode96
1295เพิ่มโซลูชัน Leetcode สองหมายเลข95
1296การส่งผ่านคำสั่งในแนวตั้งของ Binary Tree LeetCode Solution95
1297แปลงเป็นฐาน -2 โซลูชัน LeetCode95
1298Binary Tree เป็น Binary Search Tree Conversion โดยใช้ชุด STL95
1299โซลูชัน Subarray Sum LeetCode อย่างต่อเนื่อง94
1300แปลง BST เป็น Binary Tree เพื่อให้ผลรวมของคีย์ที่ใหญ่กว่าทั้งหมดจะถูกเพิ่มเข้าไปในทุกๆ94
1301จำนวนเต็มต่ำสุดที่เป็นไปได้หลังจากมากที่สุด K Adjacent Swap บนตัวเลข โซลูชัน LeetCode94
1302โซลูชัน LeetCode หมายเลข Palindrome94
1303ตรวจสอบอาร์เรย์ของขนาด n สามารถแสดง BST ของระดับ n ได้หรือไม่94
1304Jump Game IV โซลูชัน LeetCode93
1305เข้าถึงหมายเลขโซลูชัน LeetCode93
1306แทรก ลบ GetRandom O(1) Leetcode Solution93
1307ข้อความค้นหาเกี่ยวกับ XOR ของตัวหารคี่ที่ยิ่งใหญ่ที่สุดของช่วง93
1308จำนวนครั้งต่อๆ มาที่ตรงตามเงื่อนไขผลรวมที่ให้มา โซลูชัน LeetCode91
1309ออกแบบระบบใต้ดิน Leetcode Solution89
1310พิมพ์โซ่ความยาวสูงสุดของคู่87
1311ตรวจหาโซลูชัน Leetcode ของ Capital86
1312ออกแบบลีดเดอร์บอร์ด Leetcode Solution85
1313สตริงย่อยที่มีการต่อคำทุกคำ Leetcode Solution82
1314โซลูชัน LeetCode องค์ประกอบที่ใช้บ่อยยอดนิยม81
1315สวอปขั้นต่ำเพื่อรวมโซลูชัน Leetcode เข้าด้วยกันทั้งกลุ่ม80
1316โซลูชัน Leetcode รวมเส้นทางขั้นต่ำ79
1317นับหมู่เกาะย่อย โซลูชัน LeetCode79
1318เปลี่ยนตัวอักษร โซลูชัน LeetCode77
1319Binary Tree Inorder Traversal โซลูชัน LeetCode77
1320จุดนัดพบที่ดีที่สุด โซลูชัน LeetCode76
1321ค้นหาโซลูชัน LeetCode ผู้พิพากษาเมือง74
1322ถอดรหัสสตริง Leetcode Solution74
1323ลำดับต่อมาที่ยาวที่สุด โซลูชัน LeetCode74
1324ค้นหาโซลูชัน LeetCode ผู้พิพากษาเมือง73
1325รายการที่เชื่อมโยงคู่คี่ โซลูชัน Leetcode73
1326โซลูชั่น LeetCode ปีประชากรสูงสุด73
1327รวมรูทกับหมายเลขลีทโค้ดโซลูชั่น71
1328โซลูชัน LeetCode Subarray ต่อเนื่องที่ไม่ได้เรียงลำดับที่สั้นที่สุด71
1329ออกแบบ เพิ่มและค้นหาคำ โครงสร้างข้อมูล โซลูชัน LeetCode68
1330สี่เหลี่ยมผืนผ้าทับซ้อน LeetCode Solution67
1331คะแนนของวงเล็บ LeetCode Solution66
1332Range Sum Query 2D – โซลูชัน LeetCode ที่ไม่เปลี่ยนรูป66
1333โซลูชั่น LeetCode ปีประชากรสูงสุด66
1334เกมสโตน IV โซลูชัน LeetCode65
1335แทรกลงในรายการที่เชื่อมโยงแบบวงกลมที่เรียงลำดับแล้ว LeetCode Solution65
1336แผ่ Binary Tree ให้แบนเพื่อแสดงรายการที่เชื่อมโยง LeetCode Solution64
1337เปิดเผยการ์ดในการสั่งซื้อที่เพิ่มขึ้น Leetcode Solution63
1338Graph Bipartite คืออะไร? โซลูชัน LeetCode62
1339โซลูชัน LeetCode หมายเลขสามเหลี่ยมที่ถูกต้อง60
1340แบ่งช็อกโกแลต LeetCode Solution53
1341คำแนะนำทีละขั้นตอนจากโหนดต้นไม้ไบนารีไปยังโซลูชัน LeetCode อื่น47
1342ช่วงผลรวมของ BST LeetCode Solution45
1343จัดเรียงสี โซลูชัน LeetCode42
1344ย้อนกลับโซลูชัน Leetcode จำนวนเต็ม41
1345ค้นหา K องค์ประกอบที่ใกล้เคียงที่สุด LeetCode Solution40
1346หมายเลขคอลัมน์ของแผ่นงาน Excel โซลูชัน LeetCode37
1347หมุนโซลูชัน LeetCode สตริง36
1348ความยาวด้านสูงสุดของสี่เหลี่ยมจัตุรัสที่มีผลรวมน้อยกว่าหรือเท่ากับเกณฑ์ LeetCode Solution35
1349ขนาดสูงสุด Subarray Sum เท่ากับ k Leetcode Solution18
1350โซลูชัน Leetcode ของดัชนี H15
1351โซลูชัน LeetCode ไฮไฟว์14
Translate »