public class bubbleSort {
public final static int totalCount = 12;
public final static int descAsc = 1;// 升序或者降序
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Integer[] initNum = new Integer[totalCount];
int[] initNumo = new int[totalCount];
for (int i = 0; i < totalCount; i++) {
initNumo[i] = (int) (Math.random() * 100);
initNum[i] = Integer.valueOf((int) (Math.random() * 100));
}
printNums(initNumo);
System.out.println("++++++++++++++");
SortAlgorithm7(initNumo);
printNums(initNumo);
}
// 冒泡排序;相鄰交換
public static void SortAlgorithm1(int initNum[]) {
int temp = -1;
for (int i = 0; i < initNum.length; i++) {
for (int j = 0; j < initNum.length - i - 1; j++) {
if (initNum[j] > initNum[j + 1]) {
temp = initNum[j + 1];
initNum[j + 1] = initNum[j];
initNum[j] = temp;
}
}
}
}
// 選擇排序;逐個找到最值放到一端
public static void SortAlgorithm2(int initNum[]) {
int temp = 0;
for (int i = initNum.length - 1; i >= 0; i--) {
int max = 0;// 這個值很關鍵
for (int j = 0; j <= i; j++) {
if (initNum[j] > initNum[max]) {
max = j;
}
}
temp = initNum[i];
initNum[i] = initNum[max];
initNum[max] = temp;
}
}
// 插入排序,插入已經有序隊列;按照算法一步一步算下來
public static void SortAlgorithm3(int initNum[]) {
int temp = 0;
for (int i = 1; i < initNum.length; i++) {
int j = 0;
temp = initNum[i];
while (initNum[j] < temp) {
j++;
}
for (int k = i; k > j; k--) {
initNum[k] = initNum[k - 1];
}
initNum[j] = temp;
}
}
// 希爾排序;局部有序,排序更快,和步長直接相關;建立在插入排序之上
public static void SortAlgorithm4(int initNum[]) {
int temp = 0;
for (int n = initNum.length / 2; n > 0; n = n / 2) {
for (int i = n; i < initNum.length; i += n) {
int j = 0;
temp = initNum[i];
while (initNum[j] < temp) {
j += n;
}
for (int k = i; k > j; k -= n) {
initNum[k] = initNum[k - n];
}
initNum[j] = temp;
}
}
}
// 快速排序
public static void SortAlgorithm5(int initNum[]) {
quickSort(initNum, 0, initNum.length - 1);
}
public static void quickSort(int initNum[], int left, int right) {
if (left < right) {
int low = left;
int high = right;
int temp = initNum[left];
while (low < high) {
while (low < high && initNum[high] > temp) {// 注意添加low<high這個條件,外面的那個限制不能作用到裏面
high--;
}
initNum[low] = initNum[high];
while (low < high && initNum[low] <= temp) {
low++;
}
initNum[high] = initNum[low];
}
initNum[high] = temp;
quickSort(initNum, left, low - 1);
quickSort(initNum, low + 1, right);
}
}
// 堆排序
public static void SortAlgorithm6(int initNum[]) {
int temp = 0;
// 1、生成大頂堆
for (int i = initNum.length / 2 - 1; i >= 0; i--) {
createHeap(initNum, i, initNum.length - 1);
}
for (int j = initNum.length - 1; j >= 0; j--) {
temp = initNum[j];
initNum[j] = initNum[0];
initNum[0] = temp;
createHeap(initNum, 0, j - 1);
}
}
// 插入一個數字到打定堆中
public static void createHeap(int initNum[], int firstNode, int lastNode) {
if (firstNode < lastNode) {
int leftNode = firstNode * 2 + 1;
int rightNode = firstNode * 2 + 2;
int maxNode = firstNode;
int temp = -1;
if (leftNode <= lastNode && initNum[leftNode] > initNum[maxNode]) {
maxNode = leftNode;
}
if (rightNode <= lastNode && initNum[rightNode] > initNum[maxNode]) {
maxNode = rightNode;
}
if (maxNode != firstNode) {
temp = initNum[firstNode];
initNum[firstNode] = initNum[maxNode];
initNum[maxNode] = temp;
}
createHeap(initNum, leftNode, lastNode);
createHeap(initNum, rightNode, lastNode);
}
}
// 歸併排序
public static void SortAlgorithm7(int initNum[]) {
recursionMethed(initNum,0,initNum.length-1);
}
public static void recursionMethed(int initNum[], int start, int end) {
if(start<end){
recursionMethed(initNum,start,(start+end)/2);
recursionMethed(initNum,(start+end)/2+1,end);//分兩段是切斷了的
mergeMethed(initNum,start,(start+end)/2,end);
}
}
// 處理相鄰的兩個有序數組
public static void mergeMethed(int initNum[], int start, int middle, int end) {
if (start == middle && middle == end) {
return;
}
int tempNums[] = new int[end - start + 1];
int firstTemp = start;
int secoundTemp = middle+1;//分開切斷
int k = 0;
while (firstTemp <= middle && secoundTemp <= end) {
if (initNum[firstTemp] <= initNum[secoundTemp]) {
tempNums[k] = initNum[firstTemp];
k++;
firstTemp++;
} else {
tempNums[k] = initNum[secoundTemp];
k++;
secoundTemp++;
}
}
while (firstTemp > middle && secoundTemp <= end) {
tempNums[k] = initNum[secoundTemp];
k++;
secoundTemp++;
}
while (firstTemp <= middle && secoundTemp > end) {
tempNums[k] = initNum[firstTemp];
k++;
firstTemp++;
}
// 將排完序的數組賦值回去
for (int i = 0, s = start; i < tempNums.length; i++, s++) {
initNum[s] = tempNums[i];
}
}
public static void printNumsln(int initNum[]) {
for (int i = 0; i < initNum.length; i++) {
System.out.print(" " + initNum[i]);
}
}
public static void printNums(int initNum[]) {
for (int i = 0; i < initNum.length; i++) {
System.out.println(initNum[i]);
}
}
}
7種排序算法(java)——第三遍
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.