java版本实现排序算法的
冒泡排序
两个for 虚幻遍历 第一个数从总的个数一次减小 第二是比较剩余中的最大的,或者是最小的数据。
/**
* Copyright (C), 2018-2020
* FileName: BubboSort
* Author: xjl
* Date: 2020/3/19 14:50
* Description: 冒泡排序原理
*/
package ArraySort;
public class BubboSort {
public static int[] BubboSort(int[] number) {
//控制比较的排序的次数
for (int i = number.length - 1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
if (number[j] > number[j + 1]) {
int temp = number[j];
number[j] = number[j + 1];
number[j + 1] = temp;
}
}
}
return number;
}
public static void main(String[] args) {
int count=200000;
int[] number =new int[count];
for (int i=0;i<count;i++){
number[i]=(int) (Math.random()*100);
}
long st=System.currentTimeMillis();
int[] number2 = BubboSort(number);
long end=System.currentTimeMillis();
for (int i = 0; i <number2.length; i++) {
System.out.println(number2[i]);
}
System.out.println(end-st);
}
}
选择排序
选择排序就是首先应该是的选择最小的数据的将其放入前面。
/**
* Copyright (C), 2018-2020
* FileName: Select_sort
* Author: xjl
* Date: 2020/3/24 8:18
* Description: 选择排序
*/
package JAVA_sort_arithmetic.src.base_sort;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
//选择排序就是为了在剩下的数据中找到最小的数然后与i进行交换
public class Select_sort {
public int[] select(int[] numbers) {
//第一遍是遍历从第一个到倒数的第二个
for (int i = 0; i < numbers.length - 1; i++) {
int min = i;
for (int j = i + 1; j < numbers.length; j++) {
if (numbers[j] < numbers[min]) {
min = j;
}
}
int temp = numbers[i];
numbers[i] = numbers[min];
numbers[min] = temp;
}
return numbers;
}
/**
* 插入时候就是为了在将剩下的开始插入到里面去
*
* @param numbers
* @return
*/
public int[] insert(int[] numbers) {
for (int i = 1; i < numbers.length; i++) {
for (int j = i; j > 0; j--) {
if (numbers[j] < numbers[j - 1]) {
int temp = numbers[j];
numbers[j] = numbers[j - 1];
numbers[j - 1] = temp;
} else {
break;
}
}
}
return numbers;
}
@Test
public void test2() {
int[] numbers = {5, 1, 8, 9, 4, 5, 8, 6};
for (Integer va : insert(numbers)) {
System.out.println(va);
}
String[] Array = {"a", "b", "c", "d", "e"};
}
@Test
public void test3() {
String[] aa = {"a", "b", "c", "d", "e"};
List list = Arrays.asList(aa);
Collections.reverse(list);
System.out.println(list);
//System.out.println(new StringBuilder(Arrays.toString(aa)).reverse().toString());
//System.out.println(new StringBuilder(Array.toString()).reverse().toString());
System.out.println("*************************************");
StringBuffer sb = new StringBuffer("abcd");
System.out.println(sb.reverse().toString());
}
@Test
public void test() {
int[] numbers = {5, 1, 8, 9, 4, 5, 8, 6};
for (Integer va : select(numbers)) {
System.out.println(va);
}
}
}
插入排序
分为两组已经排序的和后面没有排序的,第一个for 从第1个数据遍历到倒数第二个数据,然后在遍历其中的前面的第j-1个数据的大小,不多的比较 如果遇见大于的则直接跳出来,进入下一个比较就好。
/**
* Copyright (C), 2018-2020
* FileName: Insertsort
* Author: xjl
* Date: 2020/3/19 15:28
* Description: c插入排序
*/
package ArraySort;
import org.junit.Test;
public class Insertsort {
public static int[] Insertsort(int[] number) {
for (int i = 1; i < number.length; i++) {
for (int j = i; j >0; j--) {
if (number[j-1]>number[j]) {
int temp = number[j];
number[j - 1] = number[j];
number[j] = temp;
} else {
break;
}
}
}
return number;
}
@Test
public void test() {
int count = 5;
int[] number = new int[count];
for (int i = 0; i < count; i++) {
System.out.println(number[i] = (int) (Math.random() * 10));
}
int[] number2 = Insertsort(number);
System.out.println("*******************************************");
for (int value : number2) {
System.out.println(value);
}
}
}
希尔排序
选定一的增长量h 按照增长量的h作为数据分组的依据 对每一次的分好数组的进行插入的排序的操作, 接着就是减少增长量,减少到1在一次的执行插入排序的操作。 其中h的初始值的确定是:
扫描二维码关注公众号,回复:
11299558 查看本文章
/**
* Copyright (C), 2018-2020
* FileName: shell_my
* Author: xjl
* Date: 2020/3/24 11:51
* Description: 希尔排序
*/
package JAVA_sort_arithmetic.src.high_sort;
import org.junit.Test;
/**
* 希尔排序的原理是
* 选定一个增长的量h 按照增长的量h作为数据的分组的依据 对数据的进行分组
* 对分好组的每一组数据完成插入的排序
* 减少增长量 最下减到1 这个操作
*/
public class shell_my {
public int[] shell(int[] numbers) {
//根据数组长度 确定h
int h = 1;
while (h < numbers.length / 2) {
h = 2 * h + 1;
}
while (h >= 1) {
//排序
//找到带插入的元素
for (int i = h; i < numbers.length; i++) {
//把代插入的元素插入到有序的数列中
for (int j = i; j >= h; j -= h) {
//代插入的元素
if (numbers[j] < numbers[j - h]) {
int temp = numbers[j];
numbers[j] = numbers[j - h];
numbers[j - h] = temp;
} else {
break;
}
}
}
//减少h的值
h = h / 2;
}
return numbers;
}
@Test
public void test() {
int[] numbers = {5, 1, 8, 9, 4, 5, 8, 6};
for (Integer va : shelltest(numbers)) {
System.out.println(va);
}
}
public int[] shelltest(int[] numbers) {
//确定h 的增强的量
int h = 1;
while (h < numbers.length / 2) {
h = 2 * h + 1;
}
while (h >= 1) {
//找到分组的排序的元素 选择插入排序原理
for (int i = h; i < numbers.length; i++) {
for (int j = i; j >= h; j -= h) {
if (numbers[j] < numbers[j - h]) {
int temp = numbers[j];
numbers[j] = numbers[j - h];
numbers[j - h] = temp;
} else {
break;
}
}
}
h = h / 2;
}
return numbers;
}
}
归并排序
/**
* Copyright (C), 2018-2020
* FileName: Merge_new
* Author: xjl
* Date: 2020/3/24 12:46
* Description: 归并排序
*/
package JAVA_sort_arithmetic.src.high_sort;
/**
* 归并排序就是的: 递归+分离+双指针
*/
public class Merge_new {
//需要一个辅助的数组
private static Comparable[] assit;
//对数组内的元素进行排序
public static void sort(Comparable[] a) {
//初始化数组assit
assit = new Comparable[a.length];
//定义一个lo变量 和hi变量 分别记录数组中最小的索引和最大的索引:
int lo = 0;
int hi = a.length - 1;
//调用重载的sort方法完成数据a中,从索引库lo到hi的元素的排序
sort(a, lo, hi);
}
//对数组的lo到hi之间进行排序
public static void sort(Comparable[] a, int lo, int hi) {
//安全校验
if (lo >= hi) {
return;
}
//对数据lo 到hi之间的分为两个数据
int mid = lo + (hi - lo) / 2;
//这里是递归的算法
sort(a, lo, mid);//递归调用自己
sort(a, mid + 1, hi);
//在把两个组的数据进行归并
merge(a, lo, mid, hi);
}
//从索引lo到mid为一个子数组 从mid+1到hi为一个数组 将a中的两个子数组数据合并成为一个大的有序的数组
public static void merge(Comparable[] a, int lo, int mid, int hi) {
//定义三个指针
int i = lo;//assit的指针
int p1 = lo;//左数组
int p2 = mid + 1;//右数组
//遍历p1 p2的比较对应的索引的值 找到那个比较小的 放置到辅助的数组中
while (p1 <= mid && p2 <= hi) {
if (less(a[p1], a[p2])) {
assit[i++] = a[p1++];
} else {
assit[i++] = a[p2++];
}
}
//遍历,如果p1没有走完,那就移动p1指针,把对应的元素的放置到数组中找到对应的所引处
while (p1 <= mid) {
assit[i++] = a[p1++];
}
//遍历,如果p2没有走完,那就移动p2指针,把对应的元素的放置到数组中找到对应的所引处
while (p2 <= hi) {
assit[i++] = a[p2++];
}
//再将辅助数组赋值到原来的数组中
for (int index = lo; index <= hi; index++) {
a[index] = assit[index];
}
}
//比较两个元素的大小
public static Boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
}
快速排序
/**
* Copyright (C), 2018-2020
* FileName: qiucksort
* Author: xjl
* Date: 2020/3/24 16:45
* Description: 快速排序原理
*/
package JAVA_sort_arithmetic.src.high_sort;
public class qiucksort {
//对数组的元素进行排序
public static void sort(Comparable[] a) {
int low = 0;
int hi = a.length - 1;
sort(a, low, hi);
}
//对数组a中lo到hi之间的元素进行排序
public static void sort(Comparable[] a, int lo, int hi) {
//安全索引
if (hi <= lo) {
return;
}
//从lo到hi进行分组为2组
int partition = partition(a, lo, hi);//分界值的位置变换后的索引
//让左边有序
sort(a, lo, partition - 1);
//让右边有序
sort(a, partition + 1, hi);
}
//对数组a中lo到hi之间的元素进行分组 并但会对应的分组界限的索引
public static int partition(Comparable[] a, int lo, int hi) {
//确定分界值设定第一个为分界值
Comparable key = a[lo];
//定义两个指针
int left = lo;
int right = a.length - 1;
while (true) {
//先从右向左扫描移动right 找到一个比分界值小的元素 停止
while (less(key, a[--right])) {
if (right == lo) {
break;
}
}
//在从左边想右边移动left 找到一个比分界值大的元素 停止
while (less(a[++left],key)) {
if (left == hi) {
break;
}
}
//判断left>=right 如果是那就证明元素扫描完毕,如果不是的话则需要交换元素1
if (left >= right) {
break;
} else {
exch(a, left, right);
}
}
//交换分界的值
exch(a, lo, right);
return right;
}
//比较元素
private static Boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
//交换元素
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
}