Elysia Tools

在一个清晰的工作台里浏览工具、案例、可视化和主题指南。

热门分类

专题

语言
ZHDERUPTENFRES

Elysia Tools

导航

Python

Web Python 数据结构示例

Web Python 数据结构示例,包括数组操作、哈希表和链表

案例

这个案例集合中的条目

代码python简单

数组操作

执行数组/列表操作,包括增删改查、排序、搜索和转换

难度

4/10

预计时间

30 min

标签

python, web, data structures, arrays

前置条件

Basic Python, Lists

python
# Web Python Array Operations Examples
# Using Python lists for array operations with comprehensive CRUD functionality

# 1. Basic Array/List Operations
from typing import List, Any, Optional, Callable
import bisect

def create_array(elements: List[Any] = None) -> List[Any]:
    """
    Create a new array (list)

    Args:
        elements: Initial elements

    Returns:
        New list
    """
    return elements.copy() if elements else []

def add_element(array: List[Any], element: Any, position: Optional[int] = None) -> List[Any]:
    """
    Add element to array

    Args:
        array: Target array
        element: Element to add
        position: Position to insert (None = append)

    Returns:
        Modified array
    """
    if position is None:
        array.append(element)
    else:
        array.insert(position, element)
    return array

def remove_element(array: List[Any], element: Any) -> bool:
    """
    Remove element from array

    Args:
        array: Target array
        element: Element to remove

    Returns:
        True if removed
    """
    try:
        array.remove(element)
        return True
    except ValueError:
        return False

def remove_at(array: List[Any], index: int) -> Any:
    """
    Remove element at index

    Args:
        array: Target array
        index: Index to remove

    Returns:
        Removed element
    """
    if 0 <= index < len(array):
        return array.pop(index)
    return None

def get_element(array: List[Any], index: int) -> Any:
    """
    Get element at index

    Args:
        array: Target array
        index: Index to get

    Returns:
        Element at index
    """
    return array[index] if 0 <= index < len(array) else None

def update_element(array: List[Any], index: int, new_value: Any) -> bool:
    """
    Update element at index

    Args:
        array: Target array
        index: Index to update
        new_value: New value

    Returns:
        True if updated
    """
    if 0 <= index < len(array):
        array[index] = new_value
        return True
    return False

def find_index(array: List[Any], element: Any) -> int:
    """
    Find index of element

    Args:
        array: Target array
        element: Element to find

    Returns:
        Index or -1 if not found
    """
    try:
        return array.index(element)
    except ValueError:
        return -1

def contains(array: List[Any], element: Any) -> bool:
    """
    Check if array contains element

    Args:
        array: Target array
        element: Element to check

    Returns:
        True if contains
    """
    return element in array

def get_size(array: List[Any]) -> int:
    """
    Get array size

    Args:
        array: Target array

    Returns:
        Array length
    """
    return len(array)

def is_empty(array: List[Any]) -> bool:
    """
    Check if array is empty

    Args:
        array: Target array

    Returns:
        True if empty
    """
    return len(array) == 0

def clear_array(array: List[Any]) -> List[Any]:
    """
    Clear all elements

    Args:
        array: Target array

    Returns:
        Empty array
    """
    array.clear()
    return array

# 2. Sorting Operations
def bubble_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
    """
    Bubble sort algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending

    Returns:
        Sorted array
    """
    arr = array.copy()
    n = len(arr)

    for i in range(n):
        for j in range(0, n - i - 1):
            if key:
                a, b = key(arr[j]), key(arr[j + 1])
            else:
                a, b = arr[j], arr[j + 1]

            if reverse:
                should_swap = a < b
            else:
                should_swap = a > b

            if should_swap:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

    return arr

def quick_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
    """
    Quick sort algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending

    Returns:
        Sorted array
    """
    if len(array) <= 1:
        return array

    pivot = array[len(array) // 2]

    if key:
        pivot_value = key(pivot)
    else:
        pivot_value = pivot

    left = [x for x in array if (key(x) if key else x) < pivot_value]
    middle = [x for x in array if (key(x) if key else x) == pivot_value]
    right = [x for x in array if (key(x) if key else x) > pivot_value]

    if reverse:
        return quick_sort(right, key, reverse) + middle + quick_sort(left, key, reverse)
    else:
        return quick_sort(left, key, reverse) + middle + quick_sort(right, key, reverse)

def merge_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
    """
    Merge sort algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending

    Returns:
        Sorted array
    """
    if len(array) <= 1:
        return array

    mid = len(array) // 2
    left = merge_sort(array[:mid], key, reverse)
    right = merge_sort(array[mid:], key, reverse)

    return merge(left, right, key, reverse)

def merge(left: List[Any], right: List[Any], key: Optional[Callable], reverse: bool) -> List[Any]:
    """Merge two sorted arrays"""
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        left_val = key(left[i]) if key else left[i]
        right_val = key(right[j]) if key else right[j]

        if reverse:
            condition = left_val >= right_val
        else:
            condition = left_val <= right_val

        if condition:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

def sort_array(array: List[Any], key: Optional[Callable] = None, reverse: bool = False, algorithm: str = 'builtin') -> List[Any]:
    """
    Sort array using specified algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending
        algorithm: 'builtin', 'bubble', 'quick', 'merge'

    Returns:
        Sorted array
    """
    if algorithm == 'bubble':
        return bubble_sort(array, key, reverse)
    elif algorithm == 'quick':
        return quick_sort(array, key, reverse)
    elif algorithm == 'merge':
        return merge_sort(array, key, reverse)
    else:
        return sorted(array, key=key, reverse=reverse)

# 3. Searching Operations
def linear_search(array: List[Any], target: Any, key: Optional[Callable] = None) -> int:
    """
    Linear search

    Args:
        array: Array to search
        target: Target value
        key: Key function for comparison

    Returns:
        Index or -1 if not found
    """
    for i, element in enumerate(array):
        value = key(element) if key else element
        if value == target:
            return i
    return -1

def binary_search(array: List[Any], target: Any, key: Optional[Callable] = None) -> int:
    """
    Binary search (requires sorted array)

    Args:
        array: Sorted array to search
        target: Target value
        key: Key function for comparison

    Returns:
        Index or -1 if not found
    """
    left, right = 0, len(array) - 1

    while left <= right:
        mid = (left + right) // 2
        mid_value = key(array[mid]) if key else array[mid]

        if mid_value == target:
            return mid
        elif mid_value < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1

def find_all(array: List[Any], target: Any, key: Optional[Callable] = None) -> List[int]:
    """
    Find all occurrences

    Args:
        array: Array to search
        target: Target value
        key: Key function for comparison

    Returns:
        List of indices
    """
    indices = []
    for i, element in enumerate(array):
        value = key(element) if key else element
        if value == target:
            indices.append(i)
    return indices

def find_min(array: List[Any], key: Optional[Callable] = None) -> Any:
    """
    Find minimum element

    Args:
        array: Array to search
        key: Key function for comparison

    Returns:
        Minimum element
    """
    if not array:
        return None
    return min(array, key=key) if key else min(array)

def find_max(array: List[Any], key: Optional[Callable] = None) -> Any:
    """
    Find maximum element

    Args:
        array: Array to search
        key: Key function for comparison

    Returns:
        Maximum element
    """
    if not array:
        return None
    return max(array, key=key) if key else max(array)

# 4. Transformation Operations
def map_array(array: List[Any], func: Callable[[Any], Any]) -> List[Any]:
    """
    Apply function to all elements

    Args:
        array: Source array
        func: Transform function

    Returns:
        New array
    """
    return [func(x) for x in array]

def filter_array(array: List[Any], predicate: Callable[[Any], bool]) -> List[Any]:
    """
    Filter elements by predicate

    Args:
        array: Source array
        predicate: Filter function

    Returns:
        Filtered array
    """
    return [x for x in array if predicate(x)]

def reduce_array(array: List[Any], func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
    """
    Reduce array to single value

    Args:
        array: Source array
        func: Reduce function
        initial: Initial value

    Returns:
        Reduced value
    """
    if initial is not None:
        result = initial
        for x in array:
            result = func(result, x)
    else:
        result = array[0]
        for x in array[1:]:
            result = func(result, x)
    return result

def flatten_array(array: List[Any]) -> List[Any]:
    """
    Flatten nested array

    Args:
        array: Nested array

    Returns:
        Flattened array
    """
    result = []
    for element in array:
        if isinstance(element, list):
            result.extend(flatten_array(element))
        else:
            result.append(element)
    return result

def chunk_array(array: List[Any], size: int) -> List[List[Any]]:
    """
    Split array into chunks

    Args:
        array: Source array
        size: Chunk size

    Returns:
        List of chunks
    """
    return [array[i:i + size] for i in range(0, len(array), size)]

# 5. Advanced Operations
def rotate_array(array: List[Any], positions: int) -> List[Any]:
    """
    Rotate array

    Args:
        array: Source array
        positions: Positions to rotate (positive = right)

    Returns:
        Rotated array
    """
    if not array:
        return array

    positions = positions % len(array)
    return array[-positions:] + array[:-positions]

def reverse_array(array: List[Any]) -> List[Any]:
    """
    Reverse array

    Args:
        array: Source array

    Returns:
        Reversed array
    """
    return array[::-1]

def shuffle_array(array: List[Any]) -> List[Any]:
    """
    Shuffle array randomly

    Args:
        array: Source array

    Returns:
        Shuffled array
    """
    import random
    result = array.copy()
    random.shuffle(result)
    return result

def unique_array(array: List[Any], key: Optional[Callable] = None) -> List[Any]:
    """
    Get unique elements

    Args:
        array: Source array
        key: Key function for uniqueness

    Returns:
        Unique elements
    """
    if key:
        seen = set()
        result = []
        for item in array:
            k = key(item)
            if k not in seen:
                seen.add(k)
                result.append(item)
        return result
    else:
        return list(dict.fromkeys(array))

def intersect_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
    """
    Find intersection of two arrays

    Args:
        arr1: First array
        arr2: Second array

    Returns:
        Intersection
    """
    return list(set(arr1) & set(arr2))

def union_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
    """
    Find union of two arrays

    Args:
        arr1: First array
        arr2: Second array

    Returns:
        Union
    """
    return list(set(arr1) | set(arr2))

def difference_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
    """
    Find difference of two arrays

    Args:
        arr1: First array
        arr2: Second array

    Returns:
        Difference
    """
    return list(set(arr1) - set(arr2))

# 6. Statistical Operations
def sum_array(array: List[float]) -> float:
    """Calculate sum of array"""
    return sum(array)

def mean_array(array: List[float]) -> float:
    """Calculate mean of array"""
    return sum(array) / len(array) if array else 0

def median_array(array: List[float]) -> float:
    """Calculate median of array"""
    if not array:
        return 0

    sorted_arr = sorted(array)
    n = len(sorted_arr)
    mid = n // 2

    if n % 2 == 0:
        return (sorted_arr[mid - 1] + sorted_arr[mid]) / 2
    else:
        return sorted_arr[mid]

def mode_array(array: List[Any]) -> Any:
    """Calculate mode of array"""
    from collections import Counter
    if not array:
        return None

    counter = Counter(array)
    return counter.most_common(1)[0][0]

def std_deviation(array: List[float]) -> float:
    """Calculate standard deviation"""
    import math
    if len(array) < 2:
        return 0

    mean = mean_array(array)
    variance = sum((x - mean) ** 2 for x in array) / len(array)
    return math.sqrt(variance)

# Usage Examples
def demonstrate_array_operations():
    print("=== Web Python Array Operations Examples ===\n")

    # 1. Basic operations
    print("--- 1. Basic Operations ---")
    arr = create_array([3, 1, 4, 1, 5])
    print(f"Created: {arr}")
    add_element(arr, 9)
    print(f"After append: {arr}")
    add_element(arr, 2, position=0)
    print(f"After insert at 0: {arr}")
    print(f"Size: {get_size(arr)}")

    # 2. Sorting
    print("\n--- 2. Sorting ---")
    unsorted = [64, 34, 25, 12, 22, 11, 90]
    print(f"Original: {unsorted}")
    print(f"Bubble sort: {bubble_sort(unsorted.copy())}")
    print(f"Quick sort: {quick_sort(unsorted.copy())}")
    print(f"Builtin sort: {sort_array(unsorted.copy())}")

    # 3. Searching
    print("\n--- 3. Searching ---")
    data = [1, 3, 5, 7, 9, 11, 13]
    print(f"Array: {data}")
    print(f"Linear search for 7: {linear_search(data, 7)}")
    print(f"Binary search for 7: {binary_search(data, 7)}")
    print(f"Find all 1s: {find_all([1, 2, 1, 3, 1], 1)}")

    # 4. Transformations
    print("\n--- 4. Transformations ---")
    numbers = [1, 2, 3, 4, 5]
    print(f"Original: {numbers}")
    print(f"Map (x^2): {map_array(numbers, lambda x: x ** 2)}")
    print(f"Filter (even): {filter_array(numbers, lambda x: x % 2 == 0)}")
    print(f"Reduce (sum): {reduce_array(numbers, lambda a, b: a + b, 0)}")
    print(f"Flatten: {flatten_array([1, [2, 3], [4, [5]]])}")

    # 5. Advanced operations
    print("\n--- 5. Advanced Operations ---")
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(f"Original: {data}")
    print(f"Rotate 3: {rotate_array(data, 3)}")
    print(f"Reverse: {reverse_array(data)}")
    print(f"Unique: {unique_array([1, 2, 2, 3, 3, 3, 4])}")
    print(f"Chunk size 3: {chunk_array(data, 3)}")

    # 6. Statistical
    print("\n--- 6. Statistical Operations ---")
    numbers = [2, 4, 4, 4, 5, 5, 7, 9]
    print(f"Data: {numbers}")
    print(f"Sum: {sum_array(numbers)}")
    print(f"Mean: {mean_array(numbers):.2f}")
    print(f"Median: {median_array(numbers)}")
    print(f"Mode: {mode_array(numbers)}")
    print(f"Std deviation: {std_deviation(numbers):.2f}")

    print("\n=== All Array Operations Examples Completed ===")

# Export functions
# export { create_array, add_element, remove_element, remove_at, get_element, update_element }
# export { find_index, contains, get_size, is_empty, clear_array }
# export { bubble_sort, quick_sort, merge_sort, sort_array }
# export { linear_search, binary_search, find_all, find_min, find_max }
# export { map_array, filter_array, reduce_array, flatten_array, chunk_array }
# export { rotate_array, reverse_array, shuffle_array, unique_array }
# export { intersect_arrays, union_arrays, difference_arrays }
# export { sum_array, mean_array, median_array, mode_array, std_deviation }
# export { demonstrate_array_operations }
代码python中等

哈希表

实现和使用哈希表(字典)进行键值存储和查找操作

难度

5/10

预计时间

25 min

标签

python, web, data structures, hash table

前置条件

Intermediate Python, Dictionaries

python
# Web Python Hash Table Examples
# Using Python dictionaries for key-value storage and efficient lookups

# 1. Basic Dictionary Operations
from typing import Any, Dict, List, Optional, Callable

def create_hash_table(elements: Dict[Any, Any] = None) -> Dict[Any, Any]:
    """
    Create a new hash table (dictionary)

    Args:
        elements: Initial key-value pairs

    Returns:
        New dictionary
    """
    return elements.copy() if elements else {}

def put(ht: Dict[Any, Any], key: Any, value: Any) -> None:
    """
    Add or update key-value pair

    Args:
        ht: Hash table
        key: Key
        value: Value
    """
    ht[key] = value

def get(ht: Dict[Any, Any], key: Any, default: Any = None) -> Any:
    """
    Get value by key

    Args:
        ht: Hash table
        key: Key to lookup
        default: Default value if key not found

    Returns:
        Value or default
    """
    return ht.get(key, default)

def remove(ht: Dict[Any, Any], key: Any) -> bool:
    """
    Remove key-value pair

    Args:
        ht: Hash table
        key: Key to remove

    Returns:
        True if removed
    """
    if key in ht:
        del ht[key]
        return True
    return False

def contains_key(ht: Dict[Any, Any], key: Any) -> bool:
    """
    Check if key exists

    Args:
        ht: Hash table
        key: Key to check

    Returns:
        True if key exists
    """
    return key in ht

def contains_value(ht: Dict[Any, Any], value: Any) -> bool:
    """
    Check if value exists

    Args:
        ht: Hash table
        value: Value to check

    Returns:
        True if value exists
    """
    return value in ht.values()

def get_size(ht: Dict[Any, Any]) -> int:
    """
    Get hash table size

    Args:
        ht: Hash table

    Returns:
        Number of key-value pairs
    """
    return len(ht)

def is_empty(ht: Dict[Any, Any]) -> bool:
    """
    Check if hash table is empty

    Args:
        ht: Hash table

    Returns:
        True if empty
    """
    return len(ht) == 0

def clear_hash_table(ht: Dict[Any, Any]) -> None:
    """
    Clear all entries

    Args:
        ht: Hash table
    """
    ht.clear()

def get_keys(ht: Dict[Any, Any]) -> List[Any]:
    """
    Get all keys

    Args:
        ht: Hash table

    Returns:
        List of keys
    """
    return list(ht.keys())

def get_values(ht: Dict[Any, Any]) -> List[Any]:
    """
    Get all values

    Args:
        ht: Hash table

    Returns:
        List of values
    """
    return list(ht.values())

def get_items(ht: Dict[Any, Any]) -> List[tuple]:
    """
    Get all key-value pairs

    Args:
        ht: Hash table

    Returns:
        List of tuples
    """
    return list(ht.items())

# 2. Advanced Operations
def update_hash_table(ht: Dict[Any, Any], other: Dict[Any, Any]) -> None:
    """
    Update with another dictionary

    Args:
        ht: Target hash table
        other: Source dictionary
    """
    ht.update(other)

def merge_hash_tables(ht1: Dict[Any, Any], ht2: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Merge two hash tables

    Args:
        ht1: First hash table
        ht2: Second hash table

    Returns:
        Merged hash table
    """
    result = ht1.copy()
    result.update(ht2)
    return result

def set_default(ht: Dict[Any, Any], key: Any, default: Any) -> Any:
    """
    Set default value if key doesn't exist

    Args:
        ht: Hash table
        key: Key
        default: Default value

    Returns:
        Value (existing or default)
    """
    return ht.setdefault(key, default)

def pop_value(ht: Dict[Any, Any], key: Any, default: Any = None) -> Any:
    """
    Remove and return value

    Args:
        ht: Hash table
        key: Key
        default: Default if key not found

    Returns:
        Removed value or default
    """
    return ht.pop(key, default)

def pop_item(ht: Dict[Any, Any]) -> tuple:
    """
    Remove and return arbitrary item

    Args:
        ht: Hash table

    Returns:
        (key, value) tuple
    """
    return ht.popitem()

# 3. Dictionary Comprehensions
def create_from_keys(keys: List[Any], value: Any) -> Dict[Any, Any]:
    """
    Create dict from keys with same value

    Args:
        keys: List of keys
        value: Value for all keys

    Returns:
        Dictionary
    """
    return {key: value for key in keys}

def create_from_mapping(keys: List[Any], func: Callable[[Any], Any]) -> Dict[Any, Any]:
    """
    Create dict by mapping keys through function

    Args:
        keys: List of keys
        func: Function to generate values

    Returns:
        Dictionary
    """
    return {key: func(key) for key in keys}

def filter_hash_table(ht: Dict[Any, Any], predicate: Callable[[tuple], bool]) -> Dict[Any, Any]:
    """
    Filter entries by predicate

    Args:
        ht: Hash table
        predicate: Filter function

    Returns:
        Filtered dictionary
    """
    return {k: v for k, v in ht.items() if predicate((k, v))}

def invert_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Invert key-value pairs

    Args:
        ht: Hash table

    Returns:
        Inverted dictionary
    """
    return {v: k for k, v in ht.items()}

# 4. Sorting Operations
def sort_by_keys(ht: Dict[Any, Any], reverse: bool = False) -> List[tuple]:
    """
    Sort entries by keys

    Args:
        ht: Hash table
        reverse: Sort descending

    Returns:
        Sorted list of tuples
    """
    return sorted(ht.items(), key=lambda x: x[0], reverse=reverse)

def sort_by_values(ht: Dict[Any, Any], reverse: bool = False) -> List[tuple]:
    """
    Sort entries by values

    Args:
        ht: Hash table
        reverse: Sort descending

    Returns:
        Sorted list of tuples
    """
    return sorted(ht.items(), key=lambda x: x[1], reverse=reverse)

def get_sorted_keys(ht: Dict[Any, Any], reverse: bool = False) -> List[Any]:
    """Get sorted keys"""
    return sorted(ht.keys(), reverse=reverse)

def get_sorted_values(ht: Dict[Any, Any], reverse: bool = False) -> List[Any]:
    """Get sorted values"""
    return sorted(ht.values(), reverse=reverse)

# 5. Lookup Operations
def find_keys_by_value(ht: Dict[Any, Any], value: Any) -> List[Any]:
    """
    Find all keys with given value

    Args:
        ht: Hash table
        value: Value to search

    Returns:
        List of keys
    """
    return [k for k, v in ht.items() if v == value]

def find_max_value(ht: Dict[Any, Any]) -> tuple:
    """
    Find entry with maximum value

    Args:
        ht: Hash table

    Returns:
        (key, value) tuple
    """
    return max(ht.items(), key=lambda x: x[1])

def find_min_value(ht: Dict[Any, Any]) -> tuple:
    """
    Find entry with minimum value

    Args:
        ht: Hash table

    Returns:
        (key, value) tuple
    """
    return min(ht.items(), key=lambda x: x[1])

# 6. Hash Table Utilities
def copy_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Create shallow copy

    Args:
        ht: Hash table

    Returns:
        Copy
    """
    return ht.copy()

def deep_copy_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Create deep copy

    Args:
        ht: Hash table

    Returns:
        Deep copy
    """
    import copy
    return copy.deepcopy(ht)

def to_string(ht: Dict[Any, Any], indent: int = 0) -> str:
    """
    Convert to formatted string

    Args:
        ht: Hash table
        indent: Indentation level

    Returns:
        Formatted string
    """
    import json
    return json.dumps(ht, indent=indent, default=str)

def from_tuples(items: List[tuple]) -> Dict[Any, Any]:
    """
    Create dict from list of tuples

    Args:
        items: List of (key, value) tuples

    Returns:
        Dictionary
    """
    return dict(items)

def from_lists(keys: List[Any], values: List[Any]) -> Dict[Any, Any]:
    """
    Create dict from two lists

    Args:
        keys: List of keys
        values: List of values

    Returns:
        Dictionary
    """
    return dict(zip(keys, values))

# 7. Specialized Hash Tables
def create_counter(items: List[Any]) -> Dict[Any, int]:
    """
    Count occurrences

    Args:
        items: List of items

    Returns:
        Dictionary with counts
    """
    counter = {}
    for item in items:
        counter[item] = counter.get(item, 0) + 1
    return counter

def create_index(items: List[Any], key_func: Callable[[Any], Any]) -> Dict[Any, List[Any]]:
    """
    Create index by key function

    Args:
        items: List of items
        key_func: Function to extract key

    Returns:
        Dictionary mapping keys to lists of items
    """
    index = {}
    for item in items:
        key = key_func(item)
        if key not in index:
            index[key] = []
        index[key].append(item)
    return index

def group_by(items: List[Any], key_func: Callable[[Any], Any]) -> Dict[Any, List[Any]]:
    """
    Group items by key function

    Args:
        items: List of items
        key_func: Function to extract key

    Returns:
        Grouped dictionary
    """
    groups = {}
    for item in items:
        key = key_func(item)
        if key not in groups:
            groups[key] = []
        groups[key].append(item)
    return groups

# 8. Nested Dictionary Operations
def get_nested(ht: Dict[Any, Any], *keys, default: Any = None) -> Any:
    """
    Get value from nested dictionary

    Args:
        ht: Hash table
        *keys: Keys for nested access
        default: Default value

    Returns:
        Nested value or default
    """
    current = ht
    for key in keys:
        if isinstance(current, dict) and key in current:
            current = current[key]
        else:
            return default
    return current

def set_nested(ht: Dict[Any, Any], *keys, value: Any) -> None:
    """
    Set value in nested dictionary

    Args:
        ht: Hash table
        *keys: Keys for nested access
        value: Value to set
    """
    current = ht
    for key in keys[:-1]:
        if key not in current:
            current[key] = {}
        current = current[key]
    current[keys[-1]] = value

def flatten_nested_dict(ht: Dict[Any, Any], parent_key: str = '', sep: str = '.') -> Dict[Any, Any]:
    """
    Flatten nested dictionary

    Args:
        ht: Hash table
        parent_key: Parent key prefix
        sep: Separator for keys

    Returns:
        Flattened dictionary
    """
    items = []
    for k, v in ht.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_nested_dict(v, new_key, sep=sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

# Usage Examples
def demonstrate_hash_table():
    print("=== Web Python Hash Table Examples ===\n")

    # 1. Basic operations
    print("--- 1. Basic Operations ---")
    ht = create_hash_table({'name': 'Alice', 'age': 30})
    print(f"Created: {ht}")
    put(ht, 'city', 'NYC')
    print(f"After put: {ht}")
    print(f"Get name: {get(ht, 'name')}")
    print(f"Contains 'age': {contains_key(ht, 'age')}")
    print(f"Keys: {get_keys(ht)}")
    print(f"Values: {get_values(ht)}")
    print(f"Size: {get_size(ht)}")

    # 2. Advanced operations
    print("\n--- 2. Advanced Operations ---")
    ht1 = {'a': 1, 'b': 2}
    ht2 = {'c': 3, 'd': 4}
    merged = merge_hash_tables(ht1, ht2)
    print(f"Merged: {merged}")
    set_default(ht1, 'e', 5)
    print(f"Set default: {ht1}")
    inverted = invert_hash_table({'a': 1, 'b': 2, 'c': 3})
    print(f"Inverted: {inverted}")

    # 3. Sorting
    print("\n--- 3. Sorting ---")
    data = {'apple': 5, 'banana': 2, 'cherry': 8, 'date': 1}
    print(f"Original: {data}")
    print(f"Sort by keys: {sort_by_keys(data)}")
    print(f"Sort by values: {sort_by_values(data)}")
    print(f"Max value: {find_max_value(data)}")
    print(f"Min value: {find_min_value(data)}")

    # 4. Lookup operations
    print("\n--- 4. Lookup Operations ---")
    scores = {'Alice': 95, 'Bob': 87, 'Charlie': 95, 'David': 92}
    print(f"Scores: {scores}")
    print(f"Keys with value 95: {find_keys_by_value(scores, 95)}")

    # 5. Specialized dictionaries
    print("\n--- 5. Specialized Dictionaries ---")
    items = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
    counter = create_counter(items)
    print(f"Counter: {counter}")

    data = [
        {'name': 'Alice', 'dept': 'IT'},
        {'name': 'Bob', 'dept': 'HR'},
        {'name': 'Charlie', 'dept': 'IT'}
    ]
    grouped = group_by(data, lambda x: x['dept'])
    print(f"Grouped by dept: {grouped}")

    # 6. Nested dictionaries
    print("\n--- 6. Nested Dictionaries ---")
    nested = {
        'user': {
            'name': 'Alice',
            'address': {
                'city': 'NYC',
                'zip': '10001'
            }
        }
    }
    print(f"Nested: {nested}")
    print(f"Get nested: {get_nested(nested, 'user', 'address', 'city')}")
    set_nested(nested, 'user', 'address', 'zip', value='10002')
    print(f"After set: {nested}")
    print(f"Flattened: {flatten_nested_dict(nested)}")

    print("\n=== All Hash Table Examples Completed ===")

# Export functions
# export { create_hash_table, put, get, remove, contains_key, contains_value }
# export { get_size, is_empty, clear_hash_table, get_keys, get_values, get_items }
# export { update_hash_table, merge_hash_tables, set_default, pop_value, pop_item }
# export { create_from_keys, create_from_mapping, filter_hash_table, invert_hash_table }
# export { sort_by_keys, sort_by_values, get_sorted_keys, get_sorted_values }
# export { find_keys_by_value, find_max_value, find_min_value }
# export { copy_hash_table, deep_copy_hash_table, to_string, from_tuples, from_lists }
# export { create_counter, create_index, group_by }
# export { get_nested, set_nested, flatten_nested_dict }
# export { demonstrate_hash_table }
代码python复杂

链表

实现和使用单链表,支持插入、删除、遍历和反转操作

难度

7/10

预计时间

35 min

标签

python, web, data structures, linked list

前置条件

Advanced Python, Classes, Pointers

python
# Web Python Linked List Examples
# Implementation of singly linked list with comprehensive operations

# 1. Node Class
class Node:
    """Linked list node"""

    def __init__(self, data: Any = None):
        self.data = data
        self.next: Optional['Node'] = None

    def __repr__(self):
        return f"Node({self.data})"

# 2. Linked List Class
class LinkedList:
    """Singly linked list implementation"""

    def __init__(self):
        self.head: Optional[Node] = None
        self.size = 0

    def __repr__(self):
        values = []
        current = self.head
        while current:
            values.append(str(current.data))
            current = current.next
        return " -> ".join(values) if values else "Empty List"

    def __len__(self):
        return self.size

    def __iter__(self):
        current = self.head
        while current:
            yield current.data
            current = current.next

    # 3. Insertion Operations
    def append(self, data: Any) -> None:
        """
        Append element to end

        Args:
            data: Data to append
        """
        new_node = Node(data)
        if not self.head:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
        self.size += 1

    def prepend(self, data: Any) -> None:
        """
        Add element to beginning

        Args:
            data: Data to prepend
        """
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node
        self.size += 1

    def insert_at(self, index: int, data: Any) -> bool:
        """
        Insert element at index

        Args:
            index: Insertion index
            data: Data to insert

        Returns:
            True if successful
        """
        if index < 0 or index > self.size:
            return False

        if index == 0:
            self.prepend(data)
            return True

        new_node = Node(data)
        current = self.head
        for _ in range(index - 1):
            current = current.next

        new_node.next = current.next
        current.next = new_node
        self.size += 1
        return True

    def insert_after(self, target_data: Any, new_data: Any) -> bool:
        """
        Insert after target element

        Args:
            target_data: Target element data
            new_data: New element data

        Returns:
            True if successful
        """
        current = self.head
        while current:
            if current.data == target_data:
                new_node = Node(new_data)
                new_node.next = current.next
                current.next = new_node
                self.size += 1
                return True
            current = current.next
        return False

    def insert_before(self, target_data: Any, new_data: Any) -> bool:
        """
        Insert before target element

        Args:
            target_data: Target element data
            new_data: New element data

        Returns:
            True if successful
        """
        if not self.head:
            return False

        if self.head.data == target_data:
            self.prepend(new_data)
            return True

        current = self.head
        while current.next:
            if current.next.data == target_data:
                new_node = Node(new_data)
                new_node.next = current.next
                current.next = new_node
                self.size += 1
                return True
            current = current.next
        return False

    # 4. Deletion Operations
    def delete(self, data: Any) -> bool:
        """
        Delete first occurrence of data

        Args:
            data: Data to delete

        Returns:
            True if deleted
        """
        if not self.head:
            return False

        if self.head.data == data:
            self.head = self.head.next
            self.size -= 1
            return True

        current = self.head
        while current.next:
            if current.next.data == data:
                current.next = current.next.next
                self.size -= 1
                return True
            current = current.next
        return False

    def delete_at(self, index: int) -> bool:
        """
        Delete element at index

        Args:
            index: Index to delete

        Returns:
            True if deleted
        """
        if index < 0 or index >= self.size:
            return False

        if index == 0:
            self.head = self.head.next
            self.size -= 1
            return True

        current = self.head
        for _ in range(index - 1):
            current = current.next

        current.next = current.next.next
        self.size -= 1
        return True

    def delete_head(self) -> bool:
        """
        Delete head element

        Returns:
            True if deleted
        """
        if not self.head:
            return False
        self.head = self.head.next
        self.size -= 1
        return True

    def delete_tail(self) -> bool:
        """
        Delete tail element

        Returns:
            True if deleted
        """
        if not self.head:
            return False

        if not self.head.next:
            self.head = None
        else:
            current = self.head
            while current.next.next:
                current = current.next
            current.next = None
        self.size -= 1
        return True

    # 5. Search Operations
    def find(self, data: Any) -> Optional[Node]:
        """
        Find node containing data

        Args:
            data: Data to find

        Returns:
            Node or None
        """
        current = self.head
        while current:
            if current.data == data:
                return current
            current = current.next
        return None

    def contains(self, data: Any) -> bool:
        """
        Check if data exists

        Args:
            data: Data to check

        Returns:
            True if exists
        """
        return self.find(data) is not None

    def index_of(self, data: Any) -> int:
        """
        Get index of data

        Args:
            data: Data to find

        Returns:
            Index or -1
        """
        current = self.head
        index = 0
        while current:
            if current.data == data:
                return index
            current = current.next
            index += 1
        return -1

    def get_at(self, index: int) -> Optional[Any]:
        """
        Get data at index

        Args:
            index: Index

        Returns:
            Data or None
        """
        if index < 0 or index >= self.size:
            return None

        current = self.head
        for _ in range(index):
            current = current.next
        return current.data

    # 6. Traversal Operations
    def to_list(self) -> list:
        """
        Convert to Python list

        Returns:
            List of data
        """
        result = []
        current = self.head
        while current:
            result.append(current.data)
            current = current.next
        return result

    def traverse(self, func: callable) -> None:
        """
        Apply function to each element

        Args:
            func: Function to apply
        """
        current = self.head
        while current:
            func(current.data)
            current = current.next

    def print_list(self) -> None:
        """Print linked list"""
        print(self)

    # 7. Update Operations
    def update(self, index: int, new_data: Any) -> bool:
        """
        Update data at index

        Args:
            index: Index
            new_data: New data

        Returns:
            True if updated
        """
        if index < 0 or index >= self.size:
            return False

        current = self.head
        for _ in range(index):
            current = current.next
        current.data = new_data
        return True

    # 8. Utility Operations
    def is_empty(self) -> bool:
        """
        Check if list is empty

        Returns:
            True if empty
        """
        return self.head is None

    def clear(self) -> None:
        """Clear all elements"""
        self.head = None
        self.size = 0

    def reverse(self) -> None:
        """Reverse the linked list"""
        prev = None
        current = self.head

        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node

        self.head = prev

    def get_length(self) -> int:
        """
        Get length of list

        Returns:
            Length
        """
        return self.size

    def copy(self) -> 'LinkedList':
        """
        Create shallow copy

        Returns:
            New linked list
        """
        new_list = LinkedList()
        current = self.head
        while current:
            new_list.append(current.data)
            current = current.next
        return new_list

    # 9. Advanced Operations
    def count(self, data: Any) -> int:
        """
        Count occurrences of data

        Args:
            data: Data to count

        Returns:
            Count
        """
        count = 0
        current = self.head
        while current:
            if current.data == data:
                count += 1
            current = current.next
        return count

    def remove_duplicates(self) -> None:
        """Remove duplicate elements"""
        seen = set()
        current = self.head
        prev = None

        while current:
            if current.data in seen:
                prev.next = current.next
                self.size -= 1
            else:
                seen.add(current.data)
                prev = current
            current = current.next

    def sort(self, reverse: bool = False) -> None:
        """
        Sort the linked list

        Args:
            reverse: Sort descending
        """
        # Convert to list, sort, and rebuild
        data_list = self.to_list()
        data_list.sort(reverse=reverse)

        self.clear()
        for item in data_list:
            self.append(item)

    def find_middle(self) -> Optional[Any]:
        """
        Find middle element

        Returns:
            Middle data or None
        """
        if not self.head:
            return None

        slow = self.head
        fast = self.head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

        return slow.data

    def has_cycle(self) -> bool:
        """
        Detect cycle using Floyd's algorithm

        Returns:
            True if cycle exists
        """
        if not self.head:
            return False

        slow = self.head
        fast = self.head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

            if slow == fast:
                return True

        return False

    # 10. Static Creation Methods
    @classmethod
    def from_list(cls, data_list: list) -> 'LinkedList':
        """
        Create linked list from Python list

        Args:
            data_list: List of data

        Returns:
            New linked list
        """
        linked_list = cls()
        for item in data_list:
            linked_list.append(item)
        return linked_list

# 11. Utility Functions
def merge_sorted_lists(list1: LinkedList, list2: LinkedList) -> LinkedList:
    """
    Merge two sorted linked lists

    Args:
        list1: First sorted list
        list2: Second sorted list

    Returns:
        Merged sorted list
    """
    merged = LinkedList()
    current1 = list1.head
    current2 = list2.head

    while current1 and current2:
        if current1.data <= current2.data:
            merged.append(current1.data)
            current1 = current1.next
        else:
            merged.append(current2.data)
            current2 = current2.next

    while current1:
        merged.append(current1.data)
        current1 = current1.next

    while current2:
        merged.append(current2.data)
        current2 = current2.next

    return merged

def detect_intersection(list1: LinkedList, list2: LinkedList) -> Optional[Any]:
    """
    Detect intersection point of two lists

    Args:
        list1: First list
        list2: Second list

    Returns:
        Intersection data or None
    """
    # Get lengths
    len1, len2 = len(list1), len(list2)

    # Find starting points
    current1 = list1.head
    current2 = list2.head

    # Advance longer list
    for _ in range(abs(len1 - len2)):
        if len1 > len2:
            current1 = current1.next
        else:
            current2 = current2.next

    # Move both until intersection
    while current1 and current2:
        if current1 == current2:
            return current1.data
        current1 = current1.next
        current2 = current2.next

    return None

# Usage Examples
def demonstrate_linked_list():
    print("=== Web Python Linked List Examples ===\n")

    # 1. Basic operations
    print("--- 1. Basic Operations ---")
    ll = LinkedList()
    ll.append(1)
    ll.append(2)
    ll.append(3)
    print(f"After append: {ll}")
    ll.prepend(0)
    print(f"After prepend: {ll}")
    print(f"Length: {ll.get_length()}")
    print(f"Is empty: {ll.is_empty()}")

    # 2. Insertion
    print("\n--- 2. Insertion ---")
    ll.insert_at(2, 1.5)
    print(f"After insert at 2: {ll}")
    ll.insert_after(2, 2.5)
    print(f"After insert after 2: {ll}")

    # 3. Deletion
    print("\n--- 3. Deletion ---")
    ll.delete(1.5)
    print(f"After delete 1.5: {ll}")
    ll.delete_at(0)
    print(f"After delete at 0: {ll}")
    ll.delete_head()
    print(f"After delete head: {ll}")

    # 4. Search
    print("\n--- 4. Search ---")
    ll = LinkedList.from_list([10, 20, 30, 40, 50])
    print(f"List: {ll}")
    print(f"Contains 30: {ll.contains(30)}")
    print(f"Index of 30: {ll.index_of(30)}")
    print(f"Get at 2: {ll.get_at(2)}")
    print(f"Find middle: {ll.find_middle()}")

    # 5. Traversal
    print("\n--- 5. Traversal ---")
    print("Traverse with print:")
    ll.traverse(lambda x: print(f"  Item: {x}"))
    print(f"To list: {ll.to_list()}")

    # 6. Update
    print("\n--- 6. Update ---")
    ll.update(2, 35)
    print(f"After update index 2: {ll}")

    # 7. Advanced operations
    print("\n--- 7. Advanced Operations ---")
    ll = LinkedList.from_list([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
    print(f"Original: {ll}")
    print(f"Count of 5: {ll.count(5)}")
    ll.remove_duplicates()
    print(f"After remove duplicates: {ll}")
    ll.reverse()
    print(f"After reverse: {ll}")
    ll.sort()
    print(f"After sort: {ll}")

    # 8. Merge
    print("\n--- 8. Merge Sorted Lists ---")
    list1 = LinkedList.from_list([1, 3, 5, 7])
    list2 = LinkedList.from_list([2, 4, 6, 8])
    print(f"List1: {list1}")
    print(f"List2: {list2}")
    merged = merge_sorted_lists(list1, list2)
    print(f"Merged: {merged}")

    # 9. Create from list
    print("\n--- 9. Create From List ---")
    data = [100, 200, 300, 400]
    ll_from_list = LinkedList.from_list(data)
    print(f"From list {data}: {ll_from_list}")

    # 10. Cycle detection
    print("\n--- 10. Cycle Detection ---")
    ll = LinkedList.from_list([1, 2, 3, 4])
    print(f"List: {ll}")
    print(f"Has cycle: {ll.has_cycle()}")

    print("\n=== All Linked List Examples Completed ===")

# Export classes and functions
# export { Node, LinkedList }
# export { merge_sorted_lists, detect_intersection, demonstrate_linked_list }

工具

经常与该案例搭配使用的工具

相关内容

相关案例集合

相关内容

相关专题

专题

数据库 Schema 迁移

通过规范化源数据、审阅结构差异、校验关系并准备回滚资产,规划更安全的数据库迁移。

专题

修复被数据库拒绝的 CSV 导入并完成入库

定位 CSV 导入反复失败的结构原因,把混乱表头对齐到目标表结构,按声明的策略清除重复行,最终产出带类型的 INSERT 语句或供批量装载的 TSV。

专题

图表与图示生成器

根据数据结构选择图表,清晰表达比较、分布、层级、关系、进度和时间安排。

专题

JSON 规范化与数据交换工作流

把结构化来源转换为经过核对的 JSON 表示,再按下游需求导出为表格、配置、文档、API、XML、CSON、EDN、BSON 或 UBJSON。

首页
工具3212
案例593
可视化471
文件查看器103
专题239
标签333
图像、音频与视频657

图像、音频、视频处理、转换与优化工具

数学、日期与金融647

计算器、数值计算、日期逻辑、统计与金融工具

设计与颜色298

颜色、版式、图形、视觉样式与设计辅助工具

文本与写作209

写作、清洗、格式化、提取与文本分析工具

开发与 Web193

开发者工具、网络处理、Web 调试与自动化辅助工具

转换与编码175

格式、文件、压缩包、单位与编码转换工具

潜客测验发布与联系人交接
讣告、悼词与纪念卡的家属复核及交付
本地习惯记录的备份、恢复演练与分享前检查
长文改编 X 串文与 LinkedIn 帖子的事实复核与交付
Markdown 互动课件审校、离线演示与交付

© 2026 Elysia Tools. 保留所有权利。

文档价格关于我们服务条款隐私政策Cookie 政策联系我们

Development

cURL 转 Python (requests)

将 cURL 命令转换为 Python requests 代码片段,包含请求头、数据和请求方法

Media

Chrome网上应用商店截图调整

将图片调整为Chrome网上应用商店截图尺寸,同时保留完整内容和原始宽高比例

Development

Python 正则测试器(re 模块)

在线测试 Python re 模块正则:(?P<name>…) 命名组、(?P=name) 反向引用、VERBOSE 模式、findall 行为与 \g<name> 替换模板——附可直接粘贴的 Python 代码。

Format Conversion

Web Push RFC 8030 请求 + VAPID + RFC 8291 负载加密编码器

编码完整的 Web Push 发送流程:RFC 8291 aes128gcm 负载加密、RFC 8292 VAPID ES256 JWT、RFC 8030 头部、APNs/FCM 头部对照与解密往返验证。

Web & Internet

Web 搜索(SearXNG JSON)

通过 s.stdlang.com 的 SearXNG 实例搜索网页,返回 JSON 结果供自动化或后续工具使用。

Design

网页字体配对实验室

并排预览 标题 + 正文 的 Google 字体配对,调节字重与行高,复制即可粘贴的 CSS @import + 变量代码。精选 22 款字体及 7 组经典搭配预设。

Format Conversion

Excel转HTML表格转换器

将Excel文件转换为HTML表格格式,提取第一个工作表的数据

Python

Web Python 加密安全示例

Web Python 加密和安全示例,包括哈希计算、对称加密和 Base64 编码

Python

Web Python 数据序列化示例

Web Python 数据序列化示例,包括JSON和XML处理

Java

Android Java 数据结构示例

Android Java 数据结构示例,包括数组、哈希表和链表的常用操作

Kotlin

Android Kotlin 数据结构示例

Android Kotlin 数据结构示例,包括数组、哈希表和链表及其常见操作

Swift

macOS Swift 数据结构示例

macOS Swift 数据结构示例,包括数组操作、哈希表和链表

Rust

Web Rust 数据结构示例

Web Rust 数据结构示例,包括数组操作、哈希表和链表