一个人看的www久久,91久久国产,国产精品黄色

java排序法

Posted on 2005-12-05 20:24 勇敢的心閱讀(608) 評論(0) 編輯收藏所屬分類: Java

/*這個程序是我在一個帖子上看到的，覺得寫的十分的不錯，拿出來與大家共享下*/
package com.cucu.test;

public class Sort {

  public void swap(int a[], int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
  }

  public int partition(int a[], int low, int high) {
    int pivot, p_pos, i;
    p_pos = low;
    pivot = a[p_pos];
    for (i = low + 1; i <= high; i++) {
      if (a[i] > pivot) {
        p_pos++;
        swap(a, p_pos, i);
      }
    }
    swap(a, low, p_pos);
    return p_pos;
  }

  public void quicksort(int a[], int low, int high) {
    int pivot;
    if (low < high) {
      pivot = partition(a, low, high);
      quicksort(a, low, pivot - 1);
      quicksort(a, pivot + 1, high);
    }

  }

  public static void main(String args[]) {
    int vec[] = new int[] { 37, 47, 23, -5, 19, 56 };
    int temp;
    //選擇排序法(Selection Sort)
    long begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length; j++) {
          if (vec[j] > vec[i]) {
            temp = vec[i];
            vec[i] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    long end = System.currentTimeMillis();
    System.out.println("選擇法用時為：" + (end - begin));
    //打印排序好的結果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
    //  冒泡排序法(Bubble Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length - 1; j++) {
          if (vec[j + 1] > vec[j]) {
            temp = vec[j + 1];
            vec[j + 1] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    end = System.currentTimeMillis();
    System.out.println("冒泡法用時為：" + (end - begin));
    //打印排序好的結果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

    //插入排序法(Insertion Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 1; i < vec.length; i++) {
        int j = i;
        while (vec[j - 1] < vec[i]) {
          vec[j] = vec[j - 1];
          j--;
          if (j <= 0) {
            break;
          }
        }
        vec[j] = vec[i];
      }
    }
    end = System.currentTimeMillis();
    System.out.println("插入法用時為：" + (end - begin));
    //打印排序好的結果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

    //快速排序法(Quick Sort)

    Sort s = new Sort();
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      s.quicksort(vec, 0, 5);
    }
    end = System.currentTimeMillis();
    System.out.println("快速法用時為：" + (end - begin));
    //打印排序好的結果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
  }

}

************************************************************************************

package org.jr.util;
/**
* Company: JavaResearch(http://www.javaresearch.org)
* 最后更新日期:2003年3月4日
* @author Cherami
*/
import org.jr.*;
/**
* 排序工具類，提供常見的需要排序但是又沒有實現Comparable接口的類。
* 此類也提供一些創建的排序算法的范例。
* @since 0.5
*/
public class CompareUtil {
/**
* 私有構造方法，防止類的實例化，因為工具類不需要實例化。
*/
private CompareUtil() {
}
/**
* 比較兩個數字。
* 這個方法取Number的double值進行比較，因此只有在兩個數嚴格相等的情況下才返回0，
* 又可能因為Java中Double型和Float的精度不同而導致兩個相等的數不返回0。
* @param o1 第一個數字
* @param o2 第二個數字
* @return 第一個數字大于第二個返回1，等于返回0，否則返回－1
* @since 0.5
*/
public static int compare(Number o1, Number o2) {
double n1 = o1.doubleValue();
double n2 = o2.doubleValue();
if (n1 < n2) {
return -1;
}
else if (n1 > n2) {
return 1;
}
else {
return 0;
}
}
/**
* 比較兩個布爾型值。
* 如果兩個的值不同，true被認為等于1，而false等于0。
* @param o1 第一個值
* @param o2 第二個值
* @return 第一個值大于第二個返回1，等于返回0，否則返回-1
* @since 0.5
*/
public static int compare(Boolean o1, Boolean o2) {
boolean b1 = o1.booleanValue();
boolean b2 = o2.booleanValue();
if (b1 == b2) {
return 0;
}
else if (b1) {
return 1;
}
else {
return -1;
}
}
/**
* 冒泡排序法排序。
* @param objects 排序對象
* @param isAscent 排序順序
* @return 排序后應該有的索引數組
* @since 0.5
*/
public static int[] n2sort(Comparable[] objects, boolean isAscent) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (isAscent == true) {
if (objects[indexes[i]].compareTo(objects[indexes[j]]) > 0) {
swap(indexes, i, j);
}
}
else {
if (objects[indexes[i]].compareTo(objects[indexes[j]]) < 0) {
swap(indexes, i, j);
}
}
}
}
return indexes;
}
/**
* 冒泡排序法排序。
* @param objects 排序對象
* @param key 排序關鍵字
* @param isAscent 排序順序
* @return 排序后應該有的索引數組
* @since 0.5
*/
public static int[] n2sort(PropertyComparable[] objects, int key,
boolean isAscent) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (isAscent == true) {
if (objects[indexes[i]].compareTo(objects[indexes[j]], key) > 0) {
swap(indexes, i, j);
}
}
else {
if (objects[indexes[i]].compareTo(objects[indexes[j]], key) < 0) {
swap(indexes, i, j);
}
}
}
}
return indexes;
}
/**
* 冒泡排序法排序。
* @param objects 排序對象
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] n2sort(Comparable[] objects) {
return n2sort(objects,true);
}
/**
* 冒泡排序法排序。
* @param objects 排序對象
* @param key 排序關鍵字
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] n2sort(PropertyComparable[] objects, int key) {
return n2sort(objects,key);
}
/**
* 插入排序法排序。
* @param objects 排序對象
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] insertionSort(Comparable[] objects) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 1; i < length; i++) {
int j = i;
Comparable B = objects[indexes[i]];
while ((j > 0) && (objects[indexes[j-1]].compareTo(B) > 0)) {
indexes[j] = indexes[j-1];
j--;
}
indexes[j] = i;
}
return indexes;
}
/**
* 插入排序法排序。
* @param objects 排序對象
* @param key 排序關鍵字
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] insertionSort(PropertyComparable[] objects, int key) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 1; i < length; i++) {
int j = i;
Comparable B = objects[indexes[i]];
while ((j > 0) && (objects[indexes[j-1]].compareTo(B,key) > 0)) {
indexes[j] = indexes[j-1];
j--;
}
indexes[j] = i;
}
return indexes;
}
/**
* 選擇排序法排序。
* @param objects 排序對象
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] selectionSort(Comparable[] objects) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
int min = i;
int j;
//在未排序列表里面查找最小元素
for (j = i + 1; j < length; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[min]]) <0 ) {
min = j;
}
}
//將最小的元素交換到未排序元素的最開始
swap(indexes,i,min);
}
return indexes;
}
/**
* 選擇排序法排序。
* @param objects 排序對象
* @param key 排序關鍵字
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] selectionSort(PropertyComparable[] objects, int key) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
for (int i = 0; i < length; i++) {
int min = i;
int j;
//在未排序列表里面查找最小元素
for (j = i + 1; j < length; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[min]],key) <0 ) {
min = j;
}
}
//將最小的元素交換到未排序元素的最開始
swap(indexes,i,min);
}
return indexes;
}
/**
* 雙向冒泡排序法排序。
* @param objects 排序對象
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] bidirectionalBubbleSort(Comparable[] objects) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
int j;
int limit = objects.length;
int start = -1;
while (start < limit) {
start++;
limit--;
for (j = start; j < limit; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]]) > 0) {
swap(indexes,j,j+1);
}
}
for (j = limit; --j >= start;) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]]) > 0) {
swap(indexes,j,j+1);
}
}
}
return indexes;
}
/**
* 雙向冒泡排序法排序。
* @param objects 排序對象
* @param key 排序關鍵字
* @return 按照升序排序后應該有的索引數組
* @since 0.6
*/
public static int[] bidirectionalBubbleSort(PropertyComparable[] objects, int key) {
int length = objects.length;
int[] indexes = ArrayUtil.getInitedIntArray(length);
int j;
int limit = objects.length;
int start = -1;
while (start < limit) {
start++;
limit--;
for (j = start; j < limit; j++) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]]) > 0) {
swap(indexes,j,j+1);
}
}
for (j = limit; --j >= start;) {
if (objects[indexes[j]].compareTo(objects[indexes[j+1]],key) > 0) {
swap(indexes,j,j+1);
}
}
}
return indexes;
}
/**
* 交換兩個元素的值。
* @param indexes 原索引數組
* @param i 第一行
* @param j 第二行
*/
private static void swap(int[] indexes, int i, int j) {
int tmp = indexes[i];
indexes[i] = indexes[j];
indexes[j] = tmp;
}
}
------------------------------------------
冒泡排序：
1、比較相鄰的兩個元素，如果后面的比前面小，就對調二者。反復比較，到最后兩個元素。結果，最大值就跑到了最末位置。
2、反復第一步，直到所有較大值都跑到靠后的位置。
---------------------------------------------
選擇排序
1、一開始整個數列是未排列的
2、從未排列的數中，挑選出最小的數，和未排列的數中的第一個元素互調，并將該最小的數歸類到已排序的序列中；
3、重復第2步，直到所有的數都歸類到已排序數列中。
---------------------------------------------
插入排序法：
1、一開始只有第一個數在已排序數列中，其他的數歸類到未排序數列中；
2、將未排序的第一個數，插入到已排序數列中，使得插入后的已排序數列仍然維持由小到大的順序；
3、重復步驟2，直到所有的數都在已排序數列中。
-----------------------------------------------

新用戶注冊刷新評論列表


只有注冊用戶登錄后才能發表評論。




網站導航: 博客園 IT新聞 Chat2DB C++博客博問管理
相關文章: Java異常處理之陋習展播（ZT） java面試題3 java排序法 java面試收集（持續更新）-1 原貼編輯太慢了 java面試收集（持續更新）

fjpan2002

導航

常用鏈接

留言簿(1)

隨筆分類

隨筆檔案

文章分類

文章檔案

搜索

最新評論

閱讀排行榜

評論排行榜

java排序法