激情内射亚洲一区二区三区,久久久久亚洲精品无码蜜桃,国产亚洲精aa成人网站

Q奇Q — Tue, 01 Jun 2010 02:11:00 GMT

JAVA排序汇�?收藏
package com.softeem.jbs.lesson4;
import java.util.Random;
/**
* 排序��试�c?br /> *
* 排序��法的分�c�d��下：
* 1.插入排序�Q�直接插入排序、折半插入排序、希��排序）�Q?br /> * 2.交换排序�Q�冒泡��排序、快速排序）�Q?br /> * 3.选择排序�Q�直接选择排序、堆排序�Q�；
* 4.归�ƈ排序�Q?br /> * 5.基数排序�?br /> *
* 关于排序�Ҏ��的选择�Q?br /> * (1)若n较小(如n≤50)�Q�可采用直接插入或直接选择排序�?br /> * 　当记录规模较��时�Q�直接插入排序较好；否则因�ؓ直接选择�U�d��的记录数��于直接插�h�Q�应选直接选择排序为宜�?br /> * (2)若文件初始状态基本有�?指正�?�Q�则应选用直接插�h、冒泡或随机的快速排序�ؓ宜；
* (3)若n较大�Q�则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归�q�排序�?br /> *
*/
public class SortTest {
   /**
      * 初始化测试数�l�的�Ҏ��
      * @return 一个初始化好的数组
      */
   public int[] createArray() {
            Random random = new Random();
            int[] array = new int[10];
            for (int i = 0; i < 10; i++) {
                  array = random.nextInt(100) - random.nextInt(100);//生成两个随机数相减，保证生成的数中有负数
            }
            System.out.println("==========原始序列==========");
            printArray(array);
            return array;
   }
   /**
      * 打印数组中的元素到控制台
      * @param source
      */
   public void printArray(int[] data) {
            for (int i : data) {
                  System.out.print(i + " ");
            }
            System.out.println();
   }
   /**
      * 交换数组中指定的两元素的位置
      * @param data
      * @param x
      * @param y
      */
   private void swap(int[] data, int x, int y) {
            int temp = data[x];
            data[x] = data[y];
            data[y] = temp;
   }
   /**
      * 冒��排序----交换排序的一�U?br />       * �Ҏ��Q�相��M��元素�q�行比较�Q�如有需要则�q�行交换�Q�每完成一�ơ��@环就��最大元素排在最后（如从��到大排序）�Q�下一�ơ��@环是��其他的数进行类似操作�?
      * 性能�Q�比较次数O(n^2),n^2/2�Q�交换次数O(n^2),n^2/4
      *
      * @param data 要排序的数组
      * @param sortType 排序�c�d��
      * @return
      */
   public void bubbleSort(int[] data, String sortType) {
            if (sortType.equals("asc")) { //正排序，从小排到�?br />                   //比较的轮�?br />                   for (int i = 1; i < data.length; i++) {
                        //��相��M��个数�q�行比较�Q�较大的数往后冒�?br />                         for (int j = 0; j < data.length - i; j++) {
                                 if (data[j] > data[j + 1]) {
                                       //交换盔R��两个�?br />                                        swap(data, j, j + 1);
                                 }
                        }
                  }
            } else if (sortType.equals("desc")) { //倒排序，从大排到��?br />                   //比较的轮�?br />                   for (int i = 1; i < data.length; i++) {
                        //��相��M��个数�q�行比较�Q�较大的数往后冒�?br />                         for (int j = 0; j < data.length - i; j++) {
                                 if (data[j] < data[j + 1]) {
                                       //交换盔R��两个�?br />                                        swap(data, j, j + 1);
                                 }
                        }
                  }
            } else {
                  System.out.println("您输入的排序�c�d��错误�Q?);
            }
            printArray(data);//输出冒��排序后的数组�?br />    }
   /**
      * 直接选择排序�?---选择排序的一�U?br />       * �Ҏ��Q�每一��从待排序的数据元素中选出最��（或最大）的一个元素， ��序攑֜�已排好序的数列的最后，直到全部待排序的数据元素排完�?br />       * 性能�Q�比较次数O(n^2),n^2/2
      *    交换�ơ数O(n),n
      *    交换�ơ数比冒泡排序少多了�Q�由于交换所需CPU旉��比比较所需的CUP旉��多，所以选择排序比冒泡排序快�?br />       *    但是N比较大时�Q�比较所需的CPU旉��占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些�?br />       *
      * @param data 要排序的数组
      * @param sortType 排序�c�d��
      * @return
      */
   public void selectSort(int[] data, String sortType) {
            if (sortType.equals("asc")) { //正排序，从小排到�?br />                   int index;
                  for (int i = 1; i < data.length; i++) {
                        index = 0;
                        for (int j = 1; j <= data.length - i; j++) {
                                 if (data[j] > data[index]) {
                                       index = j;
                                 }
                        }
                        //交换在位�|�data.length-i和index(最大�?两个�?br />                         swap(data, data.length - i, index);
                  }
            } else if (sortType.equals("desc")) { //倒排序，从大排到��?br />                   int index;
                  for (int i = 1; i < data.length; i++) {
                        index = 0;
                        for (int j = 1; j <= data.length - i; j++) {
                                 if (data[j] < data[index]) {
                                       index = j;
                                 }
                        }
                        //交换在位�|�data.length-i和index(最大�?两个�?br />                         swap(data, data.length - i, index);
                  }
            } else {
                  System.out.println("您输入的排序�c�d��错误�Q?);
            }
            printArray(data);//输出直接选择排序后的数组�?br />    }
   /**
      * 插入排序
      * �Ҏ��Q�将一个记录插入到已排好序的有序表�Q�有可能是空表）�?从而得��C��个新的记录数�?的有序表�?br />       * 性能�Q�比较次数O(n^2),n^2/4
      *    复制�ơ数O(n),n^2/4
      *    比较�ơ数是前两者的一般，而复制所需的CPU旉��较交换少�Q�所以性能上比冒��排序提高一倍多�Q�而比选择排序也要快�?br />       *
      * @param data 要排序的数组
      * @param sortType 排序�c�d��
      */
   public void insertSort(int[] data, String sortType) {
            if (sortType.equals("asc")) { //正排序，从小排到�?br />                   //比较的轮�?br />                   for (int i = 1; i < data.length; i++) {
                        //保证前i+1个数排好�?br />                         for (int j = 0; j < i; j++) {
                                 if (data[j] > data) {
                                       //交换在位�|�j和i两个�?br />                                        swap(data, i, j);
                                 }
                        }
                  }
            } else if (sortType.equals("desc")) { //倒排序，从大排到��?br />                   //比较的轮�?br />                   for (int i = 1; i < data.length; i++) {
                        //保证前i+1个数排好�?br />                         for (int j = 0; j < i; j++) {
                                 if (data[j] < data) {
                                       //交换在位�|�j和i两个�?br />                                        swap(data, i, j);
                                 }
                        }
                  }
            } else {
                  System.out.println("您输入的排序�c�d��错误�Q?);
            }
            printArray(data);//输出插入排序后的数组�?br />    }
   /**
      * 反�{数组的方�?br />       * @param data 源数�l?br />       */
   public void reverse(int[] data) {
            int length = data.length;
            int temp = 0;//临时变量
            for (int i = 0; i < length / 2; i++) {
                  temp = data;
                  data = data[length - 1 - i];
                  data[length - 1 - i] = temp;
            }
            printArray(data);//输出到�{后数�l�的�?br />    }
   /**
      * 快速排�?br />       * 快速排序��用分��L��Q�Divide and conquer�Q�策略来把一个序列（list�Q�分��Z��个子序列�Q�sub-lists�Q��?br />       * 步骤为：
      * 1. 从数列中挑出一个元素，�U�Cؓ "基准"�Q�pivot�Q�，
      * 2. 重新排序数列�Q�所有元素比基准值小的摆攑֜�基准前面�Q�所有元素比基准值大的摆在基准的后面�Q�相同的数可以到��M��边）。在�q�个分割之后�Q�该基准是它的最后位�|�。这个称为分�Ԍ��partition�Q�操作�?br />       * 3. 递归圎ͼ�recursive�Q�把��于基准值元素的子数列和大于基准值元素的子数列排序�?br />       * 递回的最底部情�Ş�Q�是数列的大��是零或一�Q�也��是永远都已�l�被排序好了。虽然一直递回下去�Q�但是这个算法��M��l�束�Q�因为在每次的�P代（iteration�Q�中�Q�它臛_��会把一个元素摆到它最后的位置厅R�?br />       * @param data 待排序的数组
      * @param low
      * @param high
      * @see SortTest#qsort(int[], int, int)
      * @see SortTest#qsort_desc(int[], int, int)
      */
   public void quickSort(int[] data, String sortType) {
            if (sortType.equals("asc")) { //正排序，从小排到�?br />                   qsort_asc(data, 0, data.length - 1);
            } else if (sortType.equals("desc")) { //倒排序，从大排到��?br />                   qsort_desc(data, 0, data.length - 1);
            } else {
                  System.out.println("您输入的排序�c�d��错误�Q?);
            }
   }
   /**
      * 快速排序的具体实现�Q�排正序
      * @param data
      * @param low
      * @param high
      */
   private void qsort_asc(int data[], int low, int high) {
            int i, j, x;
            if (low < high) { //�q�个条�g用来�l�束递归
                  i = low;
                  j = high;
                  x = data;
                  while (i < j) {
                        while (i < j && data[j] > x) {
                                 j--; //从右向左扄��一个小于x的数
                        }
                        if (i < j) {
                                 data = data[j];
                                 i++;
                        }
                        while (i < j && data < x) {
                                 i++; //从左向右扄��一个大于x的数
                        }
                        if (i < j) {
                                 data[j] = data;
                                 j--;
                        }
                  }
                  data = x;
                  qsort_asc(data, low, i - 1);
                  qsort_asc(data, i + 1, high);
            }
   }
   /**
      * 快速排序的具体实现�Q�排倒序
      * @param data
      * @param low
      * @param high
      */
   private void qsort_desc(int data[], int low, int high) {
            int i, j, x;
            if (low < high) { //�q�个条�g用来�l�束递归
                  i = low;
                  j = high;
                  x = data;
                  while (i < j) {
                        while (i < j && data[j] < x) {
                                 j--; //从右向左扄��一个小于x的数
                        }
                        if (i < j) {
                                 data = data[j];
                                 i++;
                        }
                        while (i < j && data > x) {
                                 i++; //从左向右扄��一个大于x的数
                        }
                        if (i < j) {
                                 data[j] = data;
                                 j--;
                        }
                  }
                  data = x;
                  qsort_desc(data, low, i - 1);
                  qsort_desc(data, i + 1, high);
            }
   }
   /**
      *二分查找特定整数在整型数�l�中的位�|?递归)
      *查找�U�性表必须是有序列�?br />       [email=*@paramdataset]*@paramdataset[/email]
      [email=*@paramdata]*@paramdata[/email]
      [email=*@parambeginIndex]*@parambeginIndex[/email]
      [email=*@paramendIndex]*@paramendIndex[/email]
      [email=*@returnindex]*@returnindex[/email]
      */
   public int binarySearch(int[] dataset, int data, int beginIndex,
                  int endIndex) {
            int midIndex = (beginIndex + endIndex) >>> 1; //相当于mid = (low + high) / 2�Q�但是效率会高些
            if (data < dataset[beginIndex] || data > dataset[endIndex]
                        || beginIndex > endIndex)
                  return -1;
            if (data < dataset[midIndex]) {
                  return binarySearch(dataset, data, beginIndex, midIndex - 1);
            } else if (data > dataset[midIndex]) {
                  return binarySearch(dataset, data, midIndex + 1, endIndex);
            } else {
                  return midIndex;
            }
   }
   /**
      *二分查找特定整数在整型数�l�中的位�|?非递归)
      *查找�U�性表必须是有序列�?br />       [email=*@paramdataset]*@paramdataset[/email]
      [email=*@paramdata]*@paramdata[/email]
      [email=*@returnindex]*@returnindex[/email]
      */
   public int binarySearch(int[] dataset, int data) {
            int beginIndex = 0;
            int endIndex = dataset.length - 1;
            int midIndex = -1;
            if (data < dataset[beginIndex] || data > dataset[endIndex]
                        || beginIndex > endIndex)
                  return -1;
            while (beginIndex <= endIndex) {
                  midIndex = (beginIndex + endIndex) >>> 1; //相当于midIndex = (beginIndex + endIndex) / 2�Q�但是效率会高些
                  if (data < dataset[midIndex]) {
                        endIndex = midIndex - 1;
                  } else if (data > dataset[midIndex]) {
                        beginIndex = midIndex + 1;
                  } else {
                        return midIndex;
                  }
            }
            return -1;
   }
   public static void main(String[] args) {
            SortTest sortTest = new SortTest();
            int[] array = sortTest.createArray();
            System.out.println("==========冒��排序�?正序)==========");
            sortTest.bubbleSort(array, "asc");
            System.out.println("==========冒��排序�?倒序)==========");
            sortTest.bubbleSort(array, "desc");
            array = sortTest.createArray();
            System.out.println("==========倒�{数组�?=========");
            sortTest.reverse(array);
            array = sortTest.createArray();
            System.out.println("==========选择排序�?正序)==========");
            sortTest.selectSort(array, "asc");
            System.out.println("==========选择排序�?倒序)==========");
            sortTest.selectSort(array, "desc");
            array = sortTest.createArray();
            System.out.println("==========插入排序�?正序)==========");
            sortTest.insertSort(array, "asc");
            System.out.println("==========插入排序�?倒序)==========");
            sortTest.insertSort(array, "desc");
            array = sortTest.createArray();
            System.out.println("==========快速排序后(正序)==========");
            sortTest.quickSort(array, "asc");
            sortTest.printArray(array);
            System.out.println("==========快速排序后(倒序)==========");
            sortTest.quickSort(array, "desc");
            sortTest.printArray(array);
            System.out.println("==========数组二分查找==========");
            System.out.println("您要扄��数在�W? + sortTest.binarySearch(array, 74)
                        + "个位子。（下标�?计算�Q?);
   }
}

转蝲地址�Q?a target="_blank">http://blog.csdn.net/lenotang/archive/2008/11/29/3411346.aspx
本文来自CSDN博客�Q��{载请标明出处�Q?a target="_blank">http://blog.csdn.net/zuoluoboy/archive/2009/04/25/4123943.aspx

Q奇Q 2010-06-01 10:11 发表评论

Q奇Q — Sun, 23 May 2010 08:21:00 GMT

只有注册用户��d��后才能阅读该文�?a href='http://www.tkk7.com/Qiegds/articles/321663.html'>阅读全文

Q奇Q 2010-05-23 16:21 发表评论

VO DAO BO POJO PO 是什�?JAVA几种对象的解�?

Q奇Q — Sun, 09 May 2010 06:36:00 GMT

PO:persistant object持久对象,可以看成是与数据库中的表相映��的java对象。最��单的PO��是对应数据库中某个表中的一条记录，多个记录可以�?/font>PO的集合�?/font>PO中应该不包含��M��Ҏ��据库的操�?/font>.

VO:value object值对象。通常用于业务层之间的数据传递，�?/font>PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可以和表对应,也可以不,�q�根据业务的需�?/font>.个�h觉得�?/font>DTO(数据传输对象),�?/font>web上传�?/font>.

DAO:data access object数据讉K��对象�Q�此对象用于讉K��数据库。通常�?/font>PO�l�合使用�Q?/font>DAO中包含了各种数据库的操作�Ҏ��。通过它的�Ҏ��,�l�合PO�Ҏ��据库�q�行相关的操�?/font>.

BO:business object业务对象,��装业务逻辑�?/font>java对象,通过调用DAO�Ҏ��,�l�合PO,VO�q�行业务操作;

POJO:plain ordinary java object ��单无规则java对象,我个��得它和其他不是一个层面上的东�?/font>,VO�?/font>PO应该都属于它.

PO�Q?nbsp;

persistant object持久对象

最形象的理解就是一�?font face="Arial">PO��是数据库中的一条记录�?nbsp;

好处是可以把一条记录作��Z��个对象处理，可以方便的�{为其它对象�?nbsp;

BO�Q?nbsp;

business object业务对象

主要作用是把业务逻辑��装��Z��个对象。这个对象可以包括一个或多个其它的对象�?nbsp;

比如一个简历，有教育经历、工作经历、社�?nbsp;关系�{�等�?nbsp;

我们可以把教育经历对应一�?font face="Arial">PO�Q�工作经历对应一�?/font>PO�Q�社�?nbsp;关系对应一�?/font>PO�?nbsp;

建立一个对应简历的BO对象处理��历，每个BO包含�q�些PO�?nbsp;

�q�样处理业务逻辑�Ӟ��我们��可以针�?font face="Arial">BO��d��理�?nbsp;

VO �Q?nbsp;

value object值对�?nbsp;

ViewObject表现层对�?nbsp;

主要对应界面昄��的数据对象。对于一�?font face="Arial">WEB��面�Q�或�?/font>SWT�?/font>SWING的一个界面，用一�?/font>VO对象对应整个界面的倹{�?nbsp;

DTO �Q?nbsp;

Data Transfer Object数据传输对象

主要用于�q�程调用�{�需要大量传输对象的地方�?nbsp;

比如我们一张表�?font face="Arial">100个字�D�，那么对应�?/font>PO��有100个属性�?nbsp;

但是我们界面上只要显�C?font face="Arial">10个字�D�，

客户端用WEB service来获取数据，没有必要把整�?/font>PO对象传递到客户端，

�q�时我们��可以用只有�q?font face="Arial">10个属性的DTO来传递结果到客户端，�q�样也不会暴露服务端表结�?/font>.到达客户端以后，如果用这个对象来对应界面昄��Q�那此时它的�w�䆾��p�{�?/font>VO

POJO �Q?nbsp;

plain ordinary java object ��?/font>java对象

个�h感觉POJO是最常见最多变的对象，是一个中间对象，也是我们最常打交道的对象�?nbsp;

一�?font face="Arial">POJO持久化以后就�?/font>PO

直接用它传递、传递过�E�中��是DTO

原文来自�Q�野蔯�� http://www.yeqiangwei.com/club/f4b0l0fp1t342010p1.html

直接用来对应表示层就�?font face="Arial">VO

DAO�Q?nbsp;

data access object数据讉K��对象

�q�个大家最熟悉�Q�和上面几个O区别最大，基本没有互相转化的可能性和必要.

主要用来��装�Ҏ��据库的访问。通过它可以把POJO持久化�ؓPO�Q�用PO�l�装出来VO�?/font>DTO

Q奇Q 2010-05-09 14:36 发表评论