public class TestJson {
public static void main (String[] args){
int [] a = {2 ,4 ,253 ,66565 ,76 ,43 ,543 ,532 ,432 };
insertSort(a);
for (int x : a){
System.out.print(" " + x);
}
}
/**
* 冒泡排序:中心思想就是首先第一轮循环遍历整个数组,然后第二轮循环从第一轮循环的基础上,从他的下一个元素开始跟 它进行比较,
* 如果出现比他大(这里是实现从小到大的排序)的元素,那么这两个元素的值互换,也就是每次都在剩下的元素里面选出最小的元素,并且
* 跟当前循环的起始元素值进行交换,外层循环从0开始,就保证了每一轮循环的第一个值都是当前的最小值,循环结束,就把所有“最小元素”
* 进行了一次完整排序,从小到大。两层循环结束就完成了排序。
*
* @param data
*/
public static void popuSort (int [] data) {
for (int i = 0 ; i < data.length; i++) {
int tempIndex = i;
for (int j = i + 1 ; j < data.length; j++) {
if (data[tempIndex] > data[j]) {
int temp = data[tempIndex];
data[tempIndex] = data[j];
data[j] = temp;
}
}
}
}
/**
* 选择排序:中心思想就是首先第一轮循环遍历整个数组,然后第二轮循环从第一轮循环的基础上,从他的下一个元素开始跟它进行比较,
* 如果出现比他大(这里是实现从小到大的排序)的元素,记录下来这个比较小的元素的下标,直到每层循环结束就记录下来了剩下的i开
* 始的最小元素下标。并且与当前循环的其起始元素互换,就保证了每一轮循环的第一个值都是当前的最小值,循环结束,就把所有“最小元素”
* 进行了一次完整排序,从小到大。两层循环结束就完成了排序。
*
* @param data
*/
public static void selectSort (int [] data) {
for (int i = 0 ; i < data.length; i++) {
int tempIndex = i;
for (int j = i + 1 ; j < data.length; j++) {
if (data[j] < data[tempIndex]) {
tempIndex = j;
}
}
int temp = data[tempIndex];
data[tempIndex] = data[i];
data[i] = temp;
}
}
/**
* 插入排序:每次都是把后一个元素跟前面已经排好序的数组进行比较插入,为了保证前面的元素都已经是排好序的,当元素只有一个的时候,我们可以
* 认为是已经排好序的只有一个元素的数组,所以i从1开始。跟他前面的已经排好序的数组进行比较,如果如果data[j]>data[i]就继续往下比较,
* 因为是已经按从小到大排好序的数组,所以我们只要找到比他小的元素就可以停止了,因为是递增的。
*
* @param data
*/
public static void insertSort (int [] data) {
for (int i = 1 ; i < data.length; i++) {
int j = i - 1 ;
int temp = data[i];
while (j >= 0 && data[j] > temp) {
data[j + 1 ] = data[j];
j--;
}
data[j + 1 ] = temp;
}
}
/**
* 快速排序:任意选取一个基准数,这里选为base=data[start],为实现从小到大的排序,数组的左边放置比base小的数,
* 右边放置比base大的数字 然后从数组的两边开始遍历数组。 左边到右边遍历,直到出现>=base的数字停止遍历。i++
* 右边到左边遍历,直到出现<=base的数字停止遍历。j--
* 在两边都停止遍历之后,如果i<=j就把data[i]和data[j]的值进行互换,使的数组左边的数都是小于等于base的数
* 右边的都是大于等于base的数
* 。这样一轮下来当然无法完成全部的排序,我们只是保证了左边的元素都<=base,右边的数都>=base,而没有准确的排序,
* 所以我们再继续对两边的数组进行这样的排序,直到数组值剩下一个元素的时候,递归返回,就完成了全部的排序。
*
* @param data
* @param start
* @param end
*/
public static void quickSort (int [] data, int start, int end) {
int i = start;
int j = end;
int base = data[start];
while (i <= j) {
while (data[i] < base) {
i++;
}
while (data[j] > base) {
j--;
}
if (i <= j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
i++;
j--;
}
}
if (start < j) {
quickSort(data, start, j);
}
if (i < end) {
quickSort(data, i, end);
}
}
/**
* 归并算法:把两个已经排好序的数组再合并到一个排好序的大一点的数组,这个新的数组是new的一个大小跟两个数组长度之和相等的一
* 个数组,用来放置排好序的大数组。从两个数组的起始位置分别开始循环,比较得到小的元素就放入到新的数组里面,比较到最后把还没有放完的数组
* 一次放到数组的后面。
*
* @param data
* @param start
* @param center
* @param end
*/
public static void merge (int [] data, int start, int center, int end) {
int left = start;
int mid = center + 1 ;
int newArrayIndex = start;
int tmp = start;
int [] newArray = new int [data.length];
while (left <= center && mid <= end) {
if (data[left] > data[mid]) {
newArray[newArrayIndex++] = data[mid++];
} else {
newArray[newArrayIndex++] = data[left++];
}
}
while (left <= center) {
newArray[newArrayIndex++] = data[left++];
}
while (mid <= end) {
newArray[newArrayIndex++] = data[mid++];
}
while (tmp <= end) {
data[tmp] = newArray[tmp++];
}
}
/**
* 归并排序:把数组进行拆分,拆分到只有一个元素的时候停止,递归返回,从内到外,把所有排好序的小数组进行归并,直到
* 返回到最外层,就完成了所有的归并,实现排序。
*
* @param data
* @param start
* @param end
*/
public static void mergeSort (int [] data, int start, int end) {
if (start >= end) {
return ;
}
int center = (start + end) / 2 ;
mergeSort(data, start, center);
mergeSort(data, center + 1 , end);
merge(data, start, center, end);
}
}