weixin_44893467的博客

package tree;public class BinaryTree<Key extends Comparable<Key>, Value> { private int N; private Node root; private class Node { public Key K; public Value V; public Node left; public Node right;

线性结构线性表栈队列他们均可以通过链表，数组的方式实现我们以线性表为例分析增删改查。增加数据。链表: 不连续的存储空间，有头插（单节点插入时间复杂度o(1)）尾插（**单节点插入时间复杂度o(1)**和中间插（单节点插入时间复杂度o(n)））头插就不进行解释。尾插：为什么尾插法也是o(1)，我们不是应该从头节点一直找到尾节点，从尾节点进行插入吗，如果只有头节点那么尾插法的插入速度为o(n)，但是我们可以附设指向表尾节点的指针，我们可以直接找到尾节点进行插入。中间插：寻找时间复杂度o(

package symbol;public class OrderSymbolTable<Key extends Comparable<Key>, Value> { private int N; private final Node head; //节点类 private class Node { private final Key k; private Value v; private Node

package symbol;public class SymbolTable<Key, Value> { private int N; private Node head; //节点类 private class Node { private Key k; private Value v; private Node next; public Node(Key k, Value v, Nod

package Queue;import java.util.Iterator;public class Queue<T> implements Iterable<T> { private Node first; private Node last; private int N; private class Node { public T item; public Node next; p

package stack;import java.util.Stack;public class ReversePolishNotation { public static void main(String[] args) { //中缀表达式3*（17-15）+18/6的逆波兰表达式如下 String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"}; int res.

括号匹配流程图package stack;public class Match { public static void main(String[] args) { String a = "11((()))"; System.out.println(a+"括号匹配？"+isMatch(a)); } public static boolean isMatch(String string) { //new 一个栈 St

public static void mergetSort(Comparable[] a) { //1.初始化辅助数组assist； assist=new Comparable[a.length]; //2.定义一个lo变量，和hi变量，分别记录数组中最小的索引和最大的索引； int lo=0; int hi=a.length-1; //3.调用sort重载方法完成数组a中，从索引lo到索引hi的元素的排序..

import java.util.Arrays;public class ShellSort { public static void main(String[] args) { Integer[] a = {1,3,5,7,9,2,4,6,8,10}; shellSort(a); System.out.println(Arrays.toString(a)); } public static void shellSort(Compa

内层数据交换其实就是冒泡，直到冒到比自己小的元素后边。import java.util.Arrays;public class Bubble { //public static void sort(Comparable[] a)：对数组内的元素进行排序 //private static boolean greater(Comparable v,Comparable w):判断v是否大于w //private static void exch(Comparable[] a,in

import java.util.Arrays;public class Bubble { //构造方法 Bubble()：创建Bubble对象 // 成员方法 //public static void sort(Comparable[] a)：对数组内的元素进行排序 //private static boolean greater(Comparable v,Comparable w):判断v是否大于w //private static void exch(Com

import java.util.Arrays;public class Bubble { //构造方法 Bubble()：创建Bubble对象 //成员方法 //public static void sort(Comparable[] a)：对数组内的元素进行排序 //private static boolean greater(Comparable v,Comparable w):判断v是否大于w //private static void exch(Comp

根据条件，对数据进行操作，得到结果好算法：用最短的时间，占用最少的内存得出结果时间复杂度，空间复杂度例子：求1到100的和public class Compare { //算1+100的效率 public static void main(String[] args) { one(); two(); } public static void one(){ long startTime=System.nanoTime(

散列函数：Hash(key)=Addr将查找表中的关键字映射成地址。冲突：把两个关键字或者两个以上的关键字映射到同一个地址。同义词：不同的关键字映射在同一个地址，这几个关键字称之为。散列表：存储关键字和存储地址直接映射关系的表。构造散列函数应该注意：1，散列函数的定义域要包含全部要存储的关键字。（不能有存不上的数据）。2，散列函数等概率，均匀的分布在整个地址空间。（也就是尽可能减少冲突）。3，散列函数尽量简单，能较短时间算出散列地址。常见的散列函数1， 直接定址法：H（Key）=a*key

数据结构排序之冒泡排序：1，直接插入排序2，折半插入排序3，希尔排序1，冒泡排序2，快速排序1，简单选择排序2，堆排序1，归并排序2，基数排序public static void main(String[] args) { int[] a = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}; minmaopao(a); maxmaopao(a); }从小到大排序 public static void minm

在网上学了数据结构时，碰到点问题，也顺便记录一下。自己跟着写了一个顺序表（低版本的ArrayList）。**第一个问题，**为什么有了ArrayList这么好的顺序表了，我们还要单独去实现呢？？？1，ArrayList有通用性，但是在碰到特性的时候可能失去了他的优势。2，ArrayList有大篇幅用不到方法，不如我们自己写的简便，浪费资源。第二个问题import java.util.Iterator;public class SquenceList<T> implements

import java.util.Iterator;public class LinkList<T> implements Iterable<T>{ @Override public Iterator<T> iterator() { return new Literator(); } private class Literator implements Iterator{ private Node n;

public class TwoWayLinkList<T> { private class Node { private T item; private Node pre; private Node next; public Node(T item, Node pre, Node next) { this.item = item; this.pre = pre;

快慢指针快慢指针指的是定义两个指针，这两个指针的移动速度一块一慢，以此来制造出自己想要的差值，这个差值可以让我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的两倍。代码实例：public class QuickSlowMid { //节点类 private static class Node<T> { T item; Node next; public Node(T item, Node next) {

有环与无环情况。。。测试代码：public class QuickSlowMid { //节点类 private static class Node<T> { T item; Node next; public Node(T item, Node next) { this.item = item; this.next = next; } } p

当快慢指针相遇时，我们可以判断到链表中有环，这时重新设定一个新指针指向链表的起点，且步长与慢指针一样为1，则慢指针与“新”指针相遇的地方就是环的入口。证明这一结论牵涉到数论的知识，这里略，只讲实现。这是一个哔哩哔哩老师错误的代码（bilibili里的2020JAVA基础-深入系统的学习数据结构与算法），我觉的逻辑是有一定的问题，会出现死循环。什么情况呢？？？？？当有环链表出现足够长的没环的地方，此时就有可能出现死循环，当圆环节点数为3时，slow和fast相遇只需要3步，当前边足够长temp还没走

循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结点，因为没有下一个元素了。要实现循环链表，我们只需要让单向链表的最后一个节点的指针指向头结点即可。循环链表的实现public class CirculationLinkList { static class Node<T> { T item; Node next; public Node(T item, Node next) {

栈的api设计栈类package stack;import java.util.Iterator;public class StackByLink<T> implements Iterable<T> { private int N; private Node head; //节点成员内部类 private class Node { public T item; public Node next;