Ultimativer Leitfaden zur Problemlösung bei der Codierung von Interviews

Gängige Strategien zum Codieren von Interviewfragen

Zwei Hinweise

Die Zwei-Zeiger-Technik wird häufig verwendet, um Array-bezogene Probleme effizient zu lösen. Dabei werden zwei Zeiger verwendet, die sich entweder aufeinander zu oder in die gleiche Richtung bewegen.

Beispiel: Finden eines Zahlenpaars in einem sortierten Array, dessen Summe einen Zielwert ergibt.

/**
 * Finds a pair of numbers in a sorted array that sum up to a target value.
 * Uses the two-pointer technique for efficient searching.
 * 
 * @param {number[]} arr - The sorted array of numbers to search through.
 * @param {number} target - The target sum to find.
 * @returns {number[]|null} - Returns an array containing the pair if found, or null if not found.
 */
function findPairWithSum(arr, target) {
  // Initialize two pointers: one at the start and one at the end of the array
  let left = 0;
  let right = arr.length - 1;

  // Continue searching while the left pointer is less than the right pointer
  while (left < right) {
    console.log(`Checking pair: ${arr[left]} and ${arr[right]}`);

    // Calculate the sum of the current pair
    const sum = arr[left] + arr[right];

    if (sum === target) {
      // If the sum equals the target, we've found our pair
      console.log(`Found pair: ${arr[left]} + ${arr[right]} = ${target}`);
      return [arr[left], arr[right]];
    } else if (sum < target) {
      // If the sum is less than the target, we need a larger sum
      // So, we move the left pointer to the right to increase the sum
      console.log(`Sum ${sum} is less than target ${target}, moving left pointer`);
      left++;
    } else {
      // If the sum is greater than the target, we need a smaller sum
      // So, we move the right pointer to the left to decrease the sum
      console.log(`Sum ${sum} is greater than target ${target}, moving right pointer`);
      right--;
    }
  }

  // If we've exhausted all possibilities without finding a pair, return null
  console.log("No pair found");
  return null;
}

// Example usage
const sortedArray = [1, 3, 5, 7, 9, 11];
const targetSum = 14;
findPairWithSum(sortedArray, targetSum);

Schiebefenster

Die Schiebefenstertechnik ist nützlich zum Lösen von Problemen, die zusammenhängende Sequenzen in Arrays oder Strings beinhalten.

Beispiel: Ermitteln der maximalen Summe eines Subarrays der Größe k.

/**
 * Finds the maximum sum of a subarray of size k in the given array.
 * @param {number[]} arr - The input array of numbers.
 * @param {number} k - The size of the subarray.
 * @returns {number|null} The maximum sum of a subarray of size k, or null if the array length is less than k.
 */
function maxSubarraySum(arr, k) {
  // Check if the array length is less than k
  if (arr.length < k) {
    console.log("Array length is less than k");
    return null;
  }

  let maxSum = 0;
  let windowSum = 0;

  // Calculate sum of first window
  for (let i = 0; i < k; i++) {
    windowSum += arr[i];
  }
  maxSum = windowSum;

  console.log(`Initial window sum: ${windowSum}, Window: [${arr.slice(0, k)}]`);

  // Slide the window and update the maximum sum
  for (let i = k; i < arr.length; i++) {
    // Remove the first element of the previous window and add the last element of the new window
    windowSum = windowSum - arr[i - k] + arr[i];
    console.log(`New window sum: ${windowSum}, Window: [${arr.slice(i - k + 1, i + 1)}]`);

    // Update maxSum if the current window sum is greater
    if (windowSum > maxSum) {
      maxSum = windowSum;
      console.log(`New max sum found: ${maxSum}, Window: [${arr.slice(i - k + 1, i + 1)}]`);
    }
  }

  console.log(`Final max sum: ${maxSum}`);
  return maxSum;
}

// Example usage
const array = [1, 4, 2, 10, 23, 3, 1, 0, 20];
const k = 4;
maxSubarraySum(array, k);

Hash-Tabelle

Hash-Tabellen eignen sich hervorragend zum Lösen von Problemen, die eine schnelle Suche oder das Zählen von Vorkommnissen erfordern.

Beispiel: Finden des ersten sich nicht wiederholenden Zeichens in einer Zeichenfolge.

/**
 * Finds the first non-repeating character in a given string.
 * @param {string} str - The input string to search.
 * @returns {string|null} The first non-repeating character, or null if not found.
 */
function firstNonRepeatingChar(str) {
  const charCount = new Map();

  // Count occurrences of each character
  for (let char of str) {
    charCount.set(char, (charCount.get(char) || 0) + 1);
    console.log(`Character ${char} count: ${charCount.get(char)}`);
  }

  // Find the first character with count 1
  for (let char of str) {
    if (charCount.get(char) === 1) {
      console.log(`First non-repeating character found: ${char}`);
      return char;
    }
  }

  console.log("No non-repeating character found");
  return null;
}

// Example usage
const inputString = "aabccdeff";
firstNonRepeatingChar(inputString);

Diese Strategien zeigen effiziente Möglichkeiten zur Lösung häufiger Probleme bei Codierungsinterviews auf. Die ausführliche Protokollierung in jedem Beispiel hilft, den schrittweisen Prozess der Algorithmen zu verstehen, was bei Interviews von entscheidender Bedeutung sein kann, um Ihren Denkprozess zu erklären.

Hier ist ein Codeblock, der zeigt, wie man Karten verwendet, um einige dieser Vorgänge besser zu verstehen:

// Create a new Map
const fruitInventory = new Map();

// Set key-value pairs
fruitInventory.set('apple', 5);
fruitInventory.set('banana', 3);
fruitInventory.set('orange', 2);

console.log('Initial inventory:', fruitInventory);

// Get a value using a key
console.log('Number of apples:', fruitInventory.get('apple'));

// Check if a key exists
console.log('Do we have pears?', fruitInventory.has('pear'));

// Update a value
fruitInventory.set('banana', fruitInventory.get('banana') + 2);
console.log('Updated banana count:', fruitInventory.get('banana'));

// Delete a key-value pair
fruitInventory.delete('orange');
console.log('Inventory after removing oranges:', fruitInventory);

// Iterate over the map
console.log('Current inventory:');
fruitInventory.forEach((count, fruit) => {
  console.log(`${fruit}: ${count}`);
});

// Get the size of the map
console.log('Number of fruit types:', fruitInventory.size);

// Clear the entire map
fruitInventory.clear();
console.log('Inventory after clearing:', fruitInventory);

Dieses Beispiel demonstriert verschiedene Kartenoperationen:

1. Eine neue Karte erstellen
2. Hinzufügen von Schlüssel-Wert-Paaren mit
3. Werte abrufen mit
4. Prüfung auf Schlüsselexistenz mit
5. Werte aktualisieren
6. Schlüssel-Wert-Paare löschen mit
7. Iterieren über die Karte mit
8. Größe der Karte ermitteln
9. Löschen der gesamten Karte mit Diese Operationen ähneln denen, die in der Funktion firstNonRepeatingChar verwendet werden, wo wir eine Karte verwenden, um das Vorkommen von Zeichen zu zählen und dann nach dem ersten Zeichen mit einer Anzahl von 1 suchen.

Tutorial zur dynamischen Programmierung

Dynamische Programmierung ist eine leistungsstarke algorithmische Technik, mit der komplexe Probleme gelöst werden, indem sie in einfachere Teilprobleme zerlegt werden. Lassen Sie uns dieses Konzept anhand eines Beispiels für die Berechnung von Fibonacci-Zahlen untersuchen.

/**
 * Calculates the nth Fibonacci number using dynamic programming.
 * @param {number} n - The position of the Fibonacci number to calculate.
 * @returns {number} The nth Fibonacci number.
 */
function fibonacci(n) {
  // Initialize an array to store Fibonacci numbers
  const fib = new Array(n + 1);

  // Base cases
  fib[0] = 0;
  fib[1] = 1;

  console.log(`F(0) = ${fib[0]}`);
  console.log(`F(1) = ${fib[1]}`);

  // Calculate Fibonacci numbers iteratively
  for (let i = 2; i <= n; i++) {
    fib[i] = fib[i - 1] + fib[i - 2];
    console.log(`F(${i}) = ${fib[i]}`);
  }

  return fib[n];
}

// Example usage
const n = 10;
console.log(`The ${n}th Fibonacci number is:`, fibonacci(n));

Dieses Beispiel zeigt, wie dynamische Programmierung Fibonacci-Zahlen effizient berechnen kann, indem zuvor berechnete Werte gespeichert und für zukünftige Berechnungen verwendet werden.

Tutorial zur binären Suche

Die binäre Suche ist ein effizienter Algorithmus zum Suchen eines Elements in einem sortierten Array. Hier ist eine Implementierung mit detaillierter Protokollierung:

/**
 * Performs a binary search on a sorted array.
 * @param {number[]} arr - The sorted array to search.
 * @param {number} target - The value to find.
 * @returns {number} The index of the target if found, or -1 if not found.
 */
function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    console.log(`Searching in range [${left}, ${right}], mid = ${mid}`);

    if (arr[mid] === target) {
      console.log(`Target ${target} found at index ${mid}`);
      return mid;
    } else if (arr[mid] < target) {
      console.log(`${arr[mid]} < ${target}, searching right half`);
      left = mid + 1;
    } else {
      console.log(`${arr[mid]} > ${target}, searching left half`);
      right = mid - 1;
    }
  }

  console.log(`Target ${target} not found in the array`);
  return -1;
}

// Example usage
const sortedArray = [1, 3, 5, 7, 9, 11, 13, 15];
const target = 7;
binarySearch(sortedArray, target);

Diese Implementierung zeigt, wie die binäre Suche den Suchbereich in jeder Iteration effizient um die Hälfte einschränkt und damit viel schneller ist als die lineare Suche nach großen sortierten Arrays.

• Tiefensuche (DFS)
• Breitensuche (BFS)
• Heap (Prioritätswarteschlange)
• Trie (Präfixbaum)
• Union-Find (Disjunkte Menge)
• Topologische Sortierung

Tiefensuche (DFS)

Depth-First Search ist ein Graph-Traversal-Algorithmus, der jeden Zweig so weit wie möglich erforscht, bevor er zurückverfolgt. Hier ist eine Beispielimplementierung für ein Diagramm, das als Adjazenzliste dargestellt wird:

class Graph {
  constructor() {
    this.adjacencyList = {};
  }

  addVertex(vertex) {
    if (!this.adjacencyList[vertex]) this.adjacencyList[vertex] = [];
  }

  addEdge(v1, v2) {
    this.adjacencyList[v1].push(v2);
    this.adjacencyList[v2].push(v1);
  }

  dfs(start) {
    const result = [];
    const visited = {};
    const adjacencyList = this.adjacencyList;

    (function dfsHelper(vertex) {
      if (!vertex) return null;
      visited[vertex] = true;
      result.push(vertex);
      console.log(`Visiting vertex: ${vertex}`);

      adjacencyList[vertex].forEach(neighbor => {
        if (!visited[neighbor]) {
          console.log(`Exploring neighbor: ${neighbor} of vertex: ${vertex}`);
          return dfsHelper(neighbor);
        } else {
          console.log(`Neighbor: ${neighbor} already visited`);
        }
      });
    })(start);

    return result;
  }
}

// Example usage
const graph = new Graph();
['A', 'B', 'C', 'D', 'E', 'F'].forEach(vertex => graph.addVertex(vertex));
graph.addEdge('A', 'B');
graph.addEdge('A', 'C');
graph.addEdge('B', 'D');
graph.addEdge('C', 'E');
graph.addEdge('D', 'E');
graph.addEdge('D', 'F');
graph.addEdge('E', 'F');

console.log(graph.dfs('A'));

Breitensuche (BFS)

BFS erkundet alle Scheitelpunkte in der aktuellen Tiefe, bevor es zu Scheitelpunkten in der nächsten Tiefenebene übergeht. Hier ist eine Implementierung:

class Graph {
  // ... (same constructor, addVertex, and addEdge methods as above)

  bfs(start) {
    const queue = [start];
    const result = [];
    const visited = {};
    visited[start] = true;

    while (queue.length) {
      let vertex = queue.shift();
      result.push(vertex);
      console.log(`Visiting vertex: ${vertex}`);

      this.adjacencyList[vertex].forEach(neighbor => {
        if (!visited[neighbor]) {
          visited[neighbor] = true;
          queue.push(neighbor);
          console.log(`Adding neighbor: ${neighbor} to queue`);
        } else {
          console.log(`Neighbor: ${neighbor} already visited`);
        }
      });
    }

    return result;
  }
}

// Example usage (using the same graph as in DFS example)
console.log(graph.bfs('A'));

Heap (Prioritätswarteschlange)

Ein Heap ist eine spezielle baumbasierte Datenstruktur, die die Heap-Eigenschaft erfüllt. Hier ist eine einfache Implementierung eines Min-Heaps:

class MinHeap {
  constructor() {
    this.heap = [];
  }

  getParentIndex(i) {
    return Math.floor((i - 1) / 2);
  }

  getLeftChildIndex(i) {
    return 2 * i + 1;
  }

  getRightChildIndex(i) {
    return 2 * i + 2;
  }

  swap(i1, i2) {
    [this.heap[i1], this.heap[i2]] = [this.heap[i2], this.heap[i1]];
  }

  insert(key) {
    this.heap.push(key);
    this.heapifyUp(this.heap.length - 1);
  }

  heapifyUp(i) {
    let currentIndex = i;
    while (this.heap[currentIndex] < this.heap[this.getParentIndex(currentIndex)]) {
      this.swap(currentIndex, this.getParentIndex(currentIndex));
      currentIndex = this.getParentIndex(currentIndex);
    }
  }

  extractMin() {
    if (this.heap.length === 0) return null;
    if (this.heap.length === 1) return this.heap.pop();

    const min = this.heap[0];
    this.heap[0] = this.heap.pop();
    this.heapifyDown(0);
    return min;
  }

  heapifyDown(i) {
    let smallest = i;
    const left = this.getLeftChildIndex(i);
    const right = this.getRightChildIndex(i);

    if (left < this.heap.length && this.heap[left] < this.heap[smallest]) {
      smallest = left;
    }

    if (right < this.heap.length && this.heap[right] < this.heap[smallest]) {
      smallest = right;
    }

    if (smallest !== i) {
      this.swap(i, smallest);
      this.heapifyDown(smallest);
    }
  }
}

// Example usage
const minHeap = new MinHeap();
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].forEach(num => minHeap.insert(num));
console.log(minHeap.heap);
console.log(minHeap.extractMin());
console.log(minHeap.heap);

Trie (Präfixbaum)

Ein Trie ist eine effiziente Datenstruktur zum Abrufen von Informationen, die häufig für die Suche nach Zeichenfolgen verwendet wird:

class TrieNode {
  constructor() {
    this.children = {};
    this.isEndOfWord = false;
  }
}

class Trie {
  constructor() {
    this.root = new TrieNode();
  }

  insert(word) {
    let current = this.root;
    for (let char of word) {
      if (!current.children[char]) {
        current.children[char] = new TrieNode();
      }
      current = current.children[char];
    }
    current.isEndOfWord = true;
    console.log(`Inserted word: ${word}`);
  }

  search(word) {
    let current = this.root;
    for (let char of word) {
      if (!current.children[char]) {
        console.log(`Word ${word} not found`);
        return false;
      }
      current = current.children[char];
    }
    console.log(`Word ${word} ${current.isEndOfWord ? 'found' : 'not found'}`);
    return current.isEndOfWord;
  }

  startsWith(prefix) {
    let current = this.root;
    for (let char of prefix) {
      if (!current.children[char]) {
        console.log(`No words start with ${prefix}`);
        return false;
      }
      current = current.children[char];
    }
    console.log(`Found words starting with ${prefix}`);
    return true;
  }
}

// Example usage
const trie = new Trie();
['apple', 'app', 'apricot', 'banana'].forEach(word => trie.insert(word));
trie.search('app');
trie.search('application');
trie.startsWith('app');
trie.startsWith('ban');

Union-Find (Disjunkte Menge)

Union-Find ist eine Datenstruktur, die Elemente verfolgt, die in eine oder mehrere disjunkte Mengen aufgeteilt sind:

class UnionFind {
  constructor(size) {
    this.parent = Array(size).fill().map((_, i) => i);
    this.rank = Array(size).fill(0);
    this.count = size;
  }

  find(x) {
    if (this.parent[x] !== x) {
      this.parent[x] = this.find(this.parent[x]);
    }
    return this.parent[x];
  }

  union(x, y) {
    let rootX = this.find(x);
    let rootY = this.find(y);

    if (rootX === rootY) return;

    if (this.rank[rootX] < this.rank[rootY]) {
      [rootX, rootY] = [rootY, rootX];
    }
    this.parent[rootY] = rootX;
    if (this.rank[rootX] === this.rank[rootY]) {
      this.rank[rootX]++;
    }
    this.count--;

    console.log(`United ${x} and ${y}`);
  }

  connected(x, y) {
    return this.find(x) === this.find(y);
  }
}

// Example usage
const uf = new UnionFind(10);
uf.union(0, 1);
uf.union(2, 3);
uf.union(4, 5);
uf.union(6, 7);
uf.union(8, 9);
uf.union(0, 2);
uf.union(4, 6);
uf.union(0, 4);

console.log(uf.connected(1, 5)); // Should print: true
console.log(uf.connected(7, 9)); // Should print: false

Topologische Sortierung

Topologische Sortierung wird zum Ordnen von Aufgaben mit Abhängigkeiten verwendet. Hier ist eine Implementierung mit DFS:

class Graph {
  constructor() {
    this.adjacencyList = {};
  }

  addVertex(vertex) {
    if (!this.adjacencyList[vertex]) this.adjacencyList[vertex] = [];
  }

  addEdge(v1, v2) {
    this.adjacencyList[v1].push(v2);
  }

  topologicalSort() {
    const visited = {};
    const stack = [];

    const dfsHelper = (vertex) => {
      visited[vertex] = true;
      this.adjacencyList[vertex].forEach(neighbor => {
        if (!visited[neighbor]) {
          dfsHelper(neighbor);
        }
      });
      stack.push(vertex);
      console.log(`Added ${vertex} to stack`);
    };

    for (let vertex in this.adjacencyList) {
      if (!visited[vertex]) {
        dfsHelper(vertex);
      }
    }

    return stack.reverse();
  }
}

// Example usage
const graph = new Graph();
['A', 'B', 'C', 'D', 'E', 'F'].forEach(vertex => graph.addVertex(vertex));
graph.addEdge('A', 'C');
graph.addEdge('B', 'C');
graph.addEdge('B', 'D');
graph.addEdge('C', 'E');
graph.addEdge('D', 'F');
graph.addEdge('E', 'F');

console.log(graph.topologicalSort());

Diese Implementierungen bieten eine solide Grundlage für das Verständnis und die Verwendung dieser wichtigen Algorithmen und Datenstrukturen bei der Codierung von Interviews und realen Anwendungen.

Das obige ist der detaillierte Inhalt vonUltimativer Leitfaden zur Problemlösung bei der Codierung von Interviews. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!