数据结构主要知识点总结

迷失自我的小鹿

已于 2024-04-08 11:33:38 修改

阅读量451

点赞数 6

分类专栏：常见小技巧文章标签：数据结构

于 2024-04-08 11:29:58 首次发布

本文链接：https://blog.csdn.net/m0_62516582/article/details/137501679

版权

常见小技巧专栏收录该内容

2 篇文章 1 订阅

订阅专栏

文章目录

根据需求、如插入删除（或查找）操作频繁，选择合适的数据结构

如果查找操作频繁：

散列表（Hash Table）：提供了快速的查找、插入和删除操作，时间复杂度接近O(1)。适合作为字典或键值对存储，其中键是唯一的。
平衡二叉搜索树（如AVL树、红黑树）：它们保证了在最坏情况下仍然有较好的查找性能，时间复杂度为O(log n)。适合需要频繁查找且数据有序的场景。

如果插入和删除操作频繁：

链表（Linked List）：对于单向链表或双向链表，插入和删除操作的时间复杂度为O(1)，只要节点指针已知。但随机访问性能较差，时间复杂度为O(n)。
栈（Stack） 或 队列（Queue）：这两种是特殊的链表，分别对应LIFO和FIFO的数据结构，它们的插入和删除操作也很快。
堆（Heap）：如果需要快速访问最大或最小元素，可以使用堆结构，插入和删除操作的时间复杂度均为O(log n)。
动态数组（如ArrayList）：如果不介意数据的复制操作，动态数组可以在尾部进行快速的插入和删除，时间复杂度为O(1)。但如果在数组中间或者开始进行插入或删除，则需要移动大量元素，时间复杂度较高。

如果查找、插入和删除操作都需要频繁执行：

平衡二叉搜索树：既可以提供较快的查找性能，也可以支持快速的插入和删除，时间复杂度为O(log n)。
跳表（Skip List）：是一种可以提供快速查找、插入和删除操作的概率型数据结构，平均时间复杂度也是O(log n)。

如果数据量非常大且内存有限：

B树或B+树：这些是在磁盘上或数据库系统中常用的数据结构，可以有效地减少读写磁盘的次数，因为它们将数据存储在树的节点中，每个节点可以包含多个关键字。

总的来说，选择数据结构时需要考虑实际的使用场景和操作需求。例如，如果应用需要频繁地查找数据，那么散列表可能是一个好选择；如果需要频繁地在序列中间插入或删除数据，链表可能更合适。同时，还需要考虑数据量的大小、内存限制以及是否需要保持数据的有序性等因素。在实际应用中，可能需要结合多种数据结构来满足复杂多变的需求。

基本数据结构特点的描述

基本数据结构是计算机科学中用于组织和存储数据的重要概念，每种数据结构都有其独特的特点和适用场景。以下是一些常见数据结构的特点：

数组(Array): 数组是一种最简单且应用广泛的数据结构。它使用连续的内存空间来存储一系列元素，这些元素可以是相同的类型或类型的衍生（形成一个同质数据结构）。数组的元素可以通过下标快速访问，下标通常从0开始。数组的优点包括快速通过索引查询元素和方便的遍历，但缺点在于大小固定后无法扩容，且只能存储一种类型的数据。
栈(Stack): 栈是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构，只允许在一端进行插入和删除操作。这种结构非常适合那些需要逆序处理数据的场景。
队列(Queue): 队列是一种先进先出（FIFO, First In First Out）的数据结构，与栈不同，它允许在一端插入元素而在另一端删除元素。队列通常用于调度和缓冲任务。
链表(Linked List): 链表是由一系列节点组成，每个节点包含数据以及一个指向下一个节点的指针。链表可以是单向的或双向的。链表的优势在于动态大小和插入、删除操作方便，但随机访问速度较慢。
树(Tree): 树是一种分层数据结构，由根节点和若干子树构成。二叉树是一种特殊的树结构，其中每个节点最多有两个子节点。树结构适合表示有层级关系的数据。
图(Graph): 图是由节点（顶点）和连接节点的边组成的数据结构。图可以是有向的也可以是无向的，可以有权重也可以没有。图结构适合表示网络和路径问题。
堆(Heap): 堆是一种特殊的完全二叉树结构，满足堆性质——即父节点的值总是大于（最大堆）或小于（最小堆）其子节点的值。堆常用于实现优先队列。
散列表(Hash Table): 散列表，也叫哈希表，是一种提供快速查找、插入和删除操作的数据结构。它通过将键映射到表中一个位置来实现快速存取，这个位置是通过一个称为哈希函数的算法计算出来的。
集合(Set): 集合是一组不含重复元素的集。集合支持诸如添加、删除、判断元素是否存在等操作，并且通常不关心元素的顺序。
映射(Map): 映射也称为字典，是一种关联数组，它将键映射到值上。映射允许我们通过键来快速查找、插入和删除值。

以上是一些基本数据结构及其特征的描述。不同的数据结构适用于解决不同的问题，选择合适的数据结构对于编写高效和可维护的程序至关重要。

给定二叉树，判断正确的结点遍历（先序遍历、中序遍历、后序遍历）顺序

要判断给定的二叉树节点遍历顺序是否正确，可以通过比较遍历结果与预期结果是否一致来进行判断。

假设给定的二叉树节点遍历顺序为：preorder = [3,9,20,15,7]，inorder = [9,3,15,20,7]，postorder = [9,15,7,20,3]。

首先，根据先序遍历和中序遍历的结果可以重建出原始的二叉树结构。

先序遍历的第一个元素是根节点，即 3。然后在中序遍历中找到值为 3 的节点，它的左边是左子树的节点，右边是右子树的节点。

中序遍历结果为 [9,3,15,20,7]，所以左子树的中序遍历结果为 [9]，右子树的中序遍历结果为 [15,20,7]。

然后分别对左右子树进行递归处理，直到所有节点都被处理完。

最后，根据后序遍历的结果判断重建出的二叉树是否与给定的遍历顺序一致。

如果重建出的二叉树的先序遍历、中序遍历和后序遍历结果与给定的遍历结果一致，则说明给定的遍历顺序是正确的。

单链表的各种操作

#include <stdio.h>
#include <stdlib.h>
 
//定义结点类型
typedef struct Node {
    int data;           //数据类型，你可以把int型的data换成任意数据类型，包括结构体struct等复合类型
    struct Node *next;          //单链表的指针域
} Node,*LinkedList;
 
//单链表的初始化
LinkedList LinkedListInit() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请结点空间
    if(L==NULL){    //判断申请空间是否失败
        exit(0);    //如果失败则退出程序
    }
    L->next = NULL;          //将next设置为NULL,初始长度为0的单链表
    return L;
}
 
 
//单链表的建立1，头插法建立单链表
LinkedList LinkedListCreatH() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                      //初始化一个空链表
 
    int x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点
        p->data = x;                     //结点数据域赋值
        p->next = L->next;                    //将结点插入到表头L-->|2|-->|1|-->NULL
        L->next = p;
    }
    return L;
}
 
 
//单链表的建立2，尾插法建立单链表
 
LinkedList LinkedListCreatT() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                  //初始化一个空链表
    Node *r;
    r = L;                          //r始终指向终端结点，开始时指向头结点
    int x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点
        p->data = x;                     //结点数据域赋值
        r->next = p;                 //将结点插入到表头L-->|1|-->|2|-->NULL
        r = p;
    }
    r->next = NULL;
 
    return L;
}
 
 
//单链表的插入，在链表的第i个位置插入x的元素
 
LinkedList LinkedListInsert(LinkedList L,int i,int x) {
    Node *pre;                      //pre为前驱结点
    pre = L;
    int tempi = 0;
    for (tempi = 1; tempi < i; tempi++) {
        pre = pre->next;                 //查找第i个位置的前驱结点
    }
    Node *p;                                //插入的结点为p
    p = (Node *)malloc(sizeof(Node));
    p->data = x;
    p->next = pre->next;
    pre->next = p;
 
    return L;
}
 
 
//单链表的删除，在链表中删除值为x的元素
 
LinkedList LinkedListDelete(LinkedList L,int x) {
    Node *p,*pre;                   //pre为前驱结点，p为查找的结点。
    p = L->next;
     
    while(p->data != x) {              //查找值为x的元素
        pre = p;
        p = p->next;
    }
    pre->next = p->next;          //删除操作，将其前驱next指向其后继。
    free(p);
     
    return L;
}
 
//链表内容的修改，再链表中修改值为x的元素变为为k。
LinkedList LinkedListReplace(LinkedList L,int x,int k) {
    Node *p=L->next;
    int i=0;
    while(p){
        if(p->data==x){
            p->data=k;
        }
        p=p->next;
    }
    return L;
}
 
 
//便利输出单链表
void printList(LinkedList L){
    Node *p=L->next;
    int i=0;
    while(p){
        printf("第%d个元素的值为:%d\n",++i,p->data);
        p=p->next;
    }
} 
 
int main() {
    //创建 
    LinkedList list;
    printf("请输入单链表的数据：以EOF结尾\n");
    list = LinkedListCreatT();
    //list=LinkedListCreatT();
    printList(list);
     
    //插入 
    int i;
    int x;
    printf("请输入插入数据的位置：");
    scanf("%d",&i);
    printf("请输入插入数据的值：");
    scanf("%d",&x);
    LinkedListInsert(list,i,x);
    printList(list);
     
    //修改
    printf("请输入修改的数据：");
    scanf("%d",&i);
    printf("请输入修改后的值：");
    scanf("%d",&x);
    LinkedListReplace(list,i,x);
    printList(list);
     
    //删除 
    printf("请输入要删除的元素的值：");
    scanf("%d",&x);
    LinkedListDelete(list,x);
    printList(list);
 
    return 0;
}

散列表的构造方式，使其减少冲突散列表元素查找

散列表是一种使用哈希函数将键映射到数组索引的数据结构。为了减少冲突并提高查找效率，可以采用以下方法来构造散列表：

选择合适的哈希函数：哈希函数的选择对散列表的性能至关重要。一个好的哈希函数应该能够均匀地将键映射到数组的索引上，以减少冲突。常见的哈希函数有除留余数法、直接寻址法和乘法哈希法等。
动态调整数组大小：当散列表中的元素数量超过一定阈值时，可以通过增加数组的大小来减少冲突。这可以通过重新哈希所有元素来实现，即将每个元素的键通过新的哈希函数映射到新的数组索引上。
开放地址法：当发生冲突时，可以使用开放地址法来解决。开放地址法包括线性探测、二次探测和双重哈希等方法。这些方法通过在数组中寻找下一个可用的空位置来存储冲突的元素。
链地址法：另一种解决冲突的方法是使用链地址法。在这种方法中，每个数组元素都包含一个链表，用于存储具有相同哈希值的多个元素。当发生冲突时，新元素将被添加到相应索引处的链表中。
使用更好的哈希函数：如果哈希函数选择不当，可能会导致许多冲突。因此，可以尝试使用不同的哈希函数来减少冲突。例如，可以考虑使用更复杂的哈希函数，如MurmurHash或CityHash等。
优化负载因子：负载因子是指散列表中已存储的元素数量与数组大小的比值。较高的负载因子会导致更多的冲突。因此，可以通过调整负载因子来平衡冲突和空间利用率。

综上所述，通过选择合适的哈希函数、动态调整数组大小、使用开放地址法或链地址法、使用更好的哈希函数以及优化负载因子等方法，可以有效地减少散列表中的冲突，提高查找效率。

常见排序算法的复杂度

常见排序算法的时间复杂度主要分为两类：非线性时间比较类和线性时间非比较类。具体如下：

非线性时间比较类排序算法：

冒泡排序：平均和最坏情况下的时间复杂度为O(n^2)，最好情况为O(n)。
选择排序：在所有情况下的时间复杂度都是O(n^2)。
插入排序：平均和最坏情况下的时间复杂度为O(n^2)，最好情况为O(n)。
希尔排序（Shell Sort）：时间复杂度依赖于所选用的增量序列，最坏情况可以达到O(n^{2)，一般情况下优于O(n}2)。
归并排序：在所有情况下的时间复杂度均为O(nlogn)。
快速排序：平均情况下的时间复杂度为O(nlogn)，最坏情况为O(n^2)。
堆排序：在所有情况下的时间复杂度均为O(nlogn)。

线性时间非比较类排序算法：

计数排序：在理想情况下，即当输入的元素具有整数且范围不大时，时间复杂度为O(n)。
基数排序：在理想情况下，即当输入的元素具有整数且范围不大时，时间复杂度为O(n)。
桶排序：平均情况下时间复杂度为O(n + k)，其中k是桶的个数。

以上列出的是几种常见排序算法的时间复杂度，它们在不同的数据规模和数据分布情况下有不同的表现。在实际应用中，选择排序算法时需要考虑数据的特点以及算法的稳定性、空间复杂度等因素。例如，对于小规模数据或基本有序的数据，插入排序可能是一个很好的选择；而对于大规模数据，快速排序、归并排序或堆排序通常更为高效。而对于元素范围有限的整数数组，计数排序或基数排序可以提供线性时间的排序效率。

实现简单的排序功能

冒泡排序

#include <stdio.h>

void bubble_sort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr, n);
    printf("Sorted array: 
");
    for (int i=0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

插入排序

#include <stdio.h>

void insertion_sort(int arr[], int n) {
    int i, key, j;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    insertion_sort(arr, n);
    printf("Sorted array: 
");
    for (int i=0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

快速排序

#include <stdio.h>

void swap(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}

int partition (int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high- 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr)/sizeof(arr[0]);
    quickSort(arr, 0, n-1);
    printf("Sorted array: 
");
    for (int i=0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

迷失自我的小鹿

关注

6
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据结构主要知识点总结

1、根据需求、如插入删除（或查找）操作频繁，选择合适的数据结构 2、基本数据结构特点的描述 3、给定二叉树，判断正确的结点遍历（先序遍历、中序遍历、后序遍历）顺序 4、单链表操作（如删除或插入结点） 5、散列表的构造方式，使其减少冲突散列表元素查找6、常见排序算法的复杂度 7、实现简单的排序功能 8、选择正确的排序过程结果，如快速排序第三趟排序的结果计算二分查找的查询次数 9、计算二分查找的查询次数
复制链接

扫一扫