首页
关于
留言
统计
友链
壁纸
影视
留言找电影
Search
1
java jdk17版本使用cglib报错问题解决
321 阅读
2
在Java中修复json数据,json格式不正确,如何在Java中修复不正确的json
117 阅读
3
Java实现双链表插入排序~渡星河全网首发
106 阅读
4
Java打印某年某月的日历~不调用函数
76 阅读
5
Java中判断是否是闰年
70 阅读
代码笔记
Java
css
Javascript
数据库
安卓开发
Java 功能实例
Java 封装
我的日常
影音分享
文案
恋爱问答
资源分享
电脑游戏
实用APP
登录
/
注册
Search
标签搜索
java
java作业
恋爱
动漫
3A大作
独行月球
电影分享
总之就是非常可爱
JavaScript
office
破解
mysql
vue
java打包
跨域
tomcat解决乱码
bug解决
tomcat
vscode
渡星河
累计撰写
94
篇文章
累计收到
30
条评论
首页
栏目
代码笔记
Java
css
Javascript
数据库
安卓开发
Java 功能实例
Java 封装
我的日常
影音分享
文案
恋爱问答
资源分享
电脑游戏
实用APP
页面
关于
留言
统计
友链
壁纸
影视
留言找电影
搜索到
81
篇与
的结果
2022-11-29
Java中使用循环遍历树
需要用到栈{card-describe title="思路分析"}思路说不了,直接上代码{/card-describe}创建一个Stack类,我这边写的是简易栈public class Stack { //此栈用于存放节点所以使用TreeNode定义数组 //定义size记录栈内元素 int size = 0; TreeNode[] arr = new TreeNode[100]; //写入栈方法 public void push(TreeNode val){ arr[size]=val; size++; } //出栈方法 public TreeNode pop(){ return arr[--size]; } //返回站内元素个数 public int size(){ return size; } //判断栈是否为空 public boolean empty(){ return size==0; } } 循环遍历的方法。结合上一篇文章使用此方法上一篇文章public void LoopTraversal(TreeNode root){ //创建临时变量 TreeNode x = null; //创建栈对象 Stack stack = new Stack(); //先把根节点压入栈用于循环的判断 stack.push(root); //判断栈是否为空 while (!stack.empty()){ //取出栈内元素进行左右节点判断 x = stack.pop(); if (x.rc != null) stack.push(x.rc); if (x.lc != null) stack.push(x.lc); System.out.print(x.data+"\t"); } }
2022年11月29日
15 阅读
0 评论
2 点赞
2022-11-29
Java中树的创建
有根树**从数学来看,树结构是一种特殊的图。同样可以认为是定义在一组元素之间的二元关系。两者之间有关系就引入一条边。但计算机中树和数学中的树又有不同,计算机中需要每一棵树指定一个特殊的唯一的顶点,称为根root,一棵一般意义上的树,只要指定了其中的一个顶点作为根。他就称着有根树,通过嵌套,小型有根树可以组合成规模更大的有根树。**有序树小型有根树组的更大的有根树节点称为父亲。这些小型的树称为孩子。同一个根节点的节点之间互称为兄弟,一个节点所拥有的孩子节点个数称为度(degree)。规定了各兄弟之间次序的树称之为有序树。我的总结当成双链表来看,也不难,这期的代码注释我写的很清楚节点类,定义节点public class TreeNode { TreeNode lc,rc,parent; //定义树的高度默认为0 int height = 0; //节点中保存的数据为int int data; //红黑树中使用color boolean color; } 方法类,用于定义树调用的方法的 public class TreeMethod { //用于记录节点数量 int size = 0; //添加根节点需要返回节点 public TreeNode addRootNode(int val){ //创建节点对象,有new就是创建对象 TreeNode root = new TreeNode(); //给根节点赋值 root.data = val; //对size进行加加,size记录节点数 size++; return root; } //添加左右分支节点method为true时默认为添加左节点,否则为右,root作为父亲节点 public TreeNode addRightOrLeftNode(TreeNode root,int val,boolean method){ //创建节点对象 TreeNode newNode = new TreeNode(); //对节点data赋值val newNode.data = val; //如果method为true执行判断语句中的代码 if (method) root.lc = newNode; //method不为true时执行 root.rc = newNode; //将节点的父亲节点指向root newNode.parent = root; //对size进行加加,size记录节点数 size++; //返回创建的节点 return newNode; } //使用递归来对树进行遍历(使用中序遍历) public void RecursionTraversal(TreeNode root){ //当root遍历到最后为空节点的时候结束 if (root == null) return; RecursionTraversal(root.lc); //中序遍历需要根节点输入到左右节点的中间 System.out.print(root.data + "\t"); RecursionTraversal(root.rc); } } 测试类,运行Java的类就是这个,上面两个类是辅助这个类测试的 public class TestTreeNode { public static void main(String[] args) { //创建方法调用类的对象 TreeMethod tree = new TreeMethod(); //调用TreeMethod类里面的addRootNode方法添加一个根节点 //并接收返回的节点 TreeNode root = tree.addRootNode(77); //给根节点添加一个左分支 TreeNode node44 = tree.addRightOrLeftNode(root,44,true); //给根节点添加一个右分支 TreeNode node55 = tree.addRightOrLeftNode(root,55,false); //遍历输出data 输出结果为44 77 55 tree.RecursionTraversal(root); } } 输出结果为:44 77 55
2022年11月29日
13 阅读
0 评论
1 点赞
2022-11-25
java 使用栈进行表达式计算
思路图{mtitle title="我的代码"/}package test; public class Work { public static void main(String[] args) { Chars chars = new Chars(); Number num = new Number(); String data = "( 5 +( (2 + 3 )* (4*5)))"; data = data.replace(" ", ""); char[] outchar = data.toCharArray(); int i = 0; do { switch (outchar[i]){ case '(': break; case '+': case '*': case '-': case '/': chars.push(outchar[i]); break; case ')': int one = num.pop(); int two = num.pop(); switch (chars.pop()) { case '+' -> num.push(one + two); case '-' -> num.push(one - two); case '*' -> num.push(one * two); case '/' -> num.push(one / two); default -> System.out.println("符号错误"); } break; default: String str = String.valueOf(outchar[i]); int nums = Integer.parseInt(str); num.push(nums); break; } i++; }while (i<outchar.length); System.out.println("结果是"+num.pop()); } } class Chars { char[] chararr = new char[10]; int top = -1; public void push(char val){ int size = chararr.length; if(top+1==size){ char[] temp = new char[size]; int tempTop = -1; while (top > -1){ tempTop++; temp[tempTop]=pop(); } chararr = temp; top = tempTop; tempTop = -1; char[] newArr = new char[size*2]; while (top > -1){ tempTop++; newArr[tempTop]=pop(); } top = tempTop; chararr = newArr; } top++; chararr[top]=val; } public char pop(){ char res =chararr[top]; top--; return res; } } class Number{ int[] numarr = new int[10]; int top = -1; public void push(int val){ int size = numarr.length; if(top+1==size){ int[] temp = new int[size]; int tempTop = -1; while (top > -1){ tempTop++; temp[tempTop]=pop(); } numarr = temp; top = tempTop; tempTop = -1; int[] newArr = new int[size*2]; while (top > -1){ tempTop++; newArr[tempTop]=pop(); } top = tempTop; numarr = newArr; } top++; numarr[top]=val; } public int pop(){ int res = numarr[top]; top--; return res; } public int top(){ if (top == -1) return 0; return numarr[top]; } }{mtitle title="鹏哥的代码"/}//计算表达式 public class Caculate { public static void main(String[] args) { //创建存储操作符和操作数栈对象 Ops ops = new Ops(); Val vals = new Val(); //定义测试数据,规定:本实例只支持个位数的整数加减乘除 String data = "( 5 +( (2 + 3 )* (4*5)))"; //使用字符串String类的replace()方法,去掉字符串中的空格。 data = data.replace(" ", ""); //把字符串转换成字符数组,只需要调用字符串的toCharArray()方法即可。 char[] chars = data.toCharArray(); //遍历字符数组获取单个的字符。 for(int x = 0; x < chars.length; x++) { char s = chars[x];//拿到单个字符 //逐个判断当前字符是操作符还是操作数 //如果是操作符就压入操作符栈中。 if(s == '(');//我们规定计算式忽略左括号 else if (s == '+') ops.push(s); else if (s == '-') ops.push(s); else if (s == '*') ops.push(s); else if (s == '/') ops.push(s); else if (s == ')') { //如果遇到右括号,此时我们需要从操作符栈中取出一个操作符, //从操作数栈中取出两个操作数,然后计算结果并再次压入操作数栈中 char op = ops.pop(); int v = vals.pop(); //判断取出来的操作符op属于哪一种运算符 if(op == '+') v = vals.pop() + v; else if(op == '-') v = vals.pop() - v; else if(op == '*') v = vals.pop() * v; else if(op == '/') v = vals.pop() / v; //把计算完成之后还需要把数据再次压入操作数栈中 vals.push(v); } else { //把字符转成字符串 String str = String.valueOf(s); //把字符串数据转成整数数据 int vl = Integer.parseInt(str); //如果属于操作数就压入操作数栈中 vals.push(vl); } } System.out.println(vals.pop()); System.out.println(vals.pop()); System.out.println(ops.pop()); } } //存放操作符的栈 class Ops { //因为我们的栈是基于数组来实现的,因此我们需要先创建数组。 static char[] c = new char[10]; //栈的属性top static int top = -1; //入栈方法 public static void push(char ch) { if(top < c.length) { c[++top] = ch; } } //出栈方法 public static char pop() { if(top > -1) return c[top--]; return '!'; } } //存放操作数的栈 class Val { //因为我们的栈是基于数组来实现的,因此我们需要先创建数组。 static int[] v = new int[10]; //栈的属性top static int top = -1; //入栈方法 public static void push(int value) { if(top < v.length) v[++top] = value; } //出栈方法 public static int pop() { if(top > -1) return v[top--]; return -2147483648; } }{alert type="info"}打印出结果为 105{/alert}
2022年11月25日
22 阅读
0 评论
0 点赞
2022-11-23
Java实现双链表插入排序~渡星河全网首发
{mtitle title="双链表实现插入排序"/}测试类package test; public class TestLinkedList { public static void main(String[] args) { LinkedList list = new LinkedList(); //在双链表尾部添加节点 list.addLast("cab"); list.addLast("bba"); list.addLast("bab"); list.addLast("abb"); list.addLast("bab"); //在双链表头部添加节点 list.addFirst("aaa"); System.out.println("--------------排序----------------"); //调用插入排序方法 list.insertSort(); //调用遍历函数 list.travers(); } }下面是插入排序的方法public void insertSort() { Node curr = first.next;//开始时从第二个节点开始往前看 while(curr != null) { Node prev = curr.prev; while(prev != null) { if (curr.data.compareTo(prev.data) < 0) {//如果当前节点小于前一个节点就继续往前查看 prev = prev.prev; } else break; } //因为在之后会改变当前节点的位置,所以先定义临时变量记录改变前的节点位置 Node cNext = curr.next; if (prev == null) {//如果找到的插入位置为头部直接删除节点后调用头插法 String val = curr.data; unlink(curr); addFirst(val); } else { //此部分逻辑完成把当前节点的前驱后后继关联上 //然后把当前节点插入到应该存在的位置,也就是prev之后。 curr.prev.next = curr.next; if (curr.next != null) { curr.next.prev = curr.prev; } curr.next = prev.next; prev.next.prev = curr; prev.next = curr; curr.prev = prev; } curr = cNext; } }方法类调式的时候使用这个/*双链表测试类*/ public class TestLinkedList { public static void main(String[] args) { //要访问双链表中的方法,就需要使用new关键字创建该双链表的对象。 LinkedList list = new LinkedList(); //String str = new String("abc"); //调用list的添加方法 list.add("dcd"); list.add("bbc"); list.add("fgh"); list.add("bbc"); list.add("abc"); //调用遍历方法 //list.traverse(); //list.addFirst("world"); //list.remove(-2); //list.insert(4, "world"); list.traverse(); list.insertSort(); list.traverse(); } } /* 实现双链表 该类里的属性和方法都没有用关键字static修饰 所以访问这些属性和方法的时候都要使用对象的引用取访问 */ class LinkedList { //头节点 Node first = null; //尾节点 Node last = null; //记录节点个数 int size = 0; /*定义添加元素的方法*/ public void add(String val) { addLast(val); } /*尾插法*/ public void addLast(String val) { //要把val添加到链表中,需要做什么? //第一步:创建节点, Node newNode = new Node(); //第二步:把值val存入节点的数据区域 newNode.data = val; //首次添加节点时,头节点和尾节点都是null. if(last == null) { //首次添加需要把头节点和尾节点的引用都移动到指向第一个节点 first = newNode; last = newNode; } else {//非首次插入节点 last.next = newNode;//让链表的末节点的next域指向新创建的节点 newNode.prev = last;//让新创建节点的prev域指向链表的末节点 last = newNode;//最后把last移动到指向新创建的节点 } size++; } /*头插法*/ public void addFirst(String val) { //要把val添加到链表中,需要做什么? //第一步:创建节点, Node newNode = new Node(); //第二步:把值val存入节点的数据区域 newNode.data = val; //首次插入值头和尾节点都是null if(first == null) { first = newNode; last = newNode; } else { newNode.next = first; first.prev = newNode; first = newNode; } size++; } /*检查位置边界*/ public void checkBoundary(int position) { if (position < 0 || position > size) throw new RuntimeException("下标过了啊。。。。。。"); } /*该方法根据指定位置返回节点*/ public Node node(int position) { //定义临时遍历记录头节点 Node x = first; //查找position位置处的节点 for (int i = 1; i < position; i++) { x = x.next; } return x; } /*解除节点的关系*/ public Node unlink(Node x){ //定义变量记录需要删除的节点 Node item = x; //记录当前节点的next; Node next = x.next; //记录当前节点的prev Node prev = x.prev; if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } //x.data = null; size--; return item; } /*删除节点*/ public Node remove(int position) { //位置检查 checkBoundary(position); //调用方法根据位置查找节点 Node node = node(position); //解除引用并返回 return unlink(node); } /*把指定节点的数据域更新为指定的值*/ public void update(int position, String value) { //检查边界 checkBoundary(position); //查找需要更新的节点并设置新的值 node(position).data = value; } /*获取指定节点的值*/ public String get(int position) { return node(position).data; } /*指定位置插入一个节点*/ public void insert(int position, String value) { //单独处理插链表尾部 if((size + 1) == position) { addLast(value); return; } //单独处理插入链表头部 if (position == 1) { addFirst(value); return; } //查找到需要插入节点的位置 Node node = node(position); //获取当前节点的前一个节点 Node prevNode = node.prev; //创建节点 Node newNode = createNode(value); prevNode.next = newNode; newNode.prev = prevNode; newNode.next = node; node.prev = newNode; size++; } /*创建节点*/ public Node createNode(String val) { Node node = new Node(); node.data = val; return node; } /*去除重复节点*/ public void distinct() { Node one = first; int outSize = 1; while(one != null) { Node two = one.next; int count = outSize + 1; while(two != null) { if (one.data == two.data) { two = two.next; remove(count); } else { two = two.next; count++; } } outSize++; one = one.next; } } public void insertSort() { Node curr = first.next;//开始时从第二个节点开始往前看 while(curr != null) { Node prev = curr.prev; while(prev != null) { if (curr.data.compareTo(prev.data) < 0) {//如果当前节点小于前一个节点就继续往前查看 prev = prev.prev; } else break; } //因为在之后会改变当前节点的位置,所以先定义临时变量记录改变前的节点位置 Node cNext = curr.next; if (prev == null) {//如果找到的插入位置为头部直接删除节点后调用头插法 String val = curr.data; unlink(curr); addFirst(val); } else { //此部分逻辑完成把当前节点的前驱后后继关联上 //然后把当前节点插入到应该存在的位置,也就是prev之后。 curr.prev.next = curr.next; if (curr.next != null) { curr.next.prev = curr.prev; } curr.next = prev.next; prev.next.prev = curr; prev.next = curr; curr.prev = prev; } curr = cNext; } } /*遍历链表*/ public void traverse() { Node temp = first; while(temp != null) { System.out.print(temp.data + " "); temp = temp.next; } System.out.println(); } } class Node { //数据域 String data; //前驱引用 Node prev; //后继引用 Node next; }{alert type="success"}插入排序由千峰鹏哥完成{/alert}{mtitle title="运行结果"/}
2022年11月23日
106 阅读
0 评论
2 点赞
2022-11-21
Java单链表的使用
{card-default label="单链表" width="80%"}链表和数组同属于线性结构,他与数组是互补的。数组属于静态存储结构,而链表属于动态存储结构。链表是逻辑上连续的存储单元,但物理上不连续。链表的基本存储单元是节点(node),存储单元之间使用引用或指针相互链接。同一个数组只能存储同种数据类型的元素,链表也一样,同一个链表只能存储同种数据类型。链表可以为空。链表的第一个节点称为头节点,最后一个节点称为尾节点,当链表为空时,头节点和尾节点相同,都指向null。{/card-default}太懒了,不想写注释,直接给你们看老师的吧//测试类 public class TestSingleList { public static void main(String[] args) { SingleList.addTail(100); SingleList.addTail(1000); System.out.println("size : " + SingleList.size); } } //单链表数据模型类 class SingleList { //头节点 static Node first = null; //尾节点 static Node last = null; //节点数 static int size = 0; //添加-尾部 //value表示要存入节点数据域的值。 public static void addTail(int value) { //创建一个节点 Node newNode = new Node(); newNode.data = value; if (last == null) { first = newNode; last = newNode; } else { last.next = newNode; last = newNode; } size++; } //添加-头部 public static void addFirst(int value) { //创建一个节点 Node newNode = new Node(); newNode.data = value; if(first == null) { first = newNode; last = newNode; } else { newNode.next = first; first = newNode; } siez++; } //删除,position表示要删除的是第几个节点 public static void remove(int position) { //记录当前访问到了第几个节点 int count = 1; //变量指向当前节点的上一个节点 Node preCurrent = null; //定义变量指向需要查找的当前节点 Node current = first; while(current != null) { //当删除的是第一个节点时 if (position == 1) { first = first.next; current.next = null; return; } else if(position == count) { System.out.println("执行删除"); preCurrent.next = current.next; current.next = null;//断掉引用 return; } else { preCurrent = current; current = current.next; } count++; } } //更新, 把指定位置position的值更新为新的值newVal public static void update(int position, int newVal){ Node node = get(position); node.data = newVal; } //查找,按照位置访问 public static Node get(int position){ int count = 1; Node t = first; while(t != null) { if (position == count) { System.out.println(t.data); return t; } t = t.next; count++; } return null; } //查看链表中是否包含指定的值val public static void containes(int val){} //反转 public static void reverseList(){} //在指定位置插入一个节点 public static void insert(int position, int value) {} //遍历链表 public static void traverse() { //定义一个临时变量用于获取节点的数据 Node t = first; while(t != null) { System.out.println(t.data); t = t.next; } } } //节点类 class Node { int data; Node next; }
2022年11月21日
10 阅读
0 评论
1 点赞
1
...
14
15
16
17