冒泡排序
算法思路： 数组元素两两进行比较，将大数往后放，经过一轮后最大的元素会出现在最后如此往复，整个数组就有序了。
原理图：
代码实现：
public class Demo {
public static void main(String[] args) {
//冒泡排序
int[] arr={
10,2,43,32,12,53,98,-10,34,41};
for (int j = 0; j < arr.length - 1;j++) {
//外循环实现循环的轮数
for (int i = 0; i < arr.length - 1-j; i++) {
//内循环实现一轮的循环
if(arr[i]>=arr[i+1]){
int t =arr[i];
arr[i]=arr[i+1];
arr[i+1]=t;
}
}
}
}
}
选择排序
**算法思路：**每次拿一个元素和后边所有的元素挨个比较，小的数往前放，经过一轮比较，最小的元素会出现在最前面，如此往复，这个数组就有序了。
原理图：
代码实现：
public class Demo2 {
public static void main(String[] args) {
//选择排序
int[] arr={
10,9,4,19,23,67,34,82,-19,-34,66};
for (int index = 0; index < arr.length-1; index++) {
//实现轮数
for (int i = 1+index; i < arr.length; i++) {
//实现美每轮的循环
if(arr[index]>=arr[i]){
int t=arr[index];
arr[index]=arr[i];
arr[i]=t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
插入排序
算法思路： 将一个记录插入到一个长度为m 的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表.假设有一组元素{k1,k2…,kn},排序开始就认为k1是一个有序序列,让k2插入上述表长为1的有序序列,使之成为一个表长为2的有序序列,然后让k3插入上述表长为2的有序序列,使之成为一个表长为3的有序序列,以此类推,最后让kn插入表长为n-1的有序序列,得到一个表长为n的有序序列.
原理图：
代码实现：
public class Demo3 {
public static void main(String[] args) {
//插入排序
int[] arr={
10,9,4,19,23,67,34,82,-19,-34,66};
for (int i = 1; i < arr.length; i++) {
for(int j=0;j<i;j++){
if(arr[j]>arr[i]){
int t=arr[j];
arr[j]=arr[i];
arr[i]=t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
快速排序
算法思路：
挖坑填数
- 将基准数挖出形成第一个坑。
- 由后向前找比他小的数，找到后挖出此数填到前一个坑中。
- 由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
再重复执行2，3两步骤
原理图：
public class QuickSortName {
public static void quicksort(int[] arr, int start, int end) {
if (start < end) {
int index = getIndex(arr, start, end);
//在左半部分实现
quicksort(arr, start, index - 1);
//右半部份实现
quicksort(arr, index + 1, end);
}
}
private static int getIndex(int[] arr, int start, int end) {
int i = start;
int j = end;
int t = arr[i];
while (i < j) {
while (i < j && arr[j] > t) {
j--;
}
if (i < j) {
arr[i] = arr[j];
i++;
}
while (i < j && arr[i] < t) {
i++;
}
if (i < j) {
arr[j] = arr[i];
j--;
}
}
arr[i] = t;
return i;
}
}
public class MyTest {
public static void main(String[] args) {
int[] arr = {
10, 9, 4, 80, 97, 104, 37, -100, 76};
QuickSortName.quicksort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
}
二分法查找
算法思路： 每一次查找中间元素，比较大或者小就能缩小一般元素
原理图：
扫描二维码关注公众号，回复：
11922197 查看本文章
代码实现：
public class Demo {
public static void main(String[] args) {
//二分发查根据元素查索引
int[] arr = {
10, 9, 4, 80, 97, 104, 37, -100, 76};
QuickSortName.quicksort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
int index = getIndex(arr, 111111);
System.out.println("索引是："+index);
}
private static int getIndex(int[] arr, int i) {
int minindex = 0;
int maxindex = arr.length - 1;
int midindex = (minindex + maxindex) / 2;
while (minindex < maxindex) {
if (i == arr[midindex]) {
return midindex;
} else if (i > arr[midindex]) {
minindex = midindex + 1;
} else if (i < arr[midindex]) {
maxindex = midindex - 1;
}
midindex=(minindex+maxindex)/2;
}
return -1;
}
}