Java常用的数据结构,Java常见的数据结构有哪些

　　00-1010 1.数据结构分类2。线性数据结构2.1数组2.2变量数组2.3链表2.4堆栈2.5队列3。非线性数据结构3.1树3.2图3.3哈希表3.4堆

1. 数据结构分类

　　00-1010数组是一种将元素存储在连续内存空间中的数据结构，并且要求元素属于同一类型。

　　//定义一个数组arrayint[] array=new int[5]，数组长度为5；//将array[0]=4赋给数组的元素；array[1]=3；array[2]=2；array[3]=1；array[4]=0；直接赋值：

　　//a way int[] array={4，3，2，1，0 }；//另一种方式int[] array=new int[]{4，3，2，1，0 }；

　　00-1010可变数组是一种长度灵活的数组，是在通用数组的基础上改进的，结合了扩展机制。

　　//定义一个变量数组list integer changable _ array=new ArrayList()；//将元素array.add(4)添加到变量数组的尾部；array . add(3)；array . add(2)；array . add(1)；array . add(0)；

　　00-1010链表可以定义为一个类，该类的包含两个成员变量的：节点的值Val，引用后继节点的next。节点是链表的基本单元，这种数据结构在内存空间中的存储地址是不连续的。

　　//定义链表类类ListNode {//node的值int val//后续节点的下一个引用ListNodeListNode(int x){ this。val=x；} }构建多个链表类的对象，并构建这些节点实例之间的引用指向：

　　节点头的节点值为2，其后继节点为节点n2，值为1。节点n2的节点值为1，其后继节点为节点n3，值为0。链表的头节点是head，尾节点是n3。//实例化节点ListNode head=new ListNode(2)；ListNode n2=新的ListNode(1)；ListNode n3=新的list node(0)；//建立三个节点之间的引用到head.next=n2n2.next=n3

　　00-1010栈是一种抽象的数据结构，特点是“后进先出”，可以用数组或者链表来实现。

　　//定义一个栈，使用Java的Vector类stackstackinteger Stack=new Stack()的子类；入栈操作 push()：

　　//元素0堆叠在stack.push(0)中；//元素1堆叠在stack.push(1)中；出栈操作 pop()：

　　//元素1 pops stack . pop()；//元素0超出stack . pop()；Java中可以使用Stack、ArrayDeque和LinkedList，但通常情况下，不建议使用Vector类及其子类Stack。

　　一般使用LinkedList来实现栈：

　　linked list integer stack=new linked list()；入栈操作 addLast()：

　　//元素0堆叠在stack.a中

　　ddLast(0);// 元素1入栈stack.addLast(1);出栈操作 removeLast()：

// 元素1出栈stack.removeLast();// 元素0入栈stack.removeLast();

2.5 队列

队列是一种抽象数据结构，特点是先进先出，可由链表实现。LinkedList类实现了Queue接口，因此可以把LinkedList当成Queue来用。

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

　　

入队操作 offer()：

// 元素0入队queue.offer(0);// 元素1入队queue.offer(1);

出队操作poll()，该函数的返回值为出队的那个元素：

// 元素0出队queue.poll();// 元素1出队queue.poll();

element()：返回第一个元素peek()：返回第一个元素区别：在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null。

queue.offer("a");queue.offer("b");queue.offer("c");queue.offer("d");queue.offer("e");queue.element(); //输出aqueue.peek(); //输出a

3. 非线性数据结构

3.1 树

树是一种非线性的数据结构，可分为二叉树和多叉树。二叉树可定义为一个类，该类包含三个成员变量：节点值val、左子节点left、右子节点right。

class TreeNode {    int val;    TreeNode left;    TreeNode right;    TreeNode(int x){        this.val = x;    }}

二叉树各节点实例化：

// 根节点rootTreeNode root = new TreeNode(0);TreeNode n2 = new TreeNode(1);TreeNode n3 = new TreeNode(2);TreeNode n4 = new TreeNode(3);TreeNode n5 = new TreeNode(4);

构建二叉树各节点之间的引用指向：

// 根节点的左子节点为n2，其值为1root.left = n2;// 根节点的右子节点为n3，其值为2root.right = n3;// 节点n2的左子节点为n4，其值为3n2.left = n4;// 节点n2的右子节点为n5，其值为4n2.right = n5;

3.2 图

图是一种非线性数据结构，由顶点（vertex）和边（edge）组成，每条边都连接着两个顶点。图分为有向图和无向图。

　　以无向图为例：

　　①顶点集合： vertices = {1, 2, 3, 4, 5}②边集合： edges = {(1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (3, 5), (4, 5)}（1）图的表示方法：邻接矩阵（无向图的邻接矩阵是一个斜对角对称矩阵）⭐邻接矩阵适用于存储稠密图，即顶点较多、边较少。

// 存储图的顶点int[] vertices = {1, 2, 3, 4, 5};// 存储图的边int[][] edges = {{0, 1, 1, 1, 1},                 {1, 0, 0, 1, 0},                 {1, 0, 0, 0, 1},                 {1, 1, 0, 0, 1},                 {1, 0, 1, 1, 0}};int[] vertices = {1, 2, 3, 4, 5};

（2）图的表示方法：邻接表

　　⭐邻接表适用于存储稀疏图，即顶点多、边较少。

// 存储图的顶点int[] vertices = {1, 2, 3, 4, 5};// 存储边的集合List<List<Integer>> edges = new ArrayList<>();// edge[i]表示图的顶点i对应的边集合List<Integer> edge_1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4));List<Integer> edge_2 = new ArrayList<>(Arrays.asList(0, 3));List<Integer> edge_3 = new ArrayList<>(Arrays.asList(0, 4));List<Integer> edge_4 = new ArrayList<>(Arrays.asList(0, 1, 4));List<Integer> edge_5 = new ArrayList<>(Arrays.asList(0, 2, 3));edges.add(edge_1);edges.add(edge_2);edges.add(edge_3);edges.add(edge_4);edges.add(edge_5);

3.3 散列表

散列表是一种非线性的数据结构，实质是将键（key）通过Hash函数完成到值（value）的映射。

// 初始化散列表Map<String, Integer> dict = new HashMap<>();

添加键 - 值对：

dict.put("python", 101);dict.put("c", 102);dict.put("java", 103);

通过键 key查找对应的值 value：

dict.get("python");    // 101dict.get("c");        // 102dict.get("java");    // 103

设计一个简单的Hash函数构建编程语言 ==> 编号的映射，构建一个散列表（假设不考虑低碰撞率、高鲁棒性）：

String[] program_lang = {"python", "c", "java"};int hash(int idx){    int index = (idx -1 % 100);    return index;}names[hash(101)];    // pythonnames[hash(101)];    // cnames[hash(101)];    // java

3.4 堆

（1）堆是一种基于完全二叉树的数据结构，可由数组实现。完全二叉树：一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1 ≤ i ≤ n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。（2）基于堆的原理实现的排序算法称为堆排序。（3）基于堆实现的数据结构称为优先队列。（4）堆分为大顶堆、小顶堆：①大顶堆：任意节点的值不大于其父节点的值，即根节点最大，任意子节点小于等于父节点。②小顶堆：任意节点的值不小于其父节点的值，即根节点最小，任意子节点大于等于父节点。

// 初始化小顶堆，操作为 优先队列Queue<Integer> heap = new PriorityQueue<>();

元素入堆add()：

// 元素入堆heap.add(0);heap.add(4);heap.add(2);heap.add(6);heap.add(8);

元素出堆 poll()：

// 元素出堆（从小到大）heap.poll(); // -> 0heap.poll(); // -> 2heap.poll(); // -> 4heap.poll(); // -> 6heap.poll(); // -> 8

到此这篇关于常用的Java数据结构知识点汇总的文章就介绍到这了,更多相关常用的Java数据结构分享内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。