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;
if (initNum.length > 1) {
for (int i = 0; i < initNum.length - 1; i++) {
for (int j = 0; j < initNum.length - 1 - i; j++) {
if (initNum[j] > initNum[j + 1]) {
temp = initNum[j];
initNum[j] = initNum[j + 1];
initNum[j + 1] = temp;
}
}
}
}
}
// 选择排序
public static void SortAlgorithm2(int initNum[]) {
if (initNum.length < 2) {
return;
}
int temp = initNum[0];
int tem = -1;
for (int i = 0; i < initNum.length; i++) {
for (int j = 0; j < initNum.length - 1 - i; j++) {
if (initNum[j + 1] > temp) {
tem = temp;
temp = initNum[j + 1];
initNum[j + 1] = tem;
}
}
tem = initNum[initNum.length - 1 - i];
initNum[initNum.length - 1 - i] = temp;
temp = tem;
}
}
// 插入排序
public static void SortAlgorithm3(int initNum[]) {
int temp = -1;
for (int i = 1; i < initNum.length; i++) {
for (int j = 0; j < i; j++) {
if (initNum[j] <= initNum[i]) {
} else {
temp = initNum[i];
for (int f = 0; f < i - j; f++) {
initNum[i - f] = initNum[i - f - 1];
}
initNum[j] = temp;
}
}
}
}
// 希尔排序;和步长直接相关
public static void SortAlgorithm4(int initNum[]) {
int temp = -1;
for (int k = initNum.length / 2; k > 0; k = k / 2) {
for (int i = 1; i < initNum.length; i += k) {
for (int j = 0; j < i; j += k) {
if (initNum[j] <= initNum[i]) {
} else {
temp = initNum[i];
for (int f = 0; f < i - j; f += k) {
initNum[i - f] = initNum[i - f - 1];
}
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) {
int temp = -1;
if (left < right) {
temp = initNum[left];
int low = left;
int high = right;
while (low < high) {
while (low < high && initNum[high] >= temp) {
high--;
}
initNum[low] = initNum[high];
while (low < high && initNum[low] <= temp) {
low++;
}
initNum[high] = initNum[low];
}
initNum[low] = temp;
quickSort(initNum, left, low - 1);
quickSort(initNum, low + 1, right);
}
}
// 堆排序
public static void SortAlgorithm6(int initNum[]) {
int temp = -1;
// 初始化大顶堆
for (int i = initNum.length / 2 - 1; i >= 0; i--) {
maxHeadHeap(initNum, i, initNum.length - 1);
}
printNumsln(initNum);
System.out.println();
// 逐个确定大小
for (int j = initNum.length - 1; j >= 0; j--) {
temp = initNum[j];
initNum[j] = initNum[0];
initNum[0] = temp;
maxHeadHeap(initNum, 0, j - 1);
}
}
public static void maxHeadHeap(int initNum[], int index, int indexLast) {
int leftIndex = index * 2 + 1;
int rightIndex = index * 2 + 2;
int maxIndex = index;
if (leftIndex <= indexLast && initNum[leftIndex] > initNum[maxIndex]) {
maxIndex = leftIndex;
}
if (rightIndex <= indexLast && initNum[rightIndex] > initNum[maxIndex]) {
maxIndex = rightIndex;
}
if (maxIndex != index) {
int temp = initNum[index];
initNum[index] = initNum[maxIndex];
initNum[maxIndex] = temp;
maxHeadHeap(initNum, maxIndex, indexLast);
}
}
// 调整堆使其成为大顶堆;index 从0开始
public static void maxHeadHeap(int initNum[], int index) {
int leftIndex = index * 2 + 1;
int rightIndex = index * 2 + 2;
if (leftIndex > initNum.length) {
return;
}
int maxIndex = index;
if (initNum[leftIndex] > initNum[index]) {
maxIndex = leftIndex;
}
if (rightIndex < initNum.length
&& initNum[rightIndex] > initNum[maxIndex]) {
maxIndex = rightIndex;
}
if (maxIndex != index) {
int temp = initNum[index];
initNum[index] = initNum[maxIndex];
initNum[maxIndex] = temp;
}
}
// 归并排序
public static void SortAlgorithm7(int initNum[]) {
mergeRecursion(initNum, 0, initNum.length - 1);
}
// 归并递归
public static void mergeRecursion(int initNum[], int start, int end) {
int middle = (start + end) / 2;
if (start < end) {
mergeRecursion(initNum, start, middle);
mergeRecursion(initNum, middle + 1, end);
mergeMethed(initNum, start, middle, end);
}
}
public static void mergeMethed(int initNum[], int low, int mid, int high) {
int low1 = low;
int low2 = mid+1;
int tempNum [] = new int[high-low+1];
int k=0;
while(low1<mid+1&&low2<=high){
if(initNum[low1]<=initNum[low2]){
tempNum[k] = initNum[low1];
k++;
low1++;
}else{
tempNum[k] = initNum[low2];
k++;
low2++;
}
}
while(low1<=mid&&low2>high){
tempNum[k] = initNum[low1];
k++;
low1++;
}
while(low2<=high&&low1>mid){
tempNum[k] = initNum[low2];
k++;
low2++;
}
for(int j= 0;j<tempNum.length;j++,low++){
initNum[low]=tempNum[j];
}
}
public static void printNums(int initNum[]) {
for (int i = 0; i < initNum.length; i++) {
System.out.println("" + initNum[i]);
}
}
public static void printNums(Integer initNum[]) {
for (int i = 0; i < initNum.length; i++) {
System.out.println("" + initNum[i]);
}
}
public static void printNumsln(int initNum[]) {
for (int i = 0; i < initNum.length; i++) {
System.out.print(" " + initNum[i]);
}
}
}
7种排序算法(java)--第一遍
最新推荐文章于 2022-06-28 15:30:50 发布