八大数据结构-简总结

最新推荐文章于 2022-03-18 16:38:01 发布
最新推荐文章于 2022-03-18 16:38:01 发布
阅读量261 收藏
点赞数
文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gan777777/article/details/119643365
版权

数据结构各自特点

数组Array

定义

在连续空间内存储一组相同类型的元素（同类数据元素的集合）

访搜插删

操作表达式复杂度
数据访问（Access）a[0] = 1o(1)
数据搜索（Search）遍历o(N)
插入数据（Insert）后移（没有空间全部搬家）o(N)
删除数据（Delete）前移o(N)

特点

适合读不适合写 ： 读多写少

常见操作

创建数组

int[] a = new int[n] ;
int[] a = {1,2,3}; 
int[] a = new int[3]{1,2,3}; 
ArrayList<String> arr = new ArrayList<>();

添加元素 o(N)

arr.add("abc");

访问元素o(1)

String A = a[2];
String arr1 = arr.get(1);

修改元素o(1)

a[2] = "de";
arr.set(1,"cd");

删除元素o(N)

arr.remove("cd"); //移除的是元素
arr.remove(2);  //移除索引对应元素
//arr.remove((Integer) 5) 移除数元素

遍历o(N)

for (int i : a){
    System.out.println(i);
}

for(String i = 0 ; i < arr.length; i++){
	String num = arr.get(i);
}
for (String i : arr){
    System.out.println(i);
}

查找元素o(N)

boolean arrture = arr.contains(3); //存在：true  不存在：false

数组长度o(1)

int length = a.length;
int arrlength = arr.size();

数组排序o(NlogN)（快速排序：分治法）

Arrays.sort(a); //排序升序

Collections.sort(arr); // small to big
System.out.println("排序升序:" + arr.toString());
Collections.reverse(arr);
System.out.println("排序降序:" + arr.toString());

链表LinkedList

定义

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的

访搜插删

操作表达式复杂度
数据访问（Access）遍历o(N)
数据搜索（Search）遍历o(N)
插入数据（Insert）list.addo(1)
删除数据（Delete）list.removeo(1)

特点

适合写不适合读 ： 读少写多

常见操作

创建列表

LinkedList<Integer> list = new LinkedList<>();

添加元素 o(1)、o(n)

list.add(1); //o(1)
list.add(2,99);  //o(n) 遍历索引

访问元素o(N)

int listAccess = list.get(1);//o(n) 遍历索引

搜索元素 o(n)

//search
int listSearch = list.indexOf(10); //遍历才能找到元素，返回的是索引值  o(n)

修改元素o(n)

list.set(1,8);

删除元素o(N)

list.remove(2);  //移除索引对应元素,遍历
//list.remove((Integer) 5) 移除数元素

遍历o(N)

for (int i : list){
    System.out.println(i);
}
for (int i = 0 ; i < list.size() ; i++){
    System.out.println(list.get(i));
}

查找元素o(N)

int listSearch = list.indexOf(10); //返回索引值
boolean listture = list.contains(3); //存在：true  不存在：false

数组长度o(1)

int listlength = list.size();

数组排序o(NlogN)（快速排序：分治法）

Collections.sort(list); // small to big
System.out.println("排序升序:" + list.toString());
Collections.reverse(list);
System.out.println("排序降序:" + list.toString());

节点

ListNode nodeSta = new ListNode(0);  //创建首节点
ListNode nextNode;                  //声明一个变量在移动过程中指向当前节点
nextNode = nodeSta;                 //指向首节点

//创建链表
for (int i = 1 ; i < 10 ; i++){
    ListNode node = new ListNode(i);     //创建新节点
    nextNode.next = node;                //新节点相连
    nextNode = nextNode.next;
    System.out.println("节点："+ nextNode.val);
}

队列Queue

定义

是一种先进先出的线性表。它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。

访搜插删

操作表达式复杂度
数据访问（Access）队头o(1)
数据搜索（Search）不可
插入数据（Insert）队尾o(1)
删除数据（Delete）即将出列元素o(1)

特点

先进先出

常见操作

创建队列

Queue<Integer> queue = new LinkedList<>();

添加元素 o(1)

queue.add(1);

访问元素o(1)

int temp1 = queue.peek();  //获取即将出列元素

删除元素o(1)

int temp3 = queue.poll(); //删除即将出列的元素

遍历o(1)

 while(!queue.isEmpty()){
      int temp4 = queue.poll();
      System.out.println(temp4);
}  //遍历完删完

数组长度o(1)

int queuelength = queue.size();

栈Stack

定义

栈是一种操作受限的线性表只允许从一端插入和删除数据。栈有两种存储方式，即线性存储和链接存储（链表）

访搜插删

操作表达式复杂度
数据访问（Access）栈顶o(1)
数据搜索（Search）遍历o(N)
插入数据（Insert）栈顶o(1)
删除数据（Delete）栈顶o(1)

特点

后入先出

常见操作

创建栈

Stack<Integer> stack = new Stack<>();

添加元素 o(1)

stack.push(1);

访问元素o(1)

int temp1 = stack.peek();  //获取即将出列元素

删除元素o(1)

int pop = stack.pop(); //删除即将出列的元素

遍历o(N)

while(!stack.isEmpty()){
     System.out.println(stack.pop());
} //遍历完删完

数组长度o(1)

int size = stack.size();

哈希表HashTable

定义

是根据关键码值(Key value)而直接进行访问的数据结构

访搜插删

操作表达式复杂度
数据访问（Access）不可
数据搜索（Search）keyo(1)
插入数据（Insert）可能会发生碰撞o(1)，发生碰撞为o(k)
删除数据（Delete）removeo(1)

特点

键对值

常见操作

创建哈希表

String[] hashTable = new String[4];
HashMap<Integer,String> map = new HashMap<>();

添加元素 o(1)

hashTable[1] = "abc";
map.put(1,"acd");

更新元素o(1)

hashTable[1] = "abc";
map.put(1,"acd");

删除元素o(1)

hashTable[1] = " ";
map.remove(1);

查找元素

boolean s = map.containKey(1);  //存在键值
boolean sdf = map.containsValue("sdf");//存在值

遍历o(1)

for (Integer m : map.keySet()){
    System.out.println(map.get(m));
}

for (String m : map.values()){
    System.out.println(m);
}

Set<Map.Entry<Integer, String>> entries = map.entrySet();
for (Map.Entry<Integer, String> e : entries){
    System.out.println(e);
}
//1=sdf
//2=saq

长度o(1)

int size = map.size();

哈希冲突
哈希冲突是指hash出来的地址被其他元素所占用；
解决的方法
JAVA为链地址法
解决的思路就是当出现冲突的时候将冲突的元素加入当前的链表之中

集合Set

定义

由一组无序且不重复的项组成的，根据哈希值计算储存位置，如冲突，JAVA加链表

访搜插删

操作表达式复杂度
数据访问（Access）不可
数据搜索（Search）keyo(1)
插入数据（Insert）可能会发生碰撞o(1)，发生碰撞为o(k)
删除数据（Delete）removeo(1)

特点

不重复，无序

常见操作

创建集合

Set<Integer> s = new HashSet<>();

添加元素 o(1)

s.add(2);

删除元素o(1)

s.remove(1);

查找元素

boolean sdf = s.contains(1);//存在值

遍历o(1)

 for (int a : s){
     System.out.println(a);
}

长度o(1)

int size = s.size();

树Tree

树由n(n≥1)个有限节点组成一个具有层次关系的集合。每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点。没有孩子的叫做叶子节点。
在这里插入图片描述
在这里插入图片描述
二叉树：每个节点最多含有两个子树的树称为二叉树；
满二叉树：叶节点除外的所有节点均含有两个子树的树被称为满二叉树；
完全二叉树：除最后一层外，所有层都是满节点，且最后一层缺右边连续节点的二叉树称为完全二叉树；

遍历：
前序遍历：根、左、右
中序遍历：左、根、右
后序遍历：左、右、根

  TreeNode treeNode_6 = new TreeNode(6, null, null);
        TreeNode treeNode_5 = new TreeNode(5, null, null);
        TreeNode treeNode_4 = new TreeNode(4, null, null);
        TreeNode treeNode_3 = new TreeNode(3, treeNode_6, null);
        TreeNode treeNode_2 = new TreeNode(2, treeNode_4, treeNode_5);
        TreeNode treeNode_1 = new TreeNode(1, treeNode_2, treeNode_3);

        //确定二叉树的根节点
        TreeNode root = treeNode_1;
        //先序递归
        preOrderTraverse(root);
        System.out.println();
        //先序 借助栈
        preOrderByStack(root);
        System.out.println();

        //中序 递归
        inOrderTraverse(root);
        System.out.println();
        //中序 栈
        inOrderByStack(root);
        System.out.println();

        //后序 递归
        afterOrderTraverse(root);
        System.out.println();
        //后序 栈
        afterOrderByStack(root);
        System.out.println();

    }

    //先/前序遍历，根-左-右  每个节点循环左右，直至null
    public static void preOrderTraverse(TreeNode root) {
        if (root != null) {
            System.out.print(root.val + " ");
            preOrderTraverse(root.left);
            preOrderTraverse(root.right);
        }
    }

    //先/前序遍历 非递归（借助栈）
    public static void preOrderByStack(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null || !stack.isEmpty()) {   //当前节点存在 或 栈不为空
            while (root != null) {   //当前节点存在 左遍历树
                System.out.print(root.val + " "); //打印当前节点
                stack.push(root);       //当前节点进栈
                root = root.left;  //进入其左子树
            }
            if (!stack.isEmpty()) {      //如果栈不为空
                root = stack.pop();     //栈顶节点出栈
                root = root.right; //进入其右子树
            }
        }
    }

    //中序遍历

    public static void inOrderTraverse(TreeNode root) {
        if (root != null){
            inOrderTraverse(root.left);
            System.out.print(root.val + " ");
            inOrderTraverse(root.right);
        }
    }
    //中序遍历 非递归（借助栈）
    public static void inOrderByStack(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null || !stack.isEmpty()) {   //当前节点存在 或 栈不为空
            while (root != null) {   //当前节点存在 左遍历树
                stack.push(root);       //当前节点进栈
                root = root.left;  //进入其左子树
            }
            root = stack.pop();     //栈顶节点出栈
            System.out.print(root.val + " "); //打印当前节点
            root = root.right; //进入其右子树
        }
    }

    //后序遍历

    public static void afterOrderTraverse(TreeNode root) {
        if (root != null){
            afterOrderTraverse(root.left);
            afterOrderTraverse(root.right);
            System.out.print(root.val + " ");
        }
    }
    //后序遍历 非递归（借助栈）
    public static void afterOrderByStack(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode temp  = null;
        while (root != null || !stack.isEmpty()) {   //当前节点存在 或 栈不为空
            while (root != null) {   //当前节点存在 左遍历树
                stack.push(root);       //当前节点进栈
                root = root.left;  //进入其左子树
            }
            if (!stack.isEmpty()){      //栈不为空
                root = stack.peek();    //取栈顶元素，但栈顶元素不出栈
                //当前节点的右子树为空，或者 其右子树刚访问过
                if ((root.right== null) || (root.right == temp)){
                    root = stack.pop();     //栈顶节点出栈
                    System.out.print(root.val + " "); //打印当前节点
                    temp = root;        //将当前节点赋值给temp
                    root = null;        //将当前节点置空
                }else {
                    root = root.right; //进入其右子树
                }
            }
        }
    }

TreeSet

会进行自动排序，升序

TreeSet<Integer> t = new TreeSet<>();
t.add(4);
t.add(30);
t.add(90);
t.add(89);
System.out.println(t);
//[4, 30, 89, 90]

按照构造方法进行排序，利用比较器

TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });

s1 - s2 （升序）--------------------------： s2 - s1（降序）
s2.compareTo(s1)（a在后，升序）-： s1.compareTo(s2)（a在前：降序）

堆

定义：
堆（heap）也被称为优先队列（priority queue）。队列中允许的操作是先进先出（FIFO），在队尾插入元素，在队头取出元素。而堆也是一样，在堆底插入元素，在堆顶取出元素，但是堆中元素的排列不是按照到来的先后顺序，而是按照一定的优先顺序排列的。

是一种二叉树结构，完全二叉树
每个节点大于孩子节点： 最大堆，堆顶为最大值
每个节点小于孩子节点： 最小堆，堆顶为最小值

堆的时间复杂度：
无序的数转化为完全二叉树：o(n)
完全二叉树准换为堆，进行大小比较：
在这里插入图片描述
深度：h 节点数：N 当前层交换次数：C
h = 0 : N = (n+1)/2 , C= 0 ;
h = 1: N = (n+1)/4 , C=(n+1)/4 * 1 ;
h = 2: N = (n+1)/8 , C=(n+1)/8 * 2 ;
…
C=(n+1)/2^(h+1) * h
C的和：n/2* 和(i/2^i) = n/2*2(收敛于2)
o(n)

时间复杂度取决于树的高度h。而完全二叉树的树的高度为[logn]向下取整
h = logn

访搜插删

操作表达式复杂度
数据访问（Access）不可
数据搜索（Search）o(1)
插入数据（Insert）队尾o(logn)
删除数据（Delete）即将出列元素o(logn)

特点

排序，出堆顶

常见操作

创建队列

//create a min heap
PriorityQueue<Integer> minHeap = new PriorityQueue<>(); //优先级队列
//create a max heap
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());

添加元素 o(logn)

minHeap.add(10);
minHeap.add(8);
minHeap.add(9);
minHeap.add(11);
minHeap.add(2);

获取元素o(1)

minHeap.peek();  //获取堆顶元素

删除元素o(logn)

int temp3 = minHeap.poll(); //删除堆顶元素

遍历o(n)

 while(!queue.isEmpty()){
      int temp4 = minHeap.poll();
      System.out.println(temp4);
}  //遍历完删完

数组长度o(1)

int length = minHeap.size();
gan777777
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构：八大数据结构分析
weixin_42046829的博客
03-04 1396
数据结构分类 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。 常用的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等，如图所示： 线性表和非线性表 一、线性表 常见的线性表有：数组、队列、栈、链表 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，线性表就是数据排列成一条先一样的结构，每个线性表...
8个常见数据结构排序算法总结API
01-05
本文将详细探讨标题"8个常见数据结构排序算法总结API"所涵盖的知识点，包括这些排序算法的基本原理、实现方式以及在C语言中的应用。 首先，我们来逐一了解这8种常见的排序算法： 1. **冒泡排序**：冒泡排序是一种...
八大数据结构
lili的博客
02-28 693
常见的数据结构 如何选择合适的数据结构，向量、栈、队列、链表如何区分？ 首先列出一些最常见的数据结构，我们将逐一说明： 数组、栈、队列、链表、树、图、字典树（这是一种高效的树形结构，但值得单独说明）、散列表（哈希表） 数组 数组是最简单、也是使用最广泛的数据结构。栈、队列等其他数据结构均由数组演变而来。下图是一个包含元素（1，2，3和4）的简单数组，数组长度为4。 每个数据元素都关联一个...
数据结构：八大数据结构分类
weixin_34216107的博客
03-25 239
为什么80%的码农都做不了架构师？>>> ...
《程序是怎样跑起来的》第四章
weixin_30315905的博客
01-27 92
内存是计算机中重要的部件之一，它是与CPU进行沟通的桥梁。计算机中所有程序的运行都是在内存中进行的，因此内存的性能对计算机的影响非常大。内存地址用4位16进制和8位16进制表示的区别，一个内存地址代表一个字节（8bit）的存储空间。数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存，只有当该引用指向有效内存后，才可通过该数组变量来访问数组元素。链表是一种物理存储单元上非连续、非顺序的存储...
数据结构学习总结.doc
05-13
"数据结构学习总结" 数据结构是计算机科学中的一门基础学科，涵盖了数据的表示、存储、操作和分析等方面的知识。数据结构的学习对于计算机科学与技术专业的学生来说至关重要。本文将对《数据结构与算法》课程的知识...
五大常用算法总结，算法数据结构
04-07
在计算机科学中，算法和数据结构是两个至关重要的概念，它们共同构成了解决问题的基础。本文将对五种常见的算法进行总结，分别是贪婪算法、动态规划、分治算法、回溯算法和分支限界算法。 1. **贪婪算法**： 贪婪...
数据结构总结（自学、期末复习或考研备用）.pdf
01-16
数据结构是计算机科学中的核心概念，它涉及到如何有效地组织和管理数据，以便于高效地执行算法。本资料涵盖了数据结构的多个重要主题，包括线性表、顺序表、链表、栈、队列、串、数组、广义表、树、二叉树、图、查找...
五大常用算法总结 (1)，算法数据结构
04-07
本文将对五种常用算法进行总结，分别是贪婪算法、动态规划、分治算法、回溯算法和分支限界算法。 1. **贪婪算法**： 贪婪算法是一种基于局部最优选择的策略，它在每一步都选择当前看起来最好的解决方案。然而，...
数据结构：八大数据结构分类及图解.pdf
07-11
数据结构：⼋⼤数据结构分类及图解 ⽬录 数据结构分类 数据结构分类 数据结构是指相互之间存在着⼀种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。 常⽤的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等，如图所⽰： 每⼀种数据结构都有着独特的数据存储⽅式，下⾯为⼤家介绍它们的结构和优缺点。 1、数组 、数组 数组是可以再内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进⾏访问，数组下标从0开始。例 如下⾯这段代码就是将数组的第⼀个元素赋值为 1。 int[] data = new int[100]；data[0] = 1; 优点： 1、按照索引查询元素速度快 2、按照索引遍历数组⽅便 缺点： 1、数组的⼤⼩固定后就⽆法扩容了 2、数组只能存储⼀种类型的数据 3、添加，删除的操作慢，因为要移动其他的元素。 适⽤场景： 频繁查询，对存储空间要求不⼤，很少增加和删除的情况。 2、栈 、栈 栈是⼀种特殊的线性表，仅能在线性表的⼀端操作，栈顶允许操作，栈底不允许操作。 栈的特点是：先进后出，或者说是后进先出，从栈 顶放⼊元素的操作叫⼊栈，取出元
几个常用的数据结构
12-25
几个常用的数据结构封装,Vector List HashSet HashMap Queue
数据结构中八大排序算法
05-15
包括八大排序算法，每一种算法的代码优化。
【 数据结构 】---- 八大数据结构
Fanniexia的博客
10-10 215
数据结构一、数据结构的类型1. 数组2. 队列3. 栈4. 树5. 堆6. 图7. 链表8. 散列表二、数据结构在python下的实现 一、数据结构的类型 数据结构是计算机存储、组织数据的方式。 1. 数组 数组是可以再内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进行访问。 数组可以进行方便的查找，但是删除和增加相对来说复杂。数组一旦固定之后，就确定了，无法改变...
八大数据结构整理
ArtemisQin的博客
08-24 397
什么是数据结构？ 简单地说，数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对于某些操作是高效的，而对于其他操作则是低效的。首先我们需要理解各种数据结构，才能在处理实际问题时选取最合适的数据结构。 为什么需要数据结构？ 数据是计算机科学当中最关键的实体，而数据结构则可以将数据以某种组织形式存储，因此，数据结构的价值不言而喻。 无论你以何种方式解决何种问题，你都需要处理数...
你需要知道的8种数据结构
黑白相间...
03-30 473
转载：https://blog.csdn.net/ydm19891101/article/details/88785753 为了保证可读性，本文采用意译而非直译。另外，本文版权归原作者所有，翻译仅用于学习。 1976年，一个瑞士计算机科学家写一本书《Algorithms + Data Structures ...
八大基础数据结构
LuckyRascal的博客
03-18 1535
常用的数据结构数组（Array）队列（Queue）链表（Linked List）栈（Stack）树（Tree）散列表（Hash）堆（Heap）图（Graph） 数组（Array） 数组是最简单、使用最频繁的一种数据结构。它一种线性表数据结构，用一组连续的内存空间来存储一组相同类型的数据。 如上图所示，数据是按照顺序存储在内存的连续空间内，arr后面的[]代表下标，由于数据是存储在连续空间内的，所以每个数据的内存地址(在内存上的位置)都可以通过数组下标计算出来，从而可以直接访问目标数据，达到随机访问的目的。
八大数据结构——数组（一）
BaldIsImpossible的博客
02-23 592
八大数据结构——数组（一） 数据结构定义（百度解释）： 数据结构(data structure)是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。 常用的主要有八大类型：1.数组（Array）2.栈（Stack）3.链表（Linked List）4.图（Graph）5.散列表（哈希表）（Hash）6.队列（Queue）7.树（Tree）8.堆（Heap）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值