执妄

一、节点package weightGraph;public class Vertex { public char label; public boolean isInTree; //Tree,该顶点在最小生成树里,反之就不在 public Vertex(char label) { this.label = label; this.isInTree = false; }}二、边package weightGraph;pu

package graph;import java.util.*;public class GraphTopo { //属性 private Vertex[] vertexList; //保存图中顶点的数组 private int[][] adjMat; //邻接矩阵 private int nVerts; //图中存在的节点的计数器 private Stack<Integer> theStack; //实现深度优先搜索的栈 pr

图package graph;import java.util.*;/** * 封装图的类 */public class Graph { //属性 private Vertex[] vertexList; //保存图中顶点的数组 private int[][] adjMat; //邻接矩阵 private int nVerts; //图中存在的节点的计数器 private Stack<Integer> theStack; //实现

堆package heap;public class HeapTest { public static void main(String[] args) { Heap heap = new Heap(100); heap.insert(55); heap.insert(33); heap.insert(66); heap.insert(11); heap.insert(22); he

一、线性探索法package hashtable;public class MyHashTableTest { //测试哈希表的入口 public static void main(String[] args) { MyHashTable myHashTable = new MyHashTable(100); myHashTable.insert(new DataItem(12)); myHashTable.insert(new Data

一、为什么要有红黑树如果插入的数据是有序的，这样二叉树逻辑结构和链表就没有区别了。二、红黑树的特征每个节点不是红色就是黑色根节点总时黑色的如果节点是红色的，则它的子节点必须是黑色的。也就是从每个叶子到跟的所有路径上不能有两个连续的红色节点从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）...

一、定义左子树的节点值均小于根节点右子树的值均大于根节点二、基本操作1 创建节点类package tree;public class Node { private int data; private Node leftChild; private Node rightChild; public Node() {} public Node(int data) { this.data = data; } public i

快速排序package sort;import java.util.Arrays;public class QuickSortTest { public static void main(String[] args) { int[] data = {22,11,3,5,34,23,6,7,4}; quickSort(data, 0, data.length - 1); System.out.println(Arrays.toString(da

我取的间隔是2.2package sort;import java.util.Arrays;public class ShellSortTest { public static void main(String[] args) { //int[] nums = {1,2,4,5,3,7,20,6}; int[] nums = {2,1}; shellSort(nums); } //实现希尔排序 public s.

一、递归的定义递归就是在运行的过程中调用自己。递归必须要有三个要素：边界条件递归前进段递归返回段当边界条件不满足时，递归前进；当边界条件满足时，递归返回二、求阶乘package recursion;import java.util.Scanner;public class RecursionTest1 { public static void main(String[] args) { //提示 System.out.println("请输

定义一个链表接口package linked;public interface ListInterface<T> { //规定了链表应该实现哪些功能 //返回当前的节点个数 public int getSize(); //在链表表头添加新节点 public void addHead(T data); //在链表尾部添加新节点 public void addTail(T data);}带有迭代器的链表接口package lin

只能从链表头部插入和删除package linked;public class OrderLinkedListTest { public static void main(String[] args) { OrderLinkedList orderLinkedList = new OrderLinkedList(); orderLinkedList.insert(10); orderLinkedList.insert(0); .

双端链表package linked;public class DoubleLinkedListTest { public static void main(String[] args) { DoubleLinkedList doubleLinkedList = new DoubleLinkedList(); doubleLinkedList.addTail(1); doubleLinkedList.addHead(0); dou

单链表package linked;import jdk.swing.interop.SwingInterOpUtils;public class SingleLinkedListTest { public static void main(String[] args) { SingleLinkedList singleLinkedList = new SingleLinkedList(); singleLinkedList.addHead("A");

package queue;public class QueueTest3 { public static void main(String[] args) { PriorityQueue priorityQueue = new PriorityQueue(8); priorityQueue.insert(1); priorityQueue.insert(20); priorityQueue.insert(7);

package queue;/** * 双端队列 */public class QueueTest2 { public static void main(String[] args) { DoubleEndedQueue doubleEndedQueue = new DoubleEndedQueue(); doubleEndedQueue.addFirst(1); doubleEndedQueue.addFirst(2); d

package queue;/** * 实现自己的队列 */public class QueueTest1 { public static void main(String[] args) { MyQueue myQueue = new MyQueue(3); myQueue.insert(1); myQueue.insert(2); myQueue.insert(3); System.out.println

package stack;import java.util.Stack;/** * 括号匹配 */public class StackTest4 { public static void main(String[] args) { String s = "12<a[b{c}]>"; char[] sa = s.toCharArray(); Stack<Character> stack = new Stack&lt

package stack;import java.util.Stack;public class ExpressionTest { public static void main(String[] args) { String ex = "(1+2+3)*5-69"; double rs = midToRear(ex); System.out.println(rs); } //实现中缀表达式转换为后缀表达式 publ

package stack;/** * 反转字符串 */import java.util.Stack;public class StackTest3 { public static void main(String[] args) { String s = "How are you"; char[] sa = s.toCharArray(); Stack<Character> stack = new Stack<>

低级栈（不可扩容）package stack;public class StackTest1 { public static void main(String[] args) { LowerStack lowerStack = new LowerStack(3); lowerStack.push(1); lowerStack.push(2); lowerStack.push(3); while(!lowerSta

一、数组​ 数组是java语言内置的数据类型，它是一个线性的序列，所以可以快速的访问其他元素，数组和其他数据类型不同，当你创建了一个数组时，他的容量是不变的，而且在生命周期内也是不能改变的。JAVA数组会做边界检查，如果发现有越界现象，会报RuntimeException异常错误，检查边界的代价是效率。二、集合JAVA还提供其他集合，list,map,set,它们处理对象的时候就好像这些对象没有自己的类型一样，而是直接归根于Object，这样只需要创建一个集合，把对象放进去，取出时转换成自己的类型

package array;/** * 稀疏数组的压缩算法 */public class ArrayTest6 { public static void main(String[] args) { //压缩算法 Node[] arr1 = new Node[6]; arr1[0] = new Node(9, 7, 5); arr1[1] = new Node(1, 1, 3); arr1[2] = new No

package array;public class ArrayTest5 { public static void main(String[] args) { ArrayClassInsert arrayClassInsert = new ArrayClassInsert(100); arrayClassInsert.insert(11); arrayClassInsert.insert(12); arrayClassInser

package array;public class ArrayTest4 { public static void main(String[] args) { ArrayClassSelect arrayClassSelect = new ArrayClassSelect(100); arrayClassSelect.insert(6); arrayClassSelect.insert(18); arrayClassSelect

package array;/** * 冒泡排序算法对无序数组排序 */public class ArrayTest3 { public static void main(String[] args) { ArrayClassBud arrayClassBud = new ArrayClassBud(100); //新增数组元素 arrayClassBud.insert(11); arrayClassBud.insert(1

数组优缺点分析有序数组的优点：采用二分查找效率高 O(log⁡2n\log_2^nlog2n​)有序数组的缺点插入的时候，需要移动元素O(n)有序数组和无序数组共同缺点删除的时候都要移动元素O(n)package array;public class ArrayTest2 { //程序的入口 public static void main(String[] args) { OrderArray orderArray = new O

package array;/** * 删除和查找数据都存在问题，无法对重复值进行处理 */public class ArrayTest { //程序的执行入口，测试用 public static void main(String[] args) { ArrayClass arrayClass = new ArrayClass(100); //新增数组元素 arrayClass.insert(11); arrayCl