java oj主机名排序_oj教程--排序算法（Java）
import java.util.ArrayList;
import java.util.List;
/**
* 排序算法主類
*
* @author eric
*/
class SortArray {
/*
* 【插入排序】
* 基本思想： 在要排序的一組數中，假設前面(n-1) [n>=2] 個數已經是排好順序的，
* 現在要把第n個數插到前面的有序數中，使得這n個數也是排好順序的， 如此反復循環，直到全部排好順序。
*/
public void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int j = i - 1;
int temp = arr[i];
for (; j >= 0 && temp < arr[j]; j--) {
arr[j + 1] = arr[j]; // 將大于temp的值整體后移一個單位
}
arr[j + 1] = temp;
}
}
/*
* 【選擇排序】 基本思想： 在要排序的一組數中，選出最小的一個數與第一個位置的數交換,
* 然后在剩下的數當中再找最小的與第二個位置的數交換，如此循環到倒數第二個數和最后一個數比較為止。
*/
public void selectSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int position = i;
int temp = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < temp) {
temp = arr[j];
position = j;
}
}
arr[position] = arr[i];
arr[i] = temp;
}
}
/*
* 【冒泡排序】
* 基本思想： 在要排序的一組數中， 對當前還未排好序的范圍內的全部數，自上而下對相鄰的兩個數依次進行比較和調整，
* 讓較大的數往下沉，較小的往上冒。 即：每當兩相鄰的數比較后發現它們的排序與排序要求相反時，就將它們互換。
*/
public void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr, j, j + 1);
}
}
}
}
/*
* 【希爾排序】
* 基本思想：算法先將要排序的一組數按某個增量d(n/2,n為要排序數的個數)分成若干組，
* 每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然后再用一個較小的增量(d/2)對它進行分組，
* 在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序后，排序完成。
*/
public void shellSort(int[] arr) {
double d1 = arr.length;
int temp = 0;
while (true) {
d1 = Math.ceil(d1 / 2);
int d = (int) d1;
for (int x = 0; x < d; x++) {
for (int i = x + d; i < arr.length; i += d) {
int j = i - d;
temp = arr[i];
for (; j >= 0 && temp < arr[j]; j -= d) {
arr[j + d] = arr[j];
}
arr[j + d] = temp;
}
}
if (d == 1)
break;
}
}
/*
* 【堆排序】
* 基本思想：堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。
* 堆的定義如下：具有n個元素的序列(h1,h2,...,hn),當且僅當滿足(hi>=h2i,hi>=2i+1)
* 或(hi<=h2i,hi<=2i+1)(i=1,2,...,n/2)時稱之為堆。在這里只討論滿足前者條件的堆。
* 由堆的定義可以看出，堆頂元素(即第一個元素)必為最大項(大頂堆)。
* 完全二叉樹可以很直觀地表示堆的結構。堆頂為根，其它為左子樹、右子樹。
* 初始時把要排序的數的序列看作是一棵順序存儲的二叉樹，調整它們的存儲序，使之成為一個堆，這時堆的根節點的數最大。
* 然后將根節點與堆的最后一個節點交換。然后對前面(n-1)個數重新調整使之成為堆。
* 依此類推，直到只有兩個節點的堆，并對它們作交換，最后得到有n個節點的有序序列。
* 從算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最后一個元素交換位置。
* 所以堆排序有兩個函數組成。一是建堆的滲透函數，二是反復調用滲透函數實現排序的函數
*/
public void heapSort(int[] arr) {
// 循環建堆
for (int i = 0; i < arr.length - 1; i++) {
buildMaxHeap(arr, arr.length - 1 - i); // 建堆
swap(arr, 0, arr.length - 1 - i); // 交換堆頂和最后一個元素
}
}
private void buildMaxHeap(int[] arr, int lastIndex) {
// 從lastIndex處節點(最后一個節點)的父節點開始
for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
// k保存正在判斷的節點
int k = i;
// 如果當前k節點的子節點存在
while (k * 2 + 1 <= lastIndex) {
// k節點的左子節點的索引
int biggerIndex = 2 * k + 1;
// 如果biggerIndex小于lastIndex，即biggerIndex+1代表的k節點的右子節點存在
if (biggerIndex < lastIndex) {
// 若果右子節點的值較大
if (arr[biggerIndex] < arr[biggerIndex + 1]) {
// biggerIndex總是記錄較大子節點的索引
biggerIndex++;
}
}
// 如果k節點的值小于其較大的子節點的值
if (arr[k] < arr[biggerIndex]) {
// 交換他們
swap(arr, k, biggerIndex);
// 將biggerIndex賦予k，開始while循環的下一次循環，重新保證k節點的值大于其左右子節點的值
k = biggerIndex;
} else {
break;
}
}
}
}
/*
* 【快速排序】
* 基本思想：選擇一個基準元素,通常選擇第一個元素或者最后一個元素,通過一趟掃描，將待排序列分成兩部分,
* 一部分比基準元素小,一部分大于等于基準元素,此時基準元素在其排好序后的正確位置,然后再用同樣的方法遞歸地排序劃分的兩部分。
*/
public void quickSort(int[] arr) {
// 查看數組是否為空
if (arr.length > 0) {
quickSort(arr, 0, arr.length - 1);
}
}
private void quickSort(int[] arr, int low, int high) {
if (low < high) {
int middle = getMiddle(arr, low, high); // 將list數組進行一分為二
quickSort(arr, low, middle - 1); // 對低字表進行遞歸排序
quickSort(arr, middle + 1, high); // 對高字表進行遞歸排序
}
}
private int getMiddle(int[] arr, int low, int high) {
int temp = arr[low]; // 數組的第一個作為中軸
while (low < high) {
while (low < high && arr[high] >= temp) {
high--;
}
arr[low] = arr[high]; // 比中軸小的記錄移到低端
while (low < high && arr[low] <= temp) {
low++;
}
arr[high] = arr[low]; // 比中軸大的記錄移到高端
}
arr[low] = temp; // 中軸記錄到尾
return low; // 返回中軸的位置
}
/*
* 【基數排序】
* 基本思想：將所有待比較數值(正整數)統一為同樣的數位長度，數位較短的數前面補零。
* 然后，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后,數列就變成一個有序序列。
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void radixSort(int[] arr) {
// 首先確定排序的趟數;
int max = arr[0];
int time = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 判斷位數;
while (max > 0) {
max /= 10;
time++;
}
// 建立10個隊列;
List queue = new ArrayList();
for (int i = 0; i < 10; i++) {
ArrayList queue1 = new ArrayList();
queue.add(queue1);
}
// 進行time次分配和收集;
for (int i = 0; i < time; i++) {
// 分配數組元素;
for (int j = 0; j < arr.length; j++) {
// 得到數字的第time+1位數;
int x = arr[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
ArrayList queue2 = queue.get(x);
queue2.add(arr[j]);
queue.set(x, queue2);
}
int count = 0;// 元素計數器;
// 收集隊列元素;
for (int k = 0; k < 10; k++) {
while (queue.get(k).size() > 0) {
ArrayList queue3 = queue.get(k);
arr[count] = queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
private void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static void main(String[] args) {
int[] arr = { 32, 43, 56, 12, 34, 21, 34, 54, 19 };
SortArray sa = new SortArray();
System.out.print("Before Sorting : ");
sa.printArray(arr); // 排序前打印輸出
System.out.println();
// sa.insertSort(arr); // 插入排序
// sa.selectSort(arr); // 選擇排序
// sa.bubbleSort(arr); // 冒泡排序
// sa.shellSort(arr); // 希爾排序
// sa.heapSort(arr); // 堆排序
// sa.quickSort(arr); // 快速排序
// sa.mergingSort(arr, 0, arr.length - 1 ); // 歸并排序
sa.radixSort(arr); // 基數排序
System.out.print("After Sorting : ");
sa.printArray(arr); // 排序后打印輸出
}
}
總結
以上是生活随笔為你收集整理的java oj主机名排序_oj教程--排序算法（Java）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java 反射获取泛型,用反射获取Jav
- 下一篇： java 下载处于挂起状态_即使脚本执行