各种数据结构上的常见操作

作为程序员，我们常常需要在不同的数据结构上进行一些常见的操作，比如增删查改等等。在本文中，我们将介绍一些常见数据结构上的常见操作，希望对你的开发工作有所帮助。

数组

数组是最常见的数据结构之一，它也是最简单的。在数组中，我们可以添加、查找、删除和更新元素。

添加元素

我们可以通过指定下标，将元素添加到数组中：

my_array = [1, 2, 3, 4, 5]
my_array[5] = 6

查找元素

我们可以使用下标来访问数组中的元素：

my_array = [1, 2, 3, 4, 5]
print(my_array[2])  # Output: 3

删除元素

我们可以通过下标来删除数组中的元素：

my_array = [1, 2, 3, 4, 5]
del my_array[2]

更新元素

我们可以通过下标来更新数组中的元素：

my_array = [1, 2, 3, 4, 5]
my_array[2] = 10

链表

链表是另一种常见的数据结构，在链表中，每个元素都包含一个指向下一个元素的指针。链表与数组不同，链表的元素不存储在连续的内存位置上，它们可以随时插入和删除。

添加元素

我们可以通过以下代码向链表中添加元素：

class Node:
  def __init__(self, data=None):
    self.data = data
    self.next = None

class LinkedList:
  def __init__(self):
    self.head = None

  def append(self, data):
    new_node = Node(data)
    if self.head is None:
      self.head = new_node
      return
    last_node = self.head
    while last_node.next:
      last_node = last_node.next
    last_node.next = new_node

查找元素

我们可以通过以下代码查找链表中的元素：

class Node:
  def __init__(self, data=None):
    self.data = data
    self.next = None

class LinkedList:
  def __init__(self):
    self.head = None

  def append(self, data):
    new_node = Node(data)
    if self.head is None:
      self.head = new_node
      return
    last_node = self.head
    while last_node.next:
      last_node = last_node.next
    last_node.next = new_node

  def get(self, index):
    current_node = self.head
    current_index = 0
    while current_node:
      if current_index == index:
        return current_node.data
      current_node = current_node.next
      current_index += 1
    return None

删除元素

我们可以通过以下代码删除链表中的元素：

class Node:
  def __init__(self, data=None):
    self.data = data
    self.next = None

class LinkedList:
  def __init__(self):
    self.head = None

  def append(self, data):
    new_node = Node(data)
    if self.head is None:
      self.head = new_node
      return
    last_node = self.head
    while last_node.next:
      last_node = last_node.next
    last_node.next = new_node

  def remove(self, index):
    if index == 0:
      self.head = self.head.next
      return
    current_node = self.head
    current_index = 0
    while current_node:
      if current_index == index - 1:
        current_node.next = current_node.next.next
        return
      current_node = current_node.next
      current_index += 1

栈

栈是一种后进先出（LIFO）的数据结构，它只允许在一端插入和删除元素。在栈上，我们只能访问添加到最后的元素。

添加元素

我们可以通过以下代码向栈中添加元素：

class Stack:
  def __init__(self):
    self.items = []

  def push(self, item):
    self.items.append(item)

查找元素

由于栈上的元素没有明确的位置，因此我们无法直接通过下标查找元素。我们可以通过以下代码获取栈顶元素：

class Stack:
  def __init__(self):
    self.items = []

  def push(self, item):
    self.items.append(item)

  def peek(self):
    if not self.is_empty():
      return self.items[-1]

  def is_empty(self):
    return len(self.items) == 0

删除元素

我们可以通过以下代码从栈中删除元素：

class Stack:
  def __init__(self):
    self.items = []

  def push(self, item):
    self.items.append(item)

  def peek(self):
    if not self.is_empty():
      return self.items[-1]

  def pop(self):
    return self.items.pop()

  def is_empty(self):
    return len(self.items) == 0

队列

队列是一种先进先出（FIFO）的数据结构，它允许在一端插入元素，在另一端删除元素。与栈不同，队列上的元素有明确的位置。

添加元素

我们可以通过以下代码向队列中添加元素：

class Queue:
  def __init__(self):
    self.items = []

  def enqueue(self, item):
    self.items.insert(0, item)

查找元素

由于队列上的元素有明确的位置，我们可以通过以下代码访问队列中的元素：

class Queue:
  def __init__(self):
    self.items = []

  def enqueue(self, item):
    self.items.insert(0, item)

  def peek(self):
    if not self.is_empty():
      return self.items[-1]

  def is_empty(self):
    return len(self.items) == 0

删除元素

我们可以通过以下代码从队列中删除元素：

class Queue:
  def __init__(self):
    self.items = []

  def enqueue(self, item):
    self.items.insert(0, item)

  def peek(self):
    if not self.is_empty():
      return self.items[-1]

  def dequeue(self):
    return self.items.pop()

  def is_empty(self):
    return len(self.items) == 0

哈希表

哈希表是一种键值对存储数据的数据结构，它通过将键映射到数组中的一个位置来实现快速查找。

添加元素

我们可以通过以下代码向哈希表中添加元素：

class HashTable:
  def __init__(self):
    self.max = 100
    self.arr = [[] for _ in range(self.max)]

  def get_hash(self, key):
    h = 0
    for char in key:
      h += ord(char)
    return h % self.max

  def __setitem__(self, key, val):
    h = self.get_hash(key)
    found = False
    for idx, element in enumerate(self.arr[h]):
      if len(element) == 2 and element[0] == key:
        self.arr[h][idx] = (key, val)
        found = True
        break
    if not found:
      self.arr[h].append((key, val))

  def __getitem__(self, key):
    h = self.get_hash(key)
    for element in self.arr[h]:
      if element[0] == key:
        return element[1]

查找元素

我们可以通过以下代码访问哈希表中的元素：

class HashTable:
  def __init__(self):
    self.max = 100
    self.arr = [[] for _ in range(self.max)]

  def get_hash(self, key):
    h = 0
    for char in key:
      h += ord(char)
    return h % self.max

  def __setitem__(self, key, val):
    h = self.get_hash(key)
    found = False
    for idx, element in enumerate(self.arr[h]):
      if len(element) == 2 and element[0] == key:
        self.arr[h][idx] = (key, val)
        found = True
        break
    if not found:
      self.arr[h].append((key, val))

  def __getitem__(self, key):
    h = self.get_hash(key)
    for element in self.arr[h]:
      if element[0] == key:
        return element[1]

  def __contains__(self, key):
    h = self.get_hash(key)
    for element in self.arr[h]:
      if element[0] == key:
        return True
    return False

删除元素

我们可以通过以下代码从哈希表中删除元素：

class HashTable:
  def __init__(self):
    self.max = 100
    self.arr = [[] for _ in range(self.max)]

  def get_hash(self, key):
    h = 0
    for char in key:
      h += ord(char)
    return h % self.max

  def __setitem__(self, key, val):
    h = self.get_hash(key)
    found = False
    for idx, element in enumerate(self.arr[h]):
      if len(element) == 2 and element[0] == key:
        self.arr[h][idx] = (key, val)
        found = True
        break
    if not found:
      self.arr[h].append((key, val))

  def __getitem__(self, key):
    h = self.get_hash(key)
    for element in self.arr[h]:
      if element[0] == key:
        return element[1]

  def delete(self, key):
    h = self.get_hash(key)
    for idx, element in enumerate(self.arr[h]):
      if element[0] == key:
        del self.arr[h][idx]

总结

如上，我们介绍了一些常见数据结构上的常见操作，包括数组、链表、栈、队列和哈希表。如果你要开发一个算法或者应用程序，这些操作将非常有用。即使你不需要直接使用这些数据结构，你也应该理解它们的概念和原理，这将帮助你更好地理解编程的基础知识。