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("++++++++++++++");
SortAlgorithm4(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 = -1;
for (int i = initNum.length - 1; i >= 0; i--) {
int key = 0;
for (int j = 0; j <= i; j++) {
if (initNum[j] > initNum[key]) {
key = j;
}
}
temp = initNum[i];
initNum[i] = initNum[key];
initNum[key] = temp;
}
}
// 插入排序
public static void SortAlgorithm3(int initNum[]) {
int temp = 0;
int k = 0;
for (int i = 1; i < initNum.length; i++) {
temp = initNum[i];
k = i;
while (k > 0 && temp < initNum[k - 1]) {
initNum[k] = initNum[k - 1];
k--;
}
initNum[k] = temp;
}
}
// 希尔排序;和步长直接相关
public static void SortAlgorithm4(int initNum[]) {
for(int j = initNum.length/2;j>0;j=j/2){
int temp = 0;
int k = 0;
for (int i = j; i < initNum.length; i+=j) {
temp = initNum[i];
k = i;
while (k > 0 && temp < initNum[k - j]) {
initNum[k] = initNum[k - j];
k-=j;
}
initNum[k] = 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 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--) {
heapSort(initNum, i, initNum.length - i - 1);
}
// 循环处理,讲最大的数放到最后
for (int j = initNum.length - 1; j >= 0; j--) {
temp = initNum[j];
initNum[j] = initNum[0];
initNum[0] = temp;
heapSort(initNum, 0, j - 1);
}
}
// 调整堆使其成为大顶堆;index 从0开始
public static void heapSort(int initNum[], int node, int heapSize) {
int left = node * 2 + 1;
int right = node * 2 + 2;
int maxTemp = node;
if (left < heapSize) {
heapSort(initNum, left, heapSize);
}
if (right < heapSize) {
heapSort(initNum, right, heapSize);
}
if (left <= heapSize && initNum[left] > initNum[maxTemp]) {
maxTemp = left;
}
if (right <= heapSize && initNum[right] > initNum[maxTemp]) {
maxTemp = right;
}
if (maxTemp != node) {
int temp = initNum[node];
initNum[node] = initNum[maxTemp];
initNum[maxTemp] = temp;
}
}
// 归并排序
public static void SortAlgorithm7(int initNum[]) {
mergeSort(initNum, 0, initNum.length - 1);
}
// 归并递归
public static void mergeSort(int initNum[], int start, int end) {
int middle = (start + end) / 2;
if (start < end) {
mergeSort(initNum, start, middle);
mergeSort(initNum, middle + 1, end);
mergeMethed(initNum, start, middle, end);
}
}
// 合并方法
public static void mergeMethed(int initNum[], int start, int middle, int end) {
int low1 = start;
int low2 = middle + 1;
int k = 0;
int initTemp[] = new int[end - start + 1];
while (low1 <= middle && low2 <= end) {
if (initNum[low1] <= initNum[low2]) {
initTemp[k] = initNum[low1];
low1++;
k++;
} else {
initTemp[k] = initNum[low2];
low2++;
k++;
}
}
while (low1 <= middle && low2 > end) {
initTemp[k] = initNum[low1];
low1++;
k++;
}
while (low1 > middle && low2 <= end) {
initTemp[k] = initNum[low2];
low2++;
k++;
}
for (int i = 0; i < initTemp.length; i++, start++) {
initNum[start] = initTemp[i];
}
}
public static void printNums(int 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-11-11 15:35:09 发布