首页手记数据结构入门教程：轻松掌握基础知识

数据结构入门教程：轻松掌握基础知识

标签：

数据结构算法与数据结构

概述

数据结构是计算机科学中的基础概念，它决定了程序的效率和性能。合理选择和使用数据结构可以提高程序的运行效率，增强代码的可读性和维护性，还能简化复杂操作并解决实际问题。

数据结构简介

什么是数据结构

数据结构是计算机科学中的一个基础概念，它是指在计算机程序中组织、处理和存储数据的方式。数据结构的设计直接影响到程序的效率和性能。数据结构能够帮助程序有效地管理和操作大量数据，从而提高程序的执行速度和内存使用效率。

在编程中，常见的数据结构包括数组、链表、栈、队列、树和图等。每种数据结构都有其特定的应用场景和操作特点。

数据结构的重要性

数据结构的重要性体现在以下几个方面：

提高程序效率：通过合理选择和使用数据结构，可以减少程序执行时间、提高内存利用率，从而提升程序的运行效率。
增强代码可读性：合理设计的数据结构可以使代码更加清晰、易于理解，便于后续维护。
支持复杂操作：某些数据结构能够高效地支持特定的操作，如查找、插入、删除等，从而简化编程任务。
解决实际问题：在现实世界中，各种复杂问题可以通过设计合适的数据结构来简化和解决，例如图结构在社交网络分析中的应用。

常见的数据结构类型

以下是几种常见的数据结构类型：

数组：一种线性数据结构，用于存储一组相同类型的元素。
链表：一种链式存储的线性数据结构，每个元素（节点）包含数据部分和指向下一个元素的指针。
栈：后进先出（LIFO, Last-In-First-Out）的数据结构。
队列：先进先出（FIFO, First-In-First-Out）的数据结构。
树：非线性数据结构，每个节点有一个父节点和零个或多个子节点。
图：由节点和边组成的数据结构，用于表示节点之间的关系。

线性数据结构

数组

数组是一种基本的数据结构，用于存储一组相同类型的元素。数组中的每个元素都可以通过索引进行访问。

数组的特点

固定大小：一旦创建，数组的大小就固定了，无法动态调整。
随机访问：数组中的元素可以通过索引随机访问，访问速度较快。
连续存储：数组中的元素在内存中是连续存储的。

数组的操作

数组可以执行以下操作：

插入：在数组的某个位置插入一个新元素。
删除：从数组中删除一个元素。
访问：通过索引访问数组中的元素。
更新：修改数组中的某个元素。

数组的实现

在Python中，数组可以使用列表（list）来实现。下面是一个简单的数组实现示例：

# 创建一个数组
array = [1, 2, 3, 4, 5]

# 访问元素
print(array[2])  # 输出3

# 插入元素
array.insert(2, 10)  # 在索引2处插入10
print(array)  # 输出[1, 2, 10, 3, 4, 5]

# 删除元素
array.remove(10)  # 删除值为10的元素
print(array)  # 输出[1, 2, 3, 4, 5]

# 更新元素
array[0] = 100
print(array)  # 输出[100, 2, 3, 4, 5]

链表

链表是一种线性数据结构，其特点是每个元素（节点）都包含数据部分以及指向下一个元素的指针。

链表的特点

动态大小：链表的大小可以根据需要动态调整。
不连续存储：链表中的元素在内存中不一定是连续存储的。
插入/删除操作：链表允许在任意位置插入或删除节点，但访问某个节点需要遍历。

链表的操作

链表可以执行以下操作：

插入：在链表的某个位置插入新的节点。
删除：从链表中删除某个节点。
访问：遍历链表以访问某个节点。
更新：修改链表中的节点数据。

链表的实现

在Python中，链表可以通过定义一个节点类和一个链表类来实现。下面是一个简单的单链表实现示例：

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

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

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print('None')

# 创建链表
llist = LinkedList()
llist.append(1)
llist.append(2)
llist.append(3)
llist.display()  # 输出1 -> 2 -> 3 -> None

栈

栈是一种后进先出（LIFO, Last-In-First-Out）的数据结构，通常用于实现函数调用、撤销操作等。

栈的特点

后进先出：最后插入的元素首先被删除。
插入/删除操作：在栈顶进行插入和删除操作。
固定大小：栈在某些实现中可以是固定大小的，但在大多数情况下是动态的。

栈的操作

栈可以执行以下操作：

入栈：将一个元素压入栈顶。
出栈：从栈顶弹出一个元素。
访问栈顶：查看栈顶元素但不移除它。
检查是否为空：判断栈是否为空。

栈的实现

在Python中，栈可以使用列表来实现。下面是一个简单的栈实现示例：

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

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

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

    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        return None

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

    def display(self):
        print(self.items)

# 创建栈
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
stack.display()  # 输出[1, 2, 3]
print(stack.pop())  # 输出3
stack.display()  # 输出[1, 2]

队列

队列是一种先进先出（FIFO, First-In-First-Out）的数据结构，通常用于实现任务调度、等待队列等。

队列的特点

先进先出：最先插入的元素最先被删除。
插入/删除操作：分别在队尾和队头进行插入和删除操作。
固定大小：队列在某些实现中可以是固定大小的，但在大多数情况下是动态的。

队列的操作

队列可以执行以下操作：

入队：将一个元素添加到队尾。
出队：从队头移除一个元素。
访问队头：查看队头元素但不移除它。
检查是否为空：判断队列是否为空。

队列的实现

在Python中，队列可以使用列表来实现。下面是一个简单的队列实现示例：

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

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

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

    def dequeue(self):
        if not self.is_empty():
            return self.items.pop()
        return None

    def display(self):
        print(self.items)

# 创建队列
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.display()  # 输出[1, 2, 3]
print(queue.dequeue())  # 输出1
queue.display()  # 输出[2, 3]

非线性数据结构

树

树是一种非线性数据结构，由节点和边组成，每个节点可以有零个或多个子节点。

树的特点

层次结构：树的每个节点都有一个父节点（除了根节点）和零个或多个子节点。
单一路径：从根节点到任何叶子节点的路径是唯一的。
树的类型：常见的树结构有二叉树、平衡树、堆等。

树的操作

树可以执行以下操作：

插入：在树中插入一个新节点。
删除：从树中删除一个节点。
遍历：遍历树中的所有节点。
查找：查找树中的某个节点。

树的实现

在Python中，树可以使用类来实现。下面是一个简单的二叉树实现示例：

class TreeNode:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

class BinaryTree:
    def __init__(self, root):
        self.root = TreeNode(root)

    def insert(self, data):
        if not self.root:
            self.root = TreeNode(data)
            return
        self._insert(self.root, data)

    def _insert(self, current, data):
        if data < current.data:
            if not current.left:
                current.left = TreeNode(data)
            else:
                self._insert(current.left, data)
        elif data > current.data:
            if not current.right:
                current.right = TreeNode(data)
            else:
                self._insert(current.right, data)

    def display_inorder(self):
        self._display_inorder(self.root)

    def _display_inorder(self, current):
        if current:
            self._display_inorder(current.left)
            print(current.data)
            self._display_inorder(current.right)

# 创建二叉树
tree = BinaryTree(10)
tree.insert(5)
tree.insert(15)
tree.insert(3)
tree.insert(7)
tree.display_inorder()  # 输出3 5 7 10 15

图

图是一种非线性数据结构，由节点和边组成，用于表示节点之间的关系。

图的特点

节点和边：图由节点和连接节点的边组成。
有向图和无向图：边可以是有向的（有方向的）或无向的（无方向的）。
权值：边可以有权重，表示边的代价或距离。

图的操作

图可以执行以下操作：

插入节点：在图中插入一个新节点。
删除节点：从图中删除一个节点。
插入边：在节点之间插入一条边。
删除边：从图中删除一条边。
遍历：遍历图中的所有节点。
查找：查找图中的某个节点或边。

图的实现

在Python中，图可以使用字典和列表来实现。下面是一个简单的无向图实现示例：

class Graph:
    def __init__(self):
        self.vertices = {}

    def add_vertex(self, node):
        self.vertices[node] = []

    def add_edge(self, from_vertex, to_vertex):
        if from_vertex in self.vertices and to_vertex in self.vertices:
            self.vertices[from_vertex].append(to_vertex)
            self.vertices[to_vertex].append(from_vertex)
        else:
            raise ValueError("Vertex does not exist.")

    def display(self):
        for node in self.vertices:
            print(node, '->', ' '.join(map(str, self.vertices[node])))

# 创建图
graph = Graph()
graph.add_vertex(1)
graph.add_vertex(2)
graph.add_vertex(3)
graph.add_vertex(4)
graph.add_edge(1, 2)
graph.add_edge(2, 3)
graph.add_edge(3, 4)
graph.display()  # 输出1 -> 2 2 -> 1 3 3 -> 1 2 4 4 -> 3

常见操作与算法

查找

查找是指在数据结构中查找特定元素的过程，常见的查找算法包括线性查找和二分查找。

线性查找

线性查找是一种简单的查找方法，它遍历整个数据结构，逐个比较元素，直到找到目标元素或遍历完整个结构。

二分查找

二分查找是一种高效的查找方法，它适用于已排序的数据结构。二分查找通过不断将查找区间减半，逐步缩小目标元素的位置范围。

排序

排序是指将数据结构中的元素按照一定顺序排列的过程。常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。

冒泡排序

冒泡排序是一种简单的排序方法，它通过多次遍历数据结构，每次遍历都会将最大的元素“冒泡”到合适的位置。

快速排序

快速排序是一种高效的排序方法，它通过分治法将数据结构分成两个子数组，然后递归地对这两个子数组进行排序。

遍历

遍历是指访问数据结构中每个元素的过程。常见的遍历方法包括深度优先遍历（DFS）和广度优先遍历（BFS）。

深度优先遍历（DFS）

深度优先遍历是一种递归遍历方法，它优先访问节点的子节点，然后再访问父节点的其他子节点。

广度优先遍历（BFS）

广度优先遍历是一种层次遍历方法，它优先访问节点的所有子节点，然后再访问下一层的子节点。

深度优先遍历的实现示例

在Python中，深度优先遍历可以使用栈来实现。下面是一个简单的深度优先遍历示例：

def dfs(graph, start):
    visited = set()
    stack = [start]
    while stack:
        vertex = stack.pop()
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            stack.extend(graph[vertex] - visited)

# 示例图
graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}

dfs(graph, 'A')  # 输出A C F E B D

广度优先遍历的实现示例

在Python中，广度优先遍历可以使用队列来实现。下面是一个简单的广度优先遍历示例：

def bfs(graph, start):
    visited = set()
    queue = [start]
    while queue:
        vertex = queue.pop(0)
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            queue.extend(graph[vertex] - visited)

# 示例图
graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}

bfs(graph, 'A')  # 输出A B C D E F

数据结构的选择与应用

何时使用哪种数据结构

选择合适的数据结构取决于具体的应用场景和需求。以下是一些常见的使用场景和对应的数据结构：

数组：适用于需要快速随机访问的数据，如矩阵运算。
链表：适用于需要频繁插入或删除元素的场景，如实现队列和栈。
栈：适用于需要后进先出操作的场景，如函数调用栈、括号匹配等。
队列：适用于需要先进先出操作的场景，如任务调度、消息队列等。
树：适用于需要层次结构的数据，如文件系统、目录结构等。
图：适用于需要表示节点之间关系的场景，如社交网络分析、路径规划等。

数据结构在实际开发中的应用案例

数据结构在实际开发中有着广泛的应用，下面是一些具体的案例：

数组：在图像处理中，数组被用来存储像素值，进行图像的处理和分析。例如，一个简单的图像处理示例：

# 创建一个数组来存储图像像素值
pixels = [255, 180, 100, 50, 0]
# 对像素值进行处理
for i in range(len(pixels)):
  pixels[i] = pixels[i] * 0.8
print(pixels)  # 输出[204, 144, 80, 40, 0]

链表：在内存管理中，链表被用来实现内存的动态分配和回收。例如，一个简单的内存分配示例：

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

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

  def append(self, data):
      new_node = Node(data)
      if not self.head:
          self.head = new_node
          return
      last = self.head
      while last.next:
          last = last.next
      last.next = new_node

  def display(self):
      current = self.head
      while current:
          print(current.data, end=" -> ")
          current = current.next
      print('None')

# 创建链表
llist = LinkedList()
llist.append(1)
llist.append(2)
llist.append(3)
llist.display()  # 输出1 -> 2 -> 3 -> None

栈：在编译器实现中，栈被用来存放函数调用信息，帮助进行函数调用的管理和恢复。例如，一个简单的函数调用栈示例：

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

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

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

  def pop(self):
      if not self.is_empty():
          return self.items.pop()
      return None

  def display(self):
      print(self.items)

# 创建栈
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
stack.display()  # 输出[1, 2, 3]
print(stack.pop())  # 输出3
stack.display()  # 输出[1, 2]

队列：在网络通信中，队列被用来管理网络数据包的发送和接收顺序。例如，一个简单的网络数据包队列示例：

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

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

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

  def dequeue(self):
      if not self.is_empty():
          return self.items.pop()
      return None

  def display(self):
      print(self.items)

# 创建队列
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.display()  # 输出[1, 2, 3]
print(queue.dequeue())  # 输出1
queue.display()  # 输出[2, 3]

树：在文件系统中，树被用来表示文件的层次结构，如Linux文件系统。例如，一个简单的文件系统树结构示例：

class TreeNode:
  def __init__(self, data):
      self.data = data
      self.left = None
      self.right = None

class FileSystem:
  def __init__(self, root):
      self.root = TreeNode(root)

  def insert(self, path):
      current = self.root
      path = path.split('/')
      for node in path:
          if not current.left:
              current.left = TreeNode(node)
              current = current.left
          else:
              current.right = TreeNode(node)
              current = current.right

  def display_inorder(self):
      self._display_inorder(self.root)

  def _display_inorder(self, current):
      if current:
          self._display_inorder(current.left)
          print(current.data)
          self._display_inorder(current.right)

# 创建文件系统
fs = FileSystem('/')
fs.insert('/home/user/documents')
fs.insert('/home/user/pictures')
fs.display_inorder()  # 输出/

图：在社交网络分析中，图被用来表示用户之间的关系，进行社区发现和推荐算法。例如，一个简单的社交网络图示例：

class Graph:
  def __init__(self):
      self.vertices = {}

  def add_vertex(self, node):
      self.vertices[node] = []

  def add_edge(self, from_vertex, to_vertex):
      if from_vertex in self.vertices and to_vertex in self.vertices:
          self.vertices[from_vertex].append(to_vertex)
          self.vertices[to_vertex].append(from_vertex)
      else:
          raise ValueError("Vertex does not exist.")

  def display(self):
      for node in self.vertices:
          print(node, '->', ' '.join(map(str, self.vertices[node])))

# 创建图
graph = Graph()
graph.add_vertex('Alice')
graph.add_vertex('Bob')
graph.add_vertex('Charlie')
graph.add_edge('Alice', 'Bob')
graph.add_edge('Bob', 'Charlie')
graph.display()  # 输出Alice -> Bob Bob -> Alice Charlie

练习与实践

常见数据结构的实现练习

为了加深对数据结构的理解，以下是一些常见的数据结构实现练习：

数组：实现一个动态数组，能够在数组中插入、删除元素，并支持随机访问。
链表：实现一个双向链表，能够在链表中插入、删除节点，并支持双向遍历。
栈：实现一个栈，能够在栈中插入、删除元素，并支持查看栈顶元素。
队列：实现一个队列，能够在队列中插入、删除元素，并支持查看队头元素。
树：实现一个二叉搜索树，能够在树中插入、删除节点，并支持查找操作。
图：实现一个图，能够在图中插入节点和边，并支持遍历操作。

动态数组的实现示例

在Python中，动态数组可以通过列表来实现。下面是一个简单的动态数组实现示例：

class DynamicArray:
    def __init__(self):
        self.items = []
        self.capacity = 2  # 初始容量
        self.size = 0

    def __getitem__(self, index):
        return self.items[index]

    def append(self, item):
        if self.size == self.capacity:
            self._resize(self.capacity * 2)  # 容量翻倍
        self.items.append(item)
        self.size += 1

    def insert(self, index, item):
        if self.size == self.capacity:
            self._resize(self.capacity * 2)  # 容量翻倍
        self.items.insert(index, item)
        self.size += 1

    def remove(self, item):
        if item in self.items:
            self.items.remove(item)
            self.size -= 1

    def _resize(self, new_capacity):
        new_items = [None] * new_capacity
        for i in range(self.size):
            new_items[i] = self.items[i]
        self.items = new_items
        self.capacity = new_capacity

    def display(self):
        print(self.items)

# 使用动态数组
array = DynamicArray()
array.append(1)
array.append(2)
array.insert(1, 10)
array.remove(1)
array.display()  # 输出[10, 2]

数据结构算法的实战案例

为了更好地掌握数据结构算法，以下是一些实战案例：

二分查找：实现一个二分查找算法，能在已排序的数组中查找指定元素。
插入排序：实现一个插入排序算法，能在数组中排序元素。
深度优先遍历：实现一个深度优先遍历算法，能在树或图中遍历所有节点。
广度优先遍历：实现一个广度优先遍历算法，能在树或图中遍历所有节点。

二分查找的实现示例

在Python中，二分查找可以通过递归或迭代来实现。下面是一个简单的二分查找实现示例：

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

# 示例数组
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(binary_search(arr, 7))  # 输出6

插入排序的实现示例

在Python中，插入排序可以通过遍历和比较来实现。下面是一个简单的插入排序实现示例：

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

# 示例数组
arr = [64, 34, 25, 12, 22, 11, 90]
insertion_sort(arr)
print(arr)  # 输出[11, 12, 22, 25, 34, 64, 90]

深度优先遍历的实现示例

在Python中，深度优先遍历可以通过递归或栈来实现。下面是一个简单的深度优先遍历实现示例：

def dfs(graph, start):
    visited = set()
    stack = [start]
    while stack:
        vertex = stack.pop()
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            stack.extend(graph[vertex] - visited)

# 示例图
graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}

dfs(graph, 'A')  # 输出A C F E B D

广度优先遍历的实现示例

在Python中，广度优先遍历可以通过队列来实现。下面是一个简单的广度优先遍历实现示例：

def bfs(graph, start):
    visited = set()
    queue = [start]
    while queue:
        vertex = queue.pop(0)
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            queue.extend(graph[vertex] - visited)

# 示例图
graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}

bfs(graph, 'A')  # 输出A B C D E F

通过这些练习和示例代码，你可以更好地理解和掌握数据结构的相关知识和技能。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕标琳琳

手记
篇

粉丝

18

获赞与收藏

140

关注作者，订阅最新文章

相关文章推荐

Python简要介绍--轻松掌握编程乐趣

Python基础函数--轻松掌握常见操作

Webpack轻松入门（一）——基本流程

2022 Java开发入门学习路线（一）掌握计算机基础

Webpack轻松入门（一）——基本流程

阅读免费教程

数据结构入门教程

7个小节 23510 613

后端通用面试教程

41个小节 30273 342

ES6-10 入门教程

61个小节 93083 732

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

数据结构入门教程：轻松掌握基础知识

什么是数据结构

数据结构的重要性

常见的数据结构类型

数组

数组的特点

数组的操作

数组的实现

链表

链表的特点

链表的操作

链表的实现

栈

栈的特点

栈的操作

栈的实现

队列

队列的特点

队列的操作

队列的实现

树

树的特点

树的操作

树的实现

图

图的特点

图的操作

图的实现

查找

线性查找

二分查找

排序

冒泡排序

快速排序

遍历

深度优先遍历（DFS）

广度优先遍历（BFS）

深度优先遍历的实现示例

广度优先遍历的实现示例

何时使用哪种数据结构

数据结构在实际开发中的应用案例

常见数据结构的实现练习

动态数组的实现示例

数据结构算法的实战案例

二分查找的实现示例

插入排序的实现示例

深度优先遍历的实现示例

广度优先遍历的实现示例

相关文章推荐

阅读免费教程