- 浏览: 3435629 次
- 性别:
- 来自: China
文章分类
- 全部博客 (536)
- ajax (1)
- Algorithm (14)
- Android (40)
- CSS/HTML... (2)
- defy (3)
- DesignPattern (2)
- dorado (0)
- Drools (6)
- English/日本語 (7)
- Flex (2)
- Framework (0)
- Google (3)
- hibernate (13)
- homework (3)
- HTML5 (0)
- IDE (29)
- java (45)
- javaee (7)
- Javascript (14)
- java组件 (5)
- jQuery (4)
- jsp (8)
- jsf (2)
- Linux (2)
- lucene (0)
- mysql (6)
- news (3)
- Oracle (8)
- other (4)
- PHP (5)
- Python (0)
- Software Engineering (3)
- spring (7)
- struts1.x (14)
- struts2.x (14)
- strolling in cloud (1)
- subject:javaEnhance (20)
- Tomcat (7)
- validator (3)
- 学习·方法·心得 (8)
- .NET (2)
- vba (6)
- groovy (5)
- grails (2)
- SWT (0)
- big data (1)
- perl (1)
- objective-c (50)
- product (1)
- mac (7)
- ios (188)
- ios-phone (2)
- ios-system (15)
- ios-network (5)
- ios-file (4)
- ios-db (1)
- ios-media (3)
- ios-ui (27)
- ios-openSource (6)
- ios-animation (5)
- ios-drawing (7)
- c (2)
- ios-app (2)
- ios-course (15)
- ios-runtime (14)
- ios-code (8)
- ios-thread (8)
- ios-LBS (2)
- ios-issue (1)
- ios-design (2)
- Jailbreak (2)
- cocos2d (0)
- swift (16)
- ios-framework (4)
- apple watch (4)
- ios-web (1)
- react native (3)
- TVOS (1)
- OpenGL (1)
最新评论
-
xiaobinggg:
...
Session机制详解 -
菜鸟学生会:
Drools规则工作流引擎开发教程网盘地址:http://pa ...
Drools入门-----------环境搭建,分析Helloworld -
wangyudong:
不是很好用,不支持自动化测试RESTful API,也不支持自 ...
Simple REST Client POST使用方法 -
Paul0523:
很棒的一篇文章,感谢楼主分享
Session机制详解 -
啸笑天:
获取原型对象的三种方法<script>functi ...
复习JavaScript面向对象技术
顺序栈的实现
import java.util.Arrays; public class SequenceStack<T> { private int DEFAULT_SIZE = 10; //保存数组的长度。 private int capacity; //定义当底层数组容量不够时,程序每次增加的数组长度 private int capacityIncrement = 0; //定义一个数组用于保存顺序栈的元素 private Object[] elementData; //保存顺序栈中元素的当前个数 private int size = 0; //以默认数组长度创建空顺序栈 public SequenceStack() { capacity = DEFAULT_SIZE; elementData = new Object[capacity]; } //以一个初始化元素来创建顺序栈 public SequenceStack(T element) { this(); elementData[0] = element; size++; } /** * 以指定长度的数组来创建顺序栈 * @param element 指定顺序栈中第一个元素 * @param initSize 指定顺序栈底层数组的长度 */ public SequenceStack(T element , int initSize) { this.capacity = initSize; elementData = new Object[capacity]; elementData[0] = element; size++; } /** * 以指定长度的数组来创建顺序栈 * @param element 指定顺序栈中第一个元素 * @param initSize 指定顺序栈底层数组的长度 * @param capacityIncrement 指定当顺序栈底层数组的长度不够时,底层数组每次增加的长度 */ public SequenceStack(T element , int initSize , int capacityIncrement) { this.capacity = initSize; this.capacityIncrement = capacityIncrement; elementData = new Object[capacity]; elementData[0] = element; size++; } //获取顺序栈的大小 public int length() { return size; } //入栈 public void push(T element) { ensureCapacity(size + 1); elementData[size++] = element; } //很麻烦,而且性能很差 private void ensureCapacity(int minCapacity) { //如果数组的原有长度小于目前所需的长度 if (minCapacity > capacity) { if (capacityIncrement > 0) { while (capacity < minCapacity) { //不断地将capacity长度加capacityIncrement, //直到capacity大于minCapacity为止 capacity += capacityIncrement; } } else { //不断地将capacity * 2,直到capacity大于minCapacity为止 while (capacity < minCapacity) { capacity <<= 1; } } elementData = Arrays.copyOf(elementData , capacity); } } //出栈 public T pop() { T oldValue = (T)elementData[size - 1]; //释放栈顶元素 elementData[--size] = null; return oldValue; } //返回栈顶元素,但不删除栈顶元素 public T peek() { return (T)elementData[size - 1]; } //判断顺序栈是否为空栈 public boolean empty() { return size == 0; } //清空顺序栈 public void clear() { //将底层数组所有元素赋为null Arrays.fill(elementData , null); size = 0; } public String toString() { if (size == 0) { return "[]"; } else { StringBuilder sb = new StringBuilder("["); for (int i = size - 1 ; i > -1 ; i-- ) { sb.append(elementData[i].toString() + ", "); } int len = sb.length(); return sb.delete(len - 2 , len).append("]").toString(); } } public static void main(String[] args) { SequenceStack<String> stack = new SequenceStack<String>(); //不断地入栈 stack.push("aaaa"); stack.push("bbbb"); stack.push("cccc"); stack.push("dddd"); System.out.println(stack); //访问栈顶元素 System.out.println("访问栈顶元素:" + stack.peek()); //弹出一个元素 System.out.println("第一次弹出栈顶元素:" + stack.pop()); //再次弹出一个元素 System.out.println("第二次弹出栈顶元素:" + stack.pop()); System.out.println("两次pop之后的栈:" + stack); } }
链式栈的实现
public class LinkStack<T> { //定义一个内部类Node,Node实例代表链栈的节点。 private class Node { //保存节点的数据 private T data; //指向下个节点的引用 private Node next; //无参数的构造器 public Node() { } //初始化全部属性的构造器 public Node(T data , Node next) { this.data = data; this.next = next; } } //保存该链栈的栈顶元素 private Node top; //保存该链栈中已包含的节点数 private int size; //创建空链栈 public LinkStack() { //空链栈,top的值为null top = null; } //以指定数据元素来创建链栈,该链栈只有一个元素 public LinkStack(T element) { top = new Node(element , null); size++; } //返回链栈的长度 public int length() { return size; } //进栈 public void push(T element) { //让top指向新创建的元素,新元素的next引用指向原来的栈顶元素 top = new Node(element , top); size++; } //出栈 public T pop() { Node oldTop = top; //让top引用指向原栈顶元素的下一个元素 top = top.next; //释放原栈顶元素的next引用 oldTop.next = null; size--; return oldTop.data; } //访问栈顶元素,但不删除栈顶元素 public T peek() { return top.data; } //判断链栈是否为空栈 public boolean empty() { return size == 0; } //清空链栈 public void clear() { //将底层数组所有元素赋为null top = null; size = 0; } public String toString() { //链栈为空链栈时 if (empty()) { return "[]"; } else { StringBuilder sb = new StringBuilder("["); for (Node current = top ; current != null ; current = current.next ) { sb.append(current.data.toString() + ", "); } int len = sb.length(); return sb.delete(len - 2 , len).append("]").toString(); } } public static void main(String[] args) { LinkStack<String> stack = new LinkStack<String>(); //不断地入栈 stack.push("aaaa"); stack.push("bbbb"); stack.push("cccc"); stack.push("dddd"); System.out.println(stack); //访问栈顶元素 System.out.println("访问栈顶元素:" + stack.peek()); //弹出一个元素 System.out.println("第一次弹出栈顶元素:" + stack.pop()); //再次弹出一个元素 System.out.println("第二次弹出栈顶元素:" + stack.pop()); System.out.println("两次pop之后的栈:" + stack); } }
顺序队列的实现
import java.util.Arrays; public class SequenceQueue<T> { private int DEFAULT_SIZE = 10; //保存数组的长度。 private int capacity; //定义一个数组用于保存顺序队列的元素 private Object[] elementData; //保存顺序队列中元素的当前个数 private int front = 0; private int rear = 0; //以默认数组长度创建空顺序队列 public SequenceQueue() { capacity = DEFAULT_SIZE; elementData = new Object[capacity]; } //以一个初始化元素来创建顺序队列 public SequenceQueue(T element) { this(); elementData[0] = element; rear++; } /** * 以指定长度的数组来创建顺序队列 * @param element 指定顺序队列中第一个元素 * @param initSize 指定顺序队列底层数组的长度 */ public SequenceQueue(T element , int initSize) { this.capacity = initSize; elementData = new Object[capacity]; elementData[0] = element; rear++; } //获取顺序队列的大小 public int length() { return rear - front; } //插入队列 public void add(T element) { if (rear > capacity - 1) { throw new IndexOutOfBoundsException("队列已满的异常"); } elementData[rear++] = element; } //移除队列 public T remove() { if (empty()) { throw new IndexOutOfBoundsException("空队列异常"); } //保留队列的rear端的元素的值 T oldValue = (T)elementData[front]; //释放队列的rear端的元素 elementData[front++] = null; return oldValue; } //返回队列顶元素,但不删除队列顶元素 public T element() { if (empty()) { throw new IndexOutOfBoundsException("空队列异常"); } return (T)elementData[front]; } //判断顺序队列是否为空队列 public boolean empty() { return rear == front; } //清空顺序队列 public void clear() { //将底层数组所有元素赋为null Arrays.fill(elementData , null); front = 0; rear = 0; } public String toString() { if (empty()) { return "[]"; } else { StringBuilder sb = new StringBuilder("["); for (int i = front ; i < rear ; i++ ) { sb.append(elementData[i].toString() + ", "); } int len = sb.length(); return sb.delete(len - 2 , len).append("]").toString(); } } public static void main(String[] args) { SequenceQueue<String> queue = new SequenceQueue<String>(); //依次将4个元素加入队列 queue.add("aaaa"); queue.add("bbbb"); queue.add("cccc"); queue.add("dddd"); System.out.println(queue); System.out.println("访问队列的front端元素:" + queue.element()); System.out.println("移除队列的front端元素:" + queue.remove()); System.out.println("移除队列的front端元素:" + queue.remove()); System.out.println("两次调用remove方法后的队列:" + queue); } }
循环队列的实现
import java.util.Arrays; public class LoopQueue<T> { private int DEFAULT_SIZE = 10; //保存数组的长度。 private int capacity; //定义一个数组用于保存循环队列的元素 private Object[] elementData; //保存循环队列中元素的当前个数 private int front = 0; private int rear = 0; //以默认数组长度创建空循环队列 public LoopQueue() { capacity = DEFAULT_SIZE; elementData = new Object[capacity]; } //以一个初始化元素来创建循环队列 public LoopQueue(T element) { this(); elementData[0] = element; rear++; } /** * 以指定长度的数组来创建循环队列 * @param element 指定循环队列中第一个元素 * @param initSize 指定循环队列底层数组的长度 */ public LoopQueue(T element , int initSize) { this.capacity = initSize; elementData = new Object[capacity]; elementData[0] = element; rear++; } //获取循环队列的大小 public int length() { if (empty()) { return 0; } return rear > front ? rear - front : capacity - (front - rear); } //插入队列 public void add(T element) { if (rear == front && elementData[front] != null) { throw new IndexOutOfBoundsException("队列已满的异常"); } elementData[rear++] = element; //如果rear已经到头,那就转头 rear = rear == capacity ? 0 : rear; } //移除队列 public T remove() { if (empty()) { throw new IndexOutOfBoundsException("空队列异常"); } //保留队列的rear端的元素的值 T oldValue = (T)elementData[front]; //释放队列的rear端的元素 elementData[front++] = null; //如果front已经到头,那就转头 front = front == capacity ? 0 : front; return oldValue; } //返回队列顶元素,但不删除队列顶元素 public T element() { if (empty()) { throw new IndexOutOfBoundsException("空队列异常"); } return (T)elementData[front]; } //判断循环队列是否为空队列 public boolean empty() { //rear==front且rear处的元素为null return rear == front && elementData[rear] == null; } //清空循环队列 public void clear() { //将底层数组所有元素赋为null Arrays.fill(elementData , null); front = 0; rear = 0; } public String toString() { if (empty()) { return "[]"; } else { //如果front < rear,有效元素就是front到rear之间的元素 if (front < rear) { StringBuilder sb = new StringBuilder("["); for (int i = front ; i < rear ; i++ ) { sb.append(elementData[i].toString() + ", "); } int len = sb.length(); return sb.delete(len - 2 , len).append("]").toString(); } //如果front >= rear,有效元素为front->capacity之间、0->front之间的 else { StringBuilder sb = new StringBuilder("["); for (int i = front ; i < capacity ; i++ ) { sb.append(elementData[i].toString() + ", "); } for (int i = 0 ; i < rear ; i++) { sb.append(elementData[i].toString() + ", "); } int len = sb.length(); return sb.delete(len - 2 , len).append("]").toString(); } } } public static void main(String[] args) { LoopQueue<String> queue = new LoopQueue<String>("aaaa" , 3); //添加两个元素 queue.add("bbbb"); queue.add("cccc"); //此时队列已满 System.out.println(queue); //删除一个元素后,队列可以再多加一个元素 queue.remove(); System.out.println("删除一个元素后的队列:" + queue); //再次添加一个元素,此时队列又满 queue.add("dddd"); System.out.println(queue); System.out.println("队列满时的长度:" + queue.length()); //删除一个元素后,队列可以再多加一个元素 queue.remove(); //再次加入一个元素,此时队列又满 queue.add("eeee"); System.out.println(queue); } }
链式队列的实现
public class LinkQueue<T> { //定义一个内部类Node,Node实例代表链队列的节点。 private class Node { //保存节点的数据 private T data; //指向下个节点的引用 private Node next; //无参数的构造器 public Node() { } //初始化全部属性的构造器 public Node(T data , Node next) { this.data = data; this.next = next; } } //保存该链队列的头节点 private Node front; //保存该链队列的尾节点 private Node rear; //保存该链队列中已包含的节点数 private int size; //创建空链队列 public LinkQueue() { //空链队列,front和rear都是null front = null; rear = null; } //以指定数据元素来创建链队列,该链队列只有一个元素 public LinkQueue(T element) { front = new Node(element , null); //只有一个节点,front、rear都指向该节点 rear = front; size++; } //返回链队列的长度 public int length() { return size; } //将新元素加入队列 public void add(T element) { //如果该链队列还是空链队列 if (front == null) { front = new Node(element , null); //只有一个节点,front、rear都指向该节点 rear = front; } else { //创建新节点 Node newNode = new Node(element , null); //让尾节点的next指向新增的节点 rear.next = newNode; //以新节点作为新的尾节点 rear = newNode; } size++; } //删除队列front端的元素 public T remove() { Node oldFront = front; front = front.next; oldFront.next = null; size--; return oldFront.data; } //访问链式队列中最后一个元素 public T element() { return rear.data; } //判断链式队列是否为空队列 public boolean empty() { return size == 0; } //清空链队列 public void clear() { //将front、rear两个节点赋为null front = null; rear = null; size = 0; } public String toString() { //链队列为空链队列时 if (empty()) { return "[]"; } else { StringBuilder sb = new StringBuilder("["); for (Node current = front ; current != null ; current = current.next ) { sb.append(current.data.toString() + ", "); } int len = sb.length(); return sb.delete(len - 2 , len).append("]").toString(); } } public static void main(String[] args) { LinkQueue<String> queue = new LinkQueue<String>("aaaa"); //添加两个元素 queue.add("bbbb"); queue.add("cccc"); System.out.println(queue); //删除一个元素后 queue.remove(); System.out.println("删除一个元素后的队列:" + queue); //再次添加一个元素 queue.add("dddd"); System.out.println("再次添加元素后的队列:" + queue); //删除一个元素后,队列可以再多加一个元素 queue.remove(); //再次加入一个元素 queue.add("eeee"); System.out.println(queue); } }
发表评论
-
qweqwe
2012-07-11 16:06 1江蛤蟆 一统江湖 -
123123123
2012-07-11 16:04 0<p>法轮</p> -
母牛繁殖问题
2011-12-30 13:08 3833question:农场的母牛寿命是5年,母牛第二年和第四年会繁 ... -
树形显示
2011-07-17 11:26 1638/** 树形结构应用十分广泛。 下面这段代码根据 ... -
求能除尽1至n的最小整数
2011-07-16 02:43 3957为什么1小时有60分钟,而不是100分钟呢?这是历史上的 ... -
java 四则运算 栈的实现
2011-07-15 13:42 13842import java.util.Stack; /* ... -
用1、2、3、3、4、5这六个数字,用java写一个程序,打印出所有不同的排列 要求:"4"不能在第三位,"3"与"5"不能相连。
2011-07-15 12:45 3370用1、2、3、3、4、5这六 ... -
【code】java红黑树
2011-06-28 10:07 3439import java.util.*; publi ... -
【code】java实现排序二叉树
2011-06-27 21:45 2855import java.util.*; publi ... -
【code】java创建哈夫曼树和实现哈夫曼编码
2011-06-27 17:31 12877创建哈夫曼树 主要思想: (1)对List集合中所有节点进 ... -
【code】java实现十种常见内部排序
2011-06-20 19:22 3074常见的内部排序: 下面介绍这十种常见内部排序(都是从 ... -
【code】java二叉树深(先中后)、广遍历
2011-06-19 16:55 1951import java.util.*; publi ... -
【code】java二叉树的实现
2011-06-17 22:50 5848二叉树的顺序存储 public class Array ... -
【code】java树的实现
2011-06-17 22:20 11948树的父节点存储实现 import java.util. ... -
【code】java线性表实现
2011-06-16 21:24 3658顺序线性表的实现 import java.util.A ...
相关推荐
Java code Java code Java code Java code Java code Java code Java code
智慧酒店项目智能化系统汇报方案qy.pptx
基于C语言编写的高并发Epoll服务器.zip
liba2ps1-4.14-bp156.5.5.ppc64le
基于matlab实现囚徒困境中的博弈策略的模拟:尝试了采用几种策略进行博弈使最终双赢的概率变大.rar
毕业设计:springboot的乐器社区网站设计与实现(源码 + 数据库 + 说明文档) 2相关技术介绍 3 2.1 MySQL数据库简介 3 2.2 springboot编程技术 3 2.3 VUE框架 3 2.4 B/S结构 4 3系统可行性分析 5 3.1概况 5 3.2可行性研究的前提 5 3.3可行性分析 6 3.3.1技术的可行性 6 3.3.2经济的可行性 6 3.3.3操作可行性 6 3.3.4法律的可行性 7 3.4设计的基本思想 7 3.5性能需求 7 3.5.1系统的安全性 7 3.5.2数据的完整性 7 4 系统设计 9 4.1总体设计 9 4.2数据库的分析与设计 9 4.3数据库表 10 第五章 系统功能实现 12 5.1 乐器社区网站首页界面 12 5.2 乐器信息列表界面 12 5.3管理员管理界面 13 5.4新建乐器信息界面 14 5.5二手商品购买界面 14 6 系统测试 15 6.1测试说明 15 6.2功能测试 15 6.3可用性测试 15 6.5性能测试 16 6.6用例测试 16 6.7测试结果 16
2024-2030全球及中国鼓机踏板行业研究及十五五规划分析报告
毕业设计:基于springboot的中小企业财务管理系统(源码 + 数据库 + 说明文档) 2 开发技术简介 6 2.1 基于B/S结构开发 6 2.2 jsp语言简介 6 2.3MYSQL简介 6 2.4 eclipse工具 7 3 需求分析 7 3.1 可行性分析 7 3.1.1 经济可行性 7 3.1.2 技术可行性 7 3.1.3 操作可行性 7 3.2 功能需求分析 8 3.3 非功能需求分析 8 4 系统设计 9 4.1 数据库设计 9 4.2 系统模块总体设计 10 5 系统详细设计 10 5.1 后台登录页面 10 5.2 管理员信息 11 5.3 财务人员信息 11 5.4 资产负债 12 5.5 税收管理 12 6 系统测试 13 6.1 测试的目的 13 6.2 测试的方法 13 6.3 测试的重要性 14 6.4 测试内容 14 6.5 测试结果 14
基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构建基于神经网络的图片识别系统源码.zip基于Springboot集成yolo3构
基于C#的开源音乐播放器MetroPlayer.zip
MD5哈希算法的C++实现(兼容大端字节序的CPU) 测试代码 #include<iostream> #include<iomanip> #include"md5.c" int main() { using namespace std; u8 $finalHash[16] = {}; const char* str = "a"; //调用MD5 int ret = MD5((u8*)str, strnlen_s(str, INT_MAX), $finalHash); cout << ret << "\n\n"; //输出结果 for (int i = 0; i < 16; i++) { cout << hex << setw(2) << setfill('0') << int($finalHash[i]); } cout << "\n\n"; return 0; }
2024新版Java基础从入门到精通全套视频+资料下载
项目基于Proteus仿真,使用at89c52作为主控芯片,输出PWM波,通过按键设置PWM波的频率和占空比,并且将频率和占空比显示在数码管上。
2024年全球油性皮肤保湿霜行业总体规模、主要企业国内外市场占有率及排名
附件是Windows系统下安装与配置Neo4j的步骤,包含具体的操作步骤, 文件绿色安全,仅供学习交流使用,欢迎大家下载学习交流!
本Bash脚本用于自动化管理Java JAR应用的启动、停止及监控。首先检查JAR进程是否在运行,如在运行则安全终止。随后,使用预设的Java参数启动JAR文件,并将输出和错误日志重定向至日志文件。启动后,脚本持续监控JAR进程状态,确保其在预设时间内成功启动。本脚本提供了灵活的配置和错误处理机制,为Java应用的运维管理带来了便捷与可靠性。
【基于Python+Django的毕业设计】基于大数据反电信诈骗管理系统(源码+录像演示+说明).zip 【项目技术】 python+Django+mysql 【实现功能】 主要的功能有文本分析、文本管理、修改密码、个人信息和用户管理。 详见:https://blog.csdn.net/Timi2019/article/details/138357613
libAvogadro1-1.98.1-bp156.1.1.ppc64le
本系统从使用者角度看,分为学生群体、教师群体。学生及教师都在本系统中录入自己的基本信息。当学生需要请假的时候,可以直接在本系统上填写请假事由、请假时间及返校时间,提交申请即可,然后关注老师的审批进度;当老师在系统上查询到请假信息记录时,审批确认是否同意批复学生的请假意向;当老师审批完成之后,学生就可以看到老师对请假单的审批结果。 高校学生请假管理系统可以让老师和学生在任何时间、任何地点都可以完成请假的整个流程工作。系统会有请假历史记录,学校可以按照月、季度、年度对学生的请假情况进行分析。因此,本系统大大提高了学生请假的效率,同时也有助于学校分析学生请假的情况。 关键字:请假;审批;学生;ssm框架;jsp技术;MySQL数据库;
智慧物流园区整体解决方案--物流园区、物流枢纽、多式联运qy.pptx