标签：中转 bool 记录 临时 直接 void 小数 cts 空间
常用的也是简单的排序算法
个人理解：
第二层循环条件中可以减去i，因为i每次循环后都会得一个最值往后面冒泡，即i下标后面的数已经是排序好的了不用再次对比了
//冒泡排序
public class BubbleSort {
public static void main(String[] args){
int[] arr = {3,9,-1,10,20};
System.out.println("原数组："+Arrays.toString(arr));
bubbleSort(arr);
}
public static void bubbleSort(int[] arr){
int temp = 0;
boolean flag = false;//标识变量，表示一轮对比中是否发生交换
for (int i=0;i<arr.length;i++){
//j为什么要减i，因为第i次循环时，已经有i个最大的数在后面从小到大排好了。
// 为什么要减1：因为需要留出一个，让当前数和后面的对比。不减1，当当前元素即j到达最后一个，由于后面没有元素则会溢出
for (int j=0;j<arr.length-i-1;j++){
if (arr[j]>arr[j+1]){ //即通过前后两个数对比，大于就交换，让当前一直保持最大直到比到最后，
temp =arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
个人理解：
public class InsertSort {
public static void main(String[] args){
int[] arr = {3,9,-1,10,20};
System.out.println("原数组："+ Arrays.toString(arr));
insertSort(arr);
System.out.println("排序后："+Arrays.toString(arr));
}
public static void insertSort(int[] arr){
int preIndex;
int current;
for (int i = 1; i < arr.length; i++) {
preIndex = i; //当前元素下标
current = arr[i];//当前元素值
while (preIndex>0 && arr[preIndex-1] > current){
arr[preIndex] = arr[preIndex-1];//把数往前移动一位
preIndex--;
}
//移动完后把当前值插入到对应位置
arr[preIndex] = current;
}
}
}
//选择排序
public class SelectSort {
public static void main(String[] args){
int[] arr = {3,9,-1,10,20};
System.out.println("原数组："+Arrays.toString(arr));
selectSort(arr);
System.out.println("排序后："+Arrays.toString(arr));
}
public static void selectSort(int[] arr) {
if (arr.length<2){
return;
}
int minIndex; //假定最小数下标
int min; //存储最小值
for (int i = 0; i < arr.length-1; i++) {
minIndex = i; //假定最小值下标等于循环时第一个元素的下标
min = arr[i]; //假定最小值为循环中的第一个元素
for (int j = i+1; j < arr.length; j++) {
if (arr[j] < min){ //arr[i] 相当于是最小值
min = arr[j];
minIndex = j;
}
}
//把最小值交换到前面。
if (minIndex != i){
arr[minIndex] = arr[i];
arr[i] = min;
}
}
}
}
//归并排序
public class MergetSort {
public static void main(String[] args) {
int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
System.out.println("原数组："+ Arrays.toString(arr));
int[] temp = new int[arr.length];
mergetSort(arr,0,arr.length-1,temp);
System.out.println("排序后："+Arrays.toString(arr));
}
//分+合的方法
public static void mergetSort(int[] arr,int left,int right,int[] temp){
if (left<right){
int mid = (left+right)/2;
//向左递归分解
mergetSort(arr,left,mid,temp);
//向右递归分解
mergetSort(arr,mid+1,right,temp);
//分解一次就合并一次
merget(arr,left,mid,right,temp);
}
}
//合并两个有序数组的方法
/**
*
* @param arr 数组原始索引
* @param left 左边有序数组的初始索引
* @param mid 中间索引
* @param right 右边数组索引
* @param temp 中转数组--即合并两个数组的有序数组
*/
public static void merget(int[] arr,int left,int mid,int right ,int[] temp){
int l = left; //初始化i，左边初始索引
int r = mid+1; //右边初始索引
int t = 0;
//先把左右两边(有序)数组按照规则填充打temp
//左右两边有序数组，有一边处理完成，则把另一边的直接拷贝就行了
while (l <= mid && r<=right){
if (arr[l] <= arr[r]) { //左数组元素比右数组元素小
temp[t] = arr[l]; //左边元素加入数组
t+=1; //有序数组下标加1
l+=1; //左边数组下标加1
}else { //反之，右边数组元素比左数组元素小
temp[t] = arr[r]; //左边元素加入数组
t+=1; //有序数组下标加1
r+=1; //左边数组下标加1
}
}
//右边数组遍历完，但是左边没有遍历完
while (l <= mid){
temp[t] = arr[l]; //左边元素加入数组
t+=1; //有序数组下标加1
l+=1; //左边数组下标加1
}
//左边数组遍历完，但是右边没有遍历完
while (r <= right){
temp[t] = arr[r]; //左边元素加入数组
t+=1; //有序数组下标加1
r+=1; //左边数组下标加1
}
//把temp数组元素拷贝到arr
t = 0;
int tempLeft = left;
while (tempLeft <= right){ //把排序好的数组拷贝回原数组
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
}
}
选择一个中轴值，小在左，大在右，一直分治
public class QuickSort2 {
public static void main(String[] args){
int[] arr = {101,34,119,1,-1,90,123};
System.out.println("原数组："+ Arrays.toString(arr));
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){
return;
}
int l = left;//记录最右边
int r = right;//记录最左边
// 1-基于基准值交换----快速排序就是找一个基准值，把小的放基准值前面，大的放基准值后面
int pivot = arr[l];//获取基准值=第一个元素
int temp = 0;//临时变量，交换使用
while (l<r){
//由于是在同一个数组操作，所以需要左右两边一起操作
//由于要把基准值交换，所以右边最后一定是小于基准值的，所以需要优先判断，即从右边走
while (arr[r] >= pivot && l<r){
//右边如果小于基准值，下标减1
r--;//保证下标r的值小于基准值
}
while (arr[l] <= pivot && l<r){
//左边如果小于基准值，下标加1
l++; //保证下标l的值大于基准值
}
//因为找到了左边大于基准值，右边小于基准值的两个值，所有左右两边值进行交换
if (l<r){
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
}
}
//2-基准值归位-----循环结束后l肯定等于r，并且由于是从右边开始走的所以最后下标r的值一定小于基准值，直接交换即可
arr[left] = arr[r];
arr[r] = pivot;
//3-递归----最后左右递归一直分治，基准值已经在合适的位置了就不用参与排序了
//左递归
quickSort(arr,left,r-1);
//右递归
quickSort(arr,r+1,right);
}
}
//基数排序
public class RadixSort {
public static void main(String[] args){
int[] arr = {53,3,542,748,14,214};
System.out.println("原数组："+ Arrays.toString(arr));
radixSort(arr);
System.out.println("排序后："+Arrays.toString(arr));
}
//基数排序方法
public static void radixSort(int[] arr){
//1-得到最大位数
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max){
max = arr[i];
}
}
//2-得到最大数是几位数
int maxLength = (max+"").length();
//定义一个二维数组，表示10个桶.每一行即一维数组表示一个桶
// 为了防止放入数的时候，数据溢出，则每个一维数组（），大小定位arr.length
// 明确：基数排序是使用空间换时间。
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中实际存放多少个数据，定义一个一维数组来记录各个桶放入数据的个数
int[] bucketElementCounts = new int[10]; //对应存放十个桶中，最后一个元素的下标，即桶存储了几个数据
//3-循环
for (int i = 0,n=1; i < maxLength; i++,n*=10) {
//针对每个元素对应位进行排序处理 ，第一是个位，第二是百位，第三是千位 .......
for (int j = 0; j < arr.length; j++) {
//取出每个元素个位数，相当于要存放桶的下标
int digitaOfElement = arr[j]/n % 10;
//放入对应的桶中
//bucketElementCounts[digitaOfElement] 即存放在一行（桶）中的哪个位置
bucket[digitaOfElement][bucketElementCounts[digitaOfElement]] = arr[j];
//对应桶元素下标后移一位，也相当于对应桶记录元素个数数组加1
bucketElementCounts[digitaOfElement]++;
}
//按照桶的顺序依次取出数据放入原来的数组
int index = 0;
for (int k = 0; k < bucketElementCounts.length; k++) {
//如果桶中有数据，才放入原数组中
if (bucketElementCounts[k] != 0){ //桶对应记录!=0,即记录的下标不为0，即该桶不为空
for (int l = 0; l < bucketElementCounts[k]; l++) {
//取出元素放入到原数组
arr[index++] = bucket[k][l];
}
}
//一轮处理后，需要将每个bucketElementCounts[k] = 0，即指向每个桶对应记录数组的下标都置会0，即初始
bucketElementCounts[k] = 0;
}
}
}
}
//希尔排序
public class ShellSort {
public static void main(String[] args){
int[] arr = {8,9,1,7,4,2,3,5,4,6,0};
System.out.println("原数组："+ Arrays.toString(arr));
shellSort2(arr);
System.out.println("排序后："+Arrays.toString(arr));
}
//希尔排序----交换法
public static void shellSort(int[] arr){
int temp;
for (int gap = arr.length/2; gap > 0; gap /= 2) { // 分组，每组一半
for (int i = gap; i < arr.length ; i++) { //从gap开始往前对应一个元素对比 这里是gap开始
for (int j = i-gap; j >= 0; j-=gap) { //这里是gap对应的元素
//如果当前元素大于加上步长后的那个元素，就要交换
if (arr[j] > arr[j+gap]){
temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}
}
//希尔排序----移位法
public static void shellSort2(int[] arr){
int temp;
for (int gap = arr.length/2; gap > 0; gap /= 2) { // 分组，每组一半
// 从gap个元素，逐个对其所在的组进行直接插入排序
for (int i = gap; i < arr.length ; i++) {
int j = i;
temp = arr[j]; //存放当前值
// if (arr[i] < arr[j-gap]){
while (j-gap >= 0 && arr[j-gap] > temp){
//移动
arr[j] = arr[j-gap];
j-=gap;
}
//当退出循环，说明找到插入位置
arr[j] = temp;
// }
}
}
}
}
标签：中转 bool 记录 临时 直接 void 小数 cts 空间
原文地址：https://www.cnblogs.com/xiaoaiying/p/14033694.html
