冒泡排序：
import java.util.Arrays;
public class Bubbling {
/**
* @param args
* 冒泡排序：
*
* 假设有 N 个数据需要排序，则从第 0 个数开始，依次比较第 0 和第 1 个数据，
*如果第 0 个大于第 1 个则两者交换，否则什么动作都不做，继续比较第 1 个第 2
*个…，这样依次类推，直至所有数据都“冒泡”到数据顶上。
* 冒泡排序的效率O（N*N），比较 N*N/2，交换 N*N/4；
*
*/
public int[] result(int[] array){ //int型可以换成是Object，但数组元素必须实现compareto（）方法。
if(array.length==0){
return array;
}else{
int length,temp;
length = array.length;
for(int i=1;i<length;i++){
for(int a=0;a<length-i;a++){
if(array[a]>array[a+1]){
temp =array[a];
array[a]=array[a+1];
array[a+1]=temp;
}
}
}
}
return array;
}
public static void main(String[] args) {
int[] a =new int[5];
a[0]=1;
a[1]=5;
a[2]=3;
a[3]=0;
a[4]=6;
Bubbling bubbling = new Bubbling();
a=bubbling.result(a);
System.out.println(Arrays.toString(a));
}
快速排序：
public class QuickSort
{
/**
* @them 快速排序
* 对冒泡排序的改进：首先选一个轴值，将待排序的数据分为两个独立的两部分，左侧小于轴值，右侧大于轴值
* 然后分别对这两部分重复上述部分，直到整个序列有序。
*/
public static void main(String[] args)
{
quicksort qs = new quicksort();
int data[] = {44,22,2,32,54,22,88,77,99,11};
qs.data = data;
qs.sort(0, qs.data.length-1);
qs.display();
}
}
class quicksort
{
public int data[];
private int partition(int sortArray[],int low,int hight)//划分
{
int key = sortArray[low];
while(low<hight)
{
while(low<hight && sortArray[hight]>=key)
hight--;
sortArray[low] = sortArray[hight];
while(low<hight && sortArray[low]<=key)
low++;
sortArray[hight] = sortArray[low];
}
sortArray[low] = key;
return low;
}
public void sort(int low,int hight)
{
if(low<hight)
{
int result = partition(data,low,hight);//把整体分成独立的两部分，返回轴值位置
sort(low,result-1);//左侧重复
sort(result+1,hight);//右侧重复
}
}
public void display()
{
for(int i=0;i<data.length;i++)
{
System.out.print(data[i]);
System.out.print(" ");
}
}
}
插入排序：
import java.util.Arrays;
public class InsertionSort {
/**
* @param args
* @author mayi
*
* 插入排序 是在部分数据有序的情况下，使用 OUT 标记第一个无序的数据，将
其提取保存到一个中间变量 temp 中去，使用 IN 标记空位置，依次比较 temp 中
的值与 IN‐1 的值，如果 IN‐值大于 temp 的值，则后移，直到遇到第一个比temp
小的值，在其下一个位置插入；
插入排序的效率：O （N*N）, 比较 N*N/4，复制 N*N/4；插入排序在随机数的
情况下，比冒泡快一倍，比选择稍快；在基本有序的数组中，插入排序几乎只需
要 O （N）；在逆序情况下，并不比冒泡快；
*
*
*/
public int[] getResult(int[] objects){
int temp,in,out;
for(out=1;out<objects.length;out++){
temp =objects[out];
in =out;
while(in>0&&objects[in-1]>temp){
objects[in]=objects[in-1];
--in;
}
objects[in]=temp;
}
return objects;
}
public static void main(String[] args) {
int[] a={1,3,2,4,0};
InsertionSort insertionSort =new InsertionSort();
a=insertionSort.getResult(a);
System.out.println(Arrays.toString(a));
}
}
希尔排序：
import java.util.Arrays;
public class Shell_Sort {
/*
* @them 希尔排序
* 是对插入排序的改进，先将整个分成若干个，再在若干个里分别进行插入排序，然后再整体进行一次插入排序。
* 时间复杂度：O（NlogN）~O（N*N）
*/
public int[] shellSort(int[] theArray)
{
int inner=0,outer=0;
int nElems=theArray.length;
long temp=0;
int h=1; //find initial value of h
while(h<=nElems/3) //1,4,13,40,121,...
h=h*3+1;
while(h>0)
{
//当间隔h>1时，进行小部分插入排序；当间隔h=1时，进行整体插入排序
for(outer=h;outer<nElems;outer++)
{
temp=theArray[outer];
inner=outer;
while(inner>h-1&&theArray[inner-h]>=temp)
{
theArray[inner]=theArray[inner-h];
inner-=h;
}
theArray[inner]=(int) temp;
}
h=(h-1)/3; // 间隔从大减小，一直减小到1，此时因为间隔为1，就相当于是做整体的插入排序
}
return theArray;
}
public static void main(String[] args) {
int[] a={1,4,2,7,3,12,44,21,55,32,11};
Shell_Sort g=new Shell_Sort();
a=g.shellSort(a);
System.out.println(Arrays.toString(a));
}
}
选择排序：
import java.util.Arrays;
public class SelectSort {
/**
* @param args
* @author mayi
* @them 选择排序
* 假设有 N 条数据，则暂且标记第 0 个数据为 MIN（最小），使用 OUT 标记最左
边未排序的数据，然后使用 IN 标记第 1 个数据，依次与 MIN 进行比较，如果比
MIN 小，则将该数据标记为 MIN，当第一轮比较完后，最终的 MIN 与 OUT 标记
数据交换，依次类推；
选择排序的效率：O（N*N），比较 N*N/2，交换<N ； 选择排序与冒泡排序比
较，比较次数没有明显改变，但交换次数明显减少了很多；
*/
public int[] getResult(int[] objects){
int in,out,min,temp;
//如果数组为null，直接返回
if(objects==null||objects.length==0){
return objects;
}
for(out=0;out<objects.length-1;out++){
min =out;
//寻找最小值
for(in=out+1;in<objects.length;in++){
if(objects[min]>objects[in]){
min = in;
}
}
//与out交换位置
temp =objects[out];
objects[out]=objects[min];
objects[min]=temp;
}
return objects;
}
public static void main(String[] args) {
SelectSort ss = new SelectSort();
int[] a ={2,5,4,1};
a=ss.getResult(a);
System.out.println(Arrays.toString(a));
}
}
仪表可以采用Modbus-RTU模式进行上位机通讯，协议格式为：8个数据位、1个停止位、无校验位，发送接收数据都是以十六进制格式进行。
1、发送数据格式
发送字节
1
2
3
4
5
6
7
含义
地址
读/写
A1
A2
A3
A4
CRC
仪表地址
03H,04H,06H
校验码
说明：
1）参数的通讯地址用一个字节表示时，对应A2位置，A1默认为00H。
2）03、04指令均为读命令，其中04对应的数据不可写入，03与06地址对应参数地址，一个读取、一个写入。
3）A1、A2与A3、A4组成两个双字节的数据，CRC校验码是一个双字节数据，所有的数据都是高位在前，低位在后。
4）03、04指令读取数据时，A1、A2为开始读取的地址，A3、A4为连续读取数据的个数。
5）06指令中，A1、A2需要写入数据的地址，A3、A4表示要写入的数据。
2、返回数据格式
1）06指令写入数据时，发送与返回的数据一致。
2）03、04指令返回时局格式
返回字节
1
2
3
4
5
……
含义
地址
03/06
读/写
返回数据有效字节数
高字节
低字节
……
高字节
低字节
高字节
低字节
第一数据
……
第N数据
CRC
说明：返回数据字节数为：N*2
3、上位机连续下写数据位10指令，支持此指令的仪表有XM708、XM808、XM908、XM707P、XM808P、XM908P、XMH、XMA、XMS、XMT、XMJM。
10指令发送数据格式举例为：
发送数据
01
10
0000
0002
04
0000
0000
CRC
含义
地址
指令
连续下写的首地址
连续下写数据个数
总字节数据个数*2
下写的数据
校验码
附：
C# XOR CRC16 校验码计算类
C# 带多项式参数的 CRC16计算
C#串口调试工具 v2.0
在html中，<label> 标签为 input 元素定义标签（我称之为输入提示）。
label 元素不会向用户呈现任何特殊效果。它为鼠标用户改进了可用性。如果在 label 元素内点击文本，就会触发此input控件。就是说，当用户选择该标签时，浏览器就会自动将焦点转到和标签相关的表单控件上。
<label> 标签的 for 属性应当与相关元素的 id 属性相同。
比如：
<p>请点击文本标记之一，就可以触发相关控件：</p>
<form>
<label for="male">男</label>
<input type="radio" name="gender" id="male" />
<br />
<label for="female">女</label>
<input type="radio" name="gender" id="female" />
</form>
在具体使用时，如果 input 类型为 text ，一般将输入提示写在输入控件的左边；而 input 类型为 radio 或 checkbox 时，一般在输入控件的右边（也有写在左边的，如上面的例子）。
for 属性规定 label 与哪个表单元素绑定。
隐式和显式的联系
标记通常以下面两种方式中的一种来和表单控件相联系：将表单控件作为标记标签的内容，这样的就是隐式形式，或者为 <label> 标签下的 for 属性命名一个目标表单 id，这样就是显式形式。
例如，在 XHTML 中：
显式的联系：
<label for="SSN">Social Security Number:</label>
<input type="text" name="SocSecNum" id="SSN" />
隐式的联系：
<label>Date of Birth: <input type="text" name="DofB" /></label>
第一个标记是以显式的形式将文本 "Social Security Number:" 和表单的社保号的文本输入控件 ("SocSecNum") 联系起来，它的 for 属性的值和控件的 id 一样，都是 SSN。
第二个标记 ("Date of Birth:") 不需要 for 属性，它的相关控件也不需要 id 属性，它们是通过在 <label> 标签中放入 <input> 标签来隐式的连接起来的。
如果是通过 js 或 jsp 来动态生成 <label>和<input>，最好还是采用隐式的联系，更好实现，因为不必分配和生成 id，要做到同一个网页中id不重复还是有点费劲的。
实际使用的例子：使用 FreeMarker 和 JavaScript 综合生成代码
/* 以前采用显式的联系，生成id费劲，还要避免与别的id重复
$cblist.append("<li><input type='checkbox' id='form${form.formId}_${field.sysName}_"
+i
+"' name='${field.sysName}' value='"
+value
+"'" + (found ? " checked='checked'" : "") + "/> "
+"<label for='form${form.formId}_${field.sysName}_"
+i
+"'>"
+json.data[i].text+"</label> </li>");
*/
// 改用隐式的联系，代码简洁
$cblist.append("<li><label
><input type='checkbox' name='${field.sysName}'
value='" +value +"'"
+ (found ? " checked='checked'" : "")
+ "/> " +json.data[i].text+"</label> </li>");
源文：http://www.vktone.com/articles/about_html_label_tag.html
已有 0 人发表留言，猛击->>这里<<-参与讨论
ITeye推荐
- —软件人才免语言低担保 赴美带薪读研！—