数据结构基础:修订间差异

来自牛奶河Wiki
跳到导航 跳到搜索
(创建页面,内容为“ === 数据结构基础 === ==== 存储方式 ==== - 数组(顺序存储):紧凑连续存储,可以随机访问,通过索引快速找到对应元素,而且相对节约存储空间。但正因为连续存储,内存空间必须一次性分配够,所以说数组如果要扩容,需要重新分配一块更大的空间,再把数据全部复制过去,时间复杂度 O(N);而且你如果想在数组中间进行插入和删除,每次必须搬…”)
 
无编辑摘要
 
(未显示同一用户的4个中间版本)
第1行: 第1行:
数据结构是计算机存储、组织数据的方式,是指相互之间存在一种或多种特定关系的数据元素的集合。
通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率。
数据结构往往同高效的检索算法和索引技术有关。


=== 数据结构基础 ===
=== 数据结构基础 ===


==== 存储方式 ====
==== 存储方式 ====
  - 数组(顺序存储):紧凑连续存储,可以随机访问,通过索引快速找到对应元素,而且相对节约存储空间。但正因为连续存储,内存空间必须一次性分配够,所以说数组如果要扩容,需要重新分配一块更大的空间,再把数据全部复制过去,时间复杂度 O(N);而且你如果想在数组中间进行插入和删除,每次必须搬移后面的所有数据以保持连续,时间复杂度 O(N)。
 
  - 链表(链式存储):因为元素不连续,而是靠指针指向下一个元素的位置,所以不存在数组的扩容问题;如果知道某一元素的前驱和后驱,操作指针即可删除该元素或者插入新元素,时间复杂度 O(1)。但是正因为存储空间不连续,你无法根据一个索引算出对应元素的地址,所以不能随机访问;而且由于每个元素必须存储指向前后元素位置的指针,会消耗相对更多的储存空间。
# 数组(顺序存储):紧凑连续存储,可以随机访问,通过索引快速找到对应元素,而且相对节约存储空间。但正因为连续存储,内存空间必须一次性分配够,所以说数组如果要扩容,需要重新分配一块更大的空间,再把数据全部复制过去,时间复杂度 O(N);而且你如果想在数组中间进行插入和删除,每次必须搬移后面的所有数据以保持连续,时间复杂度 O(N)。
  - 如:
# 链表(链式存储):因为元素不连续,而是靠指针指向下一个元素的位置,所以不存在数组的扩容问题;如果知道某一元素的前驱和后驱,操作指针即可删除该元素或者插入新元素,时间复杂度 O(1)。但是正因为存储空间不连续,你无法根据一个索引算出对应元素的地址,所以不能随机访问;而且由于每个元素必须存储指向前后元素位置的指针,会消耗相对更多的储存空
  - Redis 提供列表、字符串、集合等等几种常用数据结构,但是对于每种数据结构,底层的存储方式都至少有两种,以便于根据存储数据的实际情况使用合适的存储方式。
 
如:Redis 提供列表、字符串、集合等等几种常用数据结构,但是对于每种数据结构,底层的存储方式都至少有两种,以便于根据存储数据的实际情况使用合适的存储方式。


==== 数据结构 ====
==== 数据结构 ====
  - 散列表:通过散列函数把键映射到一个大数组里。而且对于解决散列冲突的方法,拉链法需要链表特性,操作简单,但需要额外的空间存储指针;线性探查法就需要数组特性,以便连续寻址,不需要指针的存储空间,但操作稍微复杂些。
 
  - 栈:数组方式需要处理扩容缩容,链表方式需要更多的内存空间存储节点指针
# 散列表:通过散列函数把键映射到一个大数组里。而且对于解决散列冲突的方法,拉链法需要链表特性,操作简单,但需要额外的空间存储指针;线性探查法就需要数组特性,以便连续寻址,不需要指针的存储空间,但操作稍微复杂些。
  - 队列:数组方式需要处理扩容缩容,链表方式需要更多的内存空间存储节点指针
# 栈:数组方式需要处理扩容缩容,链表方式需要更多的内存空间存储节点指针
  - 堆:用数组实现的树
# 队列:数组方式需要处理扩容缩容,链表方式需要更多的内存空间存储节点指针
  - 树:用数组实现就是「堆」,因为「堆」是一个完全二叉树,用数组存储不需要节点指针,操作也比较简单;用链表实现就是很常见的那种「树」,因为不一定是完全二叉树,所以不适合用数组存储。为此,在这种链表「树」结构之上,又衍生出各种巧妙的设计,比如二叉搜索树、AVL 树、红黑树、区间树、B 树等等,以应对不同的问题。
# 堆:用数组实现的树
  - 图:邻接表就是链表,邻接矩阵就是二维数组。
# 树:用数组实现就是「堆」,因为「堆」是一个完全二叉树,用数组存储不需要节点指针,操作也比较简单;用链表实现就是很常见的那种「树」,因为不一定是完全二叉树,所以不适合用数组存储。为此,在这种链表「树」结构之上,又衍生出各种巧妙的设计,比如二叉搜索树、AVL 树、红黑树、区间树、B 树等等,以应对不同的问题。
# 图:邻接表就是链表,邻接矩阵就是二维数组。


==== 基本操作 ====
==== 基本操作 ====


===== 数组遍历框架,典型的线性迭代结构: =====
===== 数组遍历框架,典型的线性迭代结构: =====
<code> void traverse(int[] arr) {
void traverse(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
 
        // 迭代访问 arr[i]
    for (int i = 0; i < arr.length; i++) {
    }
 
} </code>
    // 迭代访问 arr[i]
 
    }
 
}


===== 链表遍历框架,兼具迭代和递归结构: =====
===== 链表遍历框架,兼具迭代和递归结构: =====
<code> /* 基本的单链表节点 */ class ListNode {
/* 基本的单链表节点 */
    int val;
 
    ListNode next;  
class ListNode {
} void traverse(ListNode head) {  
 
    for (ListNode p = head; p != null; p = p.next) {
    int val;
        // 迭代访问 p.val
 
    }  
    ListNode next;
} void traverse(ListNode head) {  
 
    // 递归访问 head.val
}
    traverse(head.next);  
 
void traverse(ListNode head) {
 
    for (ListNode p = head; p != null; p = p.next) {
 
        // 迭代访问 p.val
 
    }
 
}
 
void traverse(ListNode head) {
 
    // 递归访问 head.val
 
    traverse(head.next);
 
}
}


===== 二叉树遍历框架,典型的非线性递归遍历结构: =====
===== 二叉树遍历框架,典型的非线性递归遍历结构: =====
<code> /* 基本的二叉树节点 */ class TreeNode {
    int val;
    TreeNode left, right;
} void traverse(TreeNode root) {
    traverse(root.left);
    traverse(root.right);
} </code>


<code> /* 基本的 N 叉树节点 */ class TreeNode {
/* 基本的二叉树节点 */
    int val;
 
    TreeNode[] children;  
class TreeNode {
} void traverse(TreeNode root) {  
 
    for (TreeNode child : root.children)
    int val;
        traverse(child);
 
} N 叉树的遍历又可以扩展为图的遍历。将图视为几个 N 叉棵树的结合体。图中若出现环,可采用布尔数组 visited 标记。 </code>
    TreeNode left, right;
 
}
 
void traverse(TreeNode root) {
 
    traverse(root.left);
 
    traverse(root.right);
 
}
 
/* 基本的 N 叉树节点 */
 
class TreeNode {
 
    int val;
 
    TreeNode[] children;  
 
}
 
void traverse(TreeNode root) {
 
    for (TreeNode child : root.children)
 
        traverse(child);
 
}
 
N 叉树的遍历又可以扩展为图的遍历。将图视为几个 N 叉棵树的结合体。图中若出现环,可采用布尔数组 visited 标记。  
[[分类:Develop]]
[[分类:Algorithm]]

2022年12月29日 (四) 16:30的最新版本

数据结构是计算机存储、组织数据的方式,是指相互之间存在一种或多种特定关系的数据元素的集合。

通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率。

数据结构往往同高效的检索算法和索引技术有关。

数据结构基础

存储方式

  1. 数组(顺序存储):紧凑连续存储,可以随机访问,通过索引快速找到对应元素,而且相对节约存储空间。但正因为连续存储,内存空间必须一次性分配够,所以说数组如果要扩容,需要重新分配一块更大的空间,再把数据全部复制过去,时间复杂度 O(N);而且你如果想在数组中间进行插入和删除,每次必须搬移后面的所有数据以保持连续,时间复杂度 O(N)。
  2. 链表(链式存储):因为元素不连续,而是靠指针指向下一个元素的位置,所以不存在数组的扩容问题;如果知道某一元素的前驱和后驱,操作指针即可删除该元素或者插入新元素,时间复杂度 O(1)。但是正因为存储空间不连续,你无法根据一个索引算出对应元素的地址,所以不能随机访问;而且由于每个元素必须存储指向前后元素位置的指针,会消耗相对更多的储存空

如:Redis 提供列表、字符串、集合等等几种常用数据结构,但是对于每种数据结构,底层的存储方式都至少有两种,以便于根据存储数据的实际情况使用合适的存储方式。

数据结构

  1. 散列表:通过散列函数把键映射到一个大数组里。而且对于解决散列冲突的方法,拉链法需要链表特性,操作简单,但需要额外的空间存储指针;线性探查法就需要数组特性,以便连续寻址,不需要指针的存储空间,但操作稍微复杂些。
  2. 栈:数组方式需要处理扩容缩容,链表方式需要更多的内存空间存储节点指针
  3. 队列:数组方式需要处理扩容缩容,链表方式需要更多的内存空间存储节点指针
  4. 堆:用数组实现的树
  5. 树:用数组实现就是「堆」,因为「堆」是一个完全二叉树,用数组存储不需要节点指针,操作也比较简单;用链表实现就是很常见的那种「树」,因为不一定是完全二叉树,所以不适合用数组存储。为此,在这种链表「树」结构之上,又衍生出各种巧妙的设计,比如二叉搜索树、AVL 树、红黑树、区间树、B 树等等,以应对不同的问题。
  6. 图:邻接表就是链表,邻接矩阵就是二维数组。

基本操作

数组遍历框架,典型的线性迭代结构:

void traverse(int[] arr) {

    for (int i = 0; i < arr.length; i++) {

    // 迭代访问 arr[i]

    }

}

链表遍历框架,兼具迭代和递归结构:

/* 基本的单链表节点 */

class ListNode {

    int val;

    ListNode next;

}

void traverse(ListNode head) {

    for (ListNode p = head; p != null; p = p.next) {

        // 迭代访问 p.val

    }

}

void traverse(ListNode head) {

    // 递归访问 head.val

    traverse(head.next);

}

二叉树遍历框架,典型的非线性递归遍历结构:

/* 基本的二叉树节点 */

class TreeNode {

    int val;

    TreeNode left, right;

}

void traverse(TreeNode root) {

    traverse(root.left);

    traverse(root.right);

}

/* 基本的 N 叉树节点 */

class TreeNode {

    int val;

    TreeNode[] children;

}

void traverse(TreeNode root) {

    for (TreeNode child : root.children)

        traverse(child);

}

N 叉树的遍历又可以扩展为图的遍历。将图视为几个 N 叉棵树的结合体。图中若出现环,可采用布尔数组 visited 标记。