JavaScript 数据结构：掌握 Map、Set 和自定义实现，面向全球开发者

            const apiCache = new Map();

async function getProductDetails(productId, region) {
  const cacheKey = `${productId}-${region}`;

  if (apiCache.has(cacheKey)) {
    console.log(`Cache hit for ${cacheKey}`);
    return apiCache.get(cacheKey);
  }

  console.log(`Cache miss for ${cacheKey}. Fetching from API...`);
  // Simulate fetching from a regional API
  const response = await fetch(`https://api.example.com/${region}/products/${productId}`);
  const productData = await response.json();

  // Store in cache for future use
  apiCache.set(cacheKey, productData);

  return productData;
}

// Example usage across different regions:
getProductDetails('XYZ789', 'us-east-1'); // Fetches and caches
getProductDetails('XYZ789', 'eu-west-2'); // Fetches and caches separately
getProductDetails('XYZ789', 'us-east-1'); // Cache hit!

            

              
                Copy
              
            
          

            const userActivityLogs = [
  { userId: 'user123', action: 'login', timestamp: '2023-10-27T10:00:00Z', region: 'Asia' },
  { userId: 'user456', action: 'view', timestamp: '2023-10-27T10:05:00Z', region: 'Europe' },
  { userId: 'user123', action: 'click', timestamp: '2023-10-27T10:06:00Z', region: 'Asia' },
  { userId: 'user789', action: 'login', timestamp: '2023-10-27T10:08:00Z', region: 'North America' },
  { userId: 'user456', action: 'logout', timestamp: '2023-10-27T10:10:00Z', region: 'Europe' },
  { userId: 'user123', action: 'view', timestamp: '2023-10-27T10:12:00Z', region: 'Asia' } // Duplicate user123 action
];

const uniqueUserIds = new Set();

userActivityLogs.forEach(log => {
  uniqueUserIds.add(log.userId);
});

console.log('Unique User IDs:', Array.from(uniqueUserIds)); // Using Array.from to convert Set back to array for display
// Output: Unique User IDs: [ 'user123', 'user456', 'user789' ]

// Another example: Removing duplicates from a list of product IDs
const productIds = ['A101', 'B202', 'A101', 'C303', 'B202', 'D404'];
const uniqueProductIds = new Set(productIds);
console.log('Unique Product IDs:', [...uniqueProductIds]); // Using spread syntax
// Output: Unique Product IDs: [ 'A101', 'B202', 'C303', 'D404' ]

            

              
                Copy
              
            
          

            class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
    this.size = 0;
  }

  // Add node to the end
  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
    this.size++;
  }

  // Remove node by value
  remove(data) {
    if (!this.head) return false;

    if (this.head.data === data) {
      this.head = this.head.next;
      this.size--;
      return true;
    }

    let current = this.head;
    while (current.next) {
      if (current.next.data === data) {
        current.next = current.next.next;
        this.size--;
        return true;
      }
      current = current.next;
    }
    return false;
  }

  // Find node by value
  find(data) {
    let current = this.head;
    while (current) {
      if (current.data === data) {
        return current;
      }
      current = current.next;
    }
    return null;
  }

  // Print list
  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

// Usage:
const myList = new LinkedList();
myList.add('Apple');
myList.add('Banana');
myList.add('Cherry');
myList.print(); // Apple -> Banana -> Cherry -> null
myList.remove('Banana');
myList.print(); // Apple -> Cherry -> null
console.log(myList.find('Apple')); // Node { data: 'Apple', next: Node { data: 'Cherry', next: null } }
console.log('Size:', myList.size); // Size: 2

            

              
                Copy
              
            
          

            class Stack {
  constructor() {
    this.items = [];
  }

  // Add element to the top
  push(element) {
    this.items.push(element);
  }

  // Remove and return the top element
  pop() {
    if (this.isEmpty()) {
      return "Underflow"; // Or throw an error
    }
    return this.items.pop();
  }

  // View the top element without removing
  peek() {
    if (this.isEmpty()) {
      return "No elements in Stack";
    }
    return this.items[this.items.length - 1];
  }

  // Check if stack is empty
  isEmpty() {
    return this.items.length === 0;
  }

  // Get size
  size() {
    return this.items.length;
  }

  // Print stack (top to bottom)
  print() {
    let str = "";
    for (let i = this.items.length - 1; i >= 0; i--) {
      str += this.items[i] + " ";
    }
    console.log(str.trim());
  }
}

// Usage:
const myStack = new Stack();
myStack.push(10);
myStack.push(20);
myStack.push(30);
myStack.print(); // 30 20 10
console.log('Peek:', myStack.peek()); // Peek: 30
console.log('Pop:', myStack.pop());   // Pop: 30
myStack.print(); // 20 10
console.log('Is Empty:', myStack.isEmpty()); // Is Empty: false

            

              
                Copy
              
            
          

            class Queue {
  constructor() {
    this.items = [];
  }

  // Add element to the rear
  enqueue(element) {
    this.items.push(element);
  }

  // Remove and return the front element
  dequeue() {
    if (this.isEmpty()) {
      return "Underflow";
    }
    return this.items.shift(); // O(n) operation in standard arrays
  }

  // View the front element without removing
  front() {
    if (this.isEmpty()) {
      return "No elements in Queue";
    }
    return this.items[0];
  }

  // Check if queue is empty
  isEmpty() {
    return this.items.length === 0;
  }

  // Get size
  size() {
    return this.items.length;
  }

  // Print queue (front to rear)
  print() {
    let str = "";
    for (let i = 0; i < this.items.length; i++) {
      str += this.items[i] + " ";
    }
    console.log(str.trim());
  }
}

// Usage:
const myQueue = new Queue();
myQueue.enqueue('A');
myQueue.enqueue('B');
myQueue.enqueue('C');
myQueue.print(); // A B C
console.log('Front:', myQueue.front()); // Front: A
console.log('Dequeue:', myQueue.dequeue()); // Dequeue: A
myQueue.print(); // B C
console.log('Is Empty:', myQueue.isEmpty()); // Is Empty: false

            

              
                Copy
              
            
          

            class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

class BinarySearchTree {
  constructor() {
    this.root = null;
  }

  // Insert a value into the BST
  insert(value) {
    const newNode = new TreeNode(value);
    if (!this.root) {
      this.root = newNode;
      return this;
    }

    let current = this.root;
    while (true) {
      if (value === current.value) return undefined; // Or handle duplicates as needed

      if (value < current.value) {
        if (!current.left) {
          current.left = newNode;
          return this;
        }
        current = current.left;
      } else {
        if (!current.right) {
          current.right = newNode;
          return this;
        }
        current = current.right;
      }
    }
  }

  // Search for a value in the BST
  search(value) {
    if (!this.root) return null;
    let current = this.root;
    while (current) {
      if (value === current.value) return current;
      if (value < current.value) {
        current = current.left;
      } else {
        current = current.right;
      }
    }
    return null; // Not found
  }

  // In-order traversal (returns sorted list)
  inOrderTraversal(node = this.root, result = []) {
    if (node) {
      this.inOrderTraversal(node.left, result);
      result.push(node.value);
      this.inOrderTraversal(node.right, result);
    }
    return result;
  }
}

// Usage:
const bst = new BinarySearchTree();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(2);
bst.insert(7);
bst.insert(12);
bst.insert(18);

console.log('In-order traversal:', bst.inOrderTraversal()); // [ 2, 5, 7, 10, 12, 15, 18 ]
console.log('Search for 7:', bst.search(7)); // TreeNode { value: 7, left: null, right: null }
console.log('Search for 100:', bst.search(100)); // null

            

              
                Copy
              
            
          

            class Graph {
  constructor() {
    this.adjacencyList = new Map(); // Using Map for better key handling
  }

  // Add a vertex
  addVertex(vertex) {
    if (!this.adjacencyList.has(vertex)) {
      this.adjacencyList.set(vertex, []);
    }
  }

  // Add an edge (for undirected graph)
  addEdge(vertex1, vertex2) {
    if (!this.adjacencyList.has(vertex1) || !this.adjacencyList.has(vertex2)) {
      throw new Error("One or both vertices do not exist.");
    }
    this.adjacencyList.get(vertex1).push(vertex2);
    this.adjacencyList.get(vertex2).push(vertex1); // For undirected graph
  }

  // Remove an edge
  removeEdge(vertex1, vertex2) {
    if (!this.adjacencyList.has(vertex1) || !this.adjacencyList.has(vertex2)) {
      return false;
    }
    this.adjacencyList.set(vertex1, this.adjacencyList.get(vertex1).filter(v => v !== vertex2));
    this.adjacencyList.set(vertex2, this.adjacencyList.get(vertex2).filter(v => v !== vertex1));
    return true;
  }

  // Remove a vertex and all its edges
  removeVertex(vertex) {
    if (!this.adjacencyList.has(vertex)) {
      return false;
    }
    while (this.adjacencyList.get(vertex).length) {
      const adjacentVertex = this.adjacencyList.get(vertex).pop();
      this.removeEdge(vertex, adjacentVertex);
    }
    this.adjacencyList.delete(vertex);
    return true;
  }

  // Basic Depth First Search (DFS) traversal
  dfs(startVertex, visited = new Set(), result = []) {
    if (!this.adjacencyList.has(startVertex)) return null;

    visited.add(startVertex);
    result.push(startVertex);

    this.adjacencyList.get(startVertex).forEach(neighbor => {
      if (!visited.has(neighbor)) {
        this.dfs(neighbor, visited, result);
      }
    });
    return result;
  }
}

// Usage (e.g., representing flight routes between global cities):
const flightNetwork = new Graph();
flightNetwork.addVertex('New York');
flightNetwork.addVertex('London');
flightNetwork.addVertex('Tokyo');
flightNetwork.addVertex('Sydney');
flightNetwork.addVertex('Rio de Janeiro');

flightNetwork.addEdge('New York', 'London');
flightNetwork.addEdge('New York', 'Tokyo');
flightNetwork.addEdge('London', 'Tokyo');
flightNetwork.addEdge('London', 'Rio de Janeiro');
flightNetwork.addEdge('Tokyo', 'Sydney');

console.log('Flight Network DFS from New York:', flightNetwork.dfs('New York'));
// Example Output: [ 'New York', 'London', 'Tokyo', 'Sydney', 'Rio de Janeiro' ] (order may vary based on Set iteration)

// flightNetwork.removeEdge('New York', 'London');
// flightNetwork.removeVertex('Tokyo');

            

              
                Copy