排序
冒泡排序
两次for循环 一次循环可以将一个数据排好序，那两次for循环叠加就可以将整个数组的数据排好序。
java
//arr[i]>(<)arr[i+1] 交换
//走一轮用的代码
for(int i = 0;i<arr.length-1;i++){
if(arr[i]>arr[i+1]){
//交换
//并且要注意 i<arr.length-1 因为交换条件是i+1 我们需要保证不溢出
int temp = 0;
temp = arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
//总代码
for(int j=0;j<arr.length;j++){
for(int i = 0;i<arr.length-1;i++){
if(arr[i]>arr[i+1]){
//交换
//并且要注意 i<arr.length-1 因为交换条件是i+1 我们需要保证不溢出
int temp = 0;
temp = arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
}选择排序
游标 i 从左到右遍历数组，找到数组中最小值。让最小值和待排序数组中的第一位进行交换。
java
for(int j = 0;j<arr.length-1;j++){
//等排到最后一个数字时，就已经排好顺序了，所以可以长度-1
int min = arr[j];//先默认最小值是待排序数组中的第一个
int index = j;//最小值的下标
for(int i =j+1;i<arr.length;i++){
//因为前面的已经排好序了，我们只要从待排的数据后一个开始排序。
if(arr[i]<min){
min = arr[i];
index = i；
}
}
arr[index] = arr[j];
arr[j] = min;
}插入排序
java
//先令第一个元素有序，让i为第二个元素。i不断遍历，i的循环下套一个j的循环，j循环的目的是检测数组是否有序。如果无序，那么交换位置。
for(int i = 1;i<arr.length;i++){
for(int j = i-1;j>=0;j--){
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1] = arr[j];
}
}
}希尔排序
java
//就是插入排序的升级版。先分块 再插入排序。
for(int gep = arr.length/2;gep>0;gep/=2) {
//i保证的是对每个分块都进行排序
for(int i = gep;i<arr.length;i++) {
for(int j = i-gep;j>=0;j-=gep) {
if(arr[j]>arr[j+gep]) {
int temp =arr[j];
arr[j]=arr[j+gep];
arr[j+gep] =temp;
}
}
}
}基数排序
java
package com.qcby;
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int arr[] = new int[] {654,123,7,12,987,122,234,18,46,10};
sort(arr);
System.out.println(Arrays.toString(arr));
}
public static void sort(int[] arr) {
//定义二维数组来当做桶
int[][] bucket = new int[10][arr.length];
//定义一个一维数组来当做统计数据记录器
int[] count = new int[10];
//找到数组当中的最大数
int max = arr[0];
for(int i = 0;i<arr.length;i++) {
if(arr[i] > max) {
max = arr[i];
}
}
//得到最大值的位数
int maxLength = (max + "").length();
int n = 1;
for(int h = 0;h<maxLength;h++) {
for(int i = 0;i<arr.length;i++) {
int element = arr[i] / n % 10; //读取出每个数组个位的值
int num = count[element]; //根据个位的值的值找到桶内有多少数据
bucket[element][num] = arr[i]; //将数据放入到桶当中
count[element] = count[element]+1; //数据记录器响应位置+1
}
//将数据取出
int index = 0;
for(int k = 0; k<10;k++){
if(count[k]!=0){
for(int l = 0; l<count[k];l++){
arr[index] = bucket[k][l];
index++;
}
count[k] = 0; //清空桶记录器
}
}
n= n * 10;
}
}
}
归并排序
java
public void mergeSort(int[] arr, int low, int high) {
// 递归结束条件：当low等于high时，表示已经只剩一个元素，不需要再继续递归划分了
if (low < high) {
// 计算中间位置，对左右两个子数组分别进行递归划分
int mid = (low + high) / 2;
mergeSort(arr, low, mid);
mergeSort(arr, mid + 1, high);
// 将左右两个有序子数组合并为一个有序数组
merge(arr, low, mid, high);
}
}
/**
* 合并左右两个有序子数组为一个新的有序数组
* @param arr 原数组
* @param low 左子数组的起始位置
* @param mid 左子数组的结束位置，同时也是右子数组的起始位置-1
* @param high 右子数组的结束位置
*/
public void merge(int[] arr, int low, int mid, int high) {
// 新建一个临时数组来存储排序后的结果
int[] temp = new int[high - low + 1];
int i = low; // 左子数组起始位置
int j = mid + 1; // 右子数组起始位置
int k = 0; // 临时数组的下标
// 将左右两个子数组中较小的元素依次放入临时数组中
while (i <= mid && j <= high) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
// 如果左子数组还有剩余，则将其全部复制到临时数组中
while (i <= mid) {
temp[k++] = arr[i++];
}
// 如果右子数组还有剩余，则将其全部复制到临时数组中
while (j <= high) {
temp[k++] = arr[j++];
}
// 将临时数组中的元素复制回原数组中
for (int p = 0; p < temp.length; p++) {
arr[low + p] = temp[p];
}
}快速排序
java
package com.qcby;
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int arr[] = new int[] {5,7,4,2,0,3,1,6};
quickSort(arr, 0, arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left,int right) {
if(left >= right) { // left > right | left == right
return;
}
int base = arr[left]; //基准数
int i = left; //两个游标
int j = right;
//当 i 和 j 不相遇的时候，重复以下过程
while(i != j) {
while(arr[j]>=base && i<j) {
j--;
}
while(arr[i]<=base && i<j) {
i++;
}
//数据交换
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//相遇位置的数和基准数交换
arr[left] = arr[i];
arr[i] = base;
quickSort(arr, left, i-1,i,j);
quickSort(arr, i+1, right,i,j);
}
}