标签：index arr int ++ length 数组 排序 public
冒泡排序
package com.cm.array;
import java.util.Arrays;
public class BubbleSort {
//冒泡排序 时间复杂度(O2)
//1.比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.每一轮比较都会减少一次排序
//4.依次循环直至结束
public static void bubbleSort(int[] array){
int temp = 0;
for (int i = 0; i < array.length-1; i++) {
boolean flag = false;
for (int j = 0; j < array.length-1-i; j++) {
if(array[j]>array[j+1]){
SwapVlaue.swapVlaue(array,j,j+1);
flag = true;
}
}
if(!flag){
break;
}
}
System.out.println(Arrays.toString(array));
}
}
希尔排序
package com.cm.array;
import java.util.Arrays;
/**
* @Author: YorSaeng
* @CreateTime: 2021-07-24-22:32
* @Description: com.cm
*/
public class ShellSort {
//希尔排序:是对插入排序的优化，核心的思想合理的选取增量，经过一轮排序后，使得序列大致有序
//不断的缩小增量，进行插入排序，直至增量为1时排序结束
//直接插入排序，本质上是增量为1的希尔排序
public static void shellSort(int[] arr){
//选取一个增量，普通选择的增量为数组长度的一半
/*
for(int h=arr.length/2; h>0; h/=2){
for (int i = 0; i < arr.length/2; i++) {
if(arr[i]>arr[i+h]){
SwapVlaue.swapVlaue(arr, i,i+h);
}
}
}
*/
//选取增量时可采用科鲁特(Knuth)序列提高效率 h = 3 * h + 1
int x = 1;
while (x <= arr.length/3){
x = 3 * x + 1;
}
for(int h=x; h>0; h/=2){
for (int i = 0; i < arr.length/2; i++) {
if(arr[i]>arr[i+h]){
SwapVlaue.swapVlaue(arr, i,i+h);
}
}
}
System.out.println(Arrays.toString(arr));
}
}
选择排序
package com.cm.array;
import java.util.Arrays;
/**
* @Author: YorSaeng
* @CreateTime: 2021-07-24-14:56
* @Description: com.cm
*/
public class SelectSort {
public static void selectSort(int[] arr) {
/*选择排序
* 从0索引开始，依次和后面的元素进行比较，小的元素往前放，
* 经过一轮比较后，最小的元素就出现在了最小索引处。
* */
//第一轮比较取出最小值且将它置于最小索引
//将index+1进行下一轮的排序
//排序arr.length-1次完成
for (int index = 0; index < arr.length - 1; index++) {//最后一个数无需再比较，所以只需执行arr.length-1次
for (int i = index + 1; i < arr.length; i++) {//i=index+1使index始终与它下一个元素进行比较
if(arr[index]>arr[i]){
SwapVlaue.swapVlaue(arr,index,i);
}
}
}
System.out.println(Arrays.toString(arr));
}
}
直接插入排序
package com.cm.array;
import java.util.Arrays;
/**
* @Author: YorSaeng
* @CreateTime: 2021-07-24-15:55
* @Description: com.cm
*/
public class DirectInsertionSort {
//直接插入排序
//从1索引开始，将后面的元素，插入到之前的有序列表之中使之仍然有序
public DirectInsertionSort(int[] arr) {
//外层定义循环轮次
for (int i = 1; i < arr.length; i++) {
//内层进行值的交换
for (int j = i; j > 0; j--) {//j>0避免ArrayIndexOutOfBounds错误,j--负责跟前面所有的值进行比较
if(arr[j]<arr[j-1]){
SwapVlaue.swapVlaue(arr, j,j-1);
}
}
}
System.out.println(Arrays.toString(arr));
}
}
快速排序
package com.cm.array;
import java.util.Arrays;
/**
* @Author: YorSaeng
* @CreateTime: 2021-07-25-19:20
* @Description: com.cm
*/
public class QuickSort {
//快速排序
//分治法：比大小，再分区
//1.从一个数组中取出一个数，作为基准数
//2.分区：将比这个数大或等于的数全部放到它的右边，小于它的数放到它的左边
//3.再对左右区间重复第二步，直到各个区间只有一个数
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);
}
}
//1.将基准数挖出形成第一个坑
//2.从后往前找，找到比他小的数时挖出此数填到前一个坑中
//3.从前往后找，找到比他大的数时挖出此数填到前一个坑中
//4.重复执行2,3两步骤
private static int getIndex(int[] arr, int start, int end) {
int i = start;
int j = end;
int x = arr[i];
while(i < j){
//从后往前找，找到比他小的数时j就是找到的数的索引
while (i < j && arr[j] >= x){
j--;
}
if(i < j){
arr[i] = arr[j];
i++;
}
//从前往后找，找到比他大的数时i就是找到的数的索引
while (i < j && arr[i] < x){
i++;
}
if(i < j){
arr[j] = arr[i];
j--;
}
}
arr[i] = x;
return i;
}
}
归并排序
package com.cm.array;
import java.util.Arrays;
/**
* @Author: YorSaeng
* @CreateTime: 2021-07-26-16:00
* @Description: com.cm
*/
public class MergeSort {
//归并排序
//假设初始序列有N个记录，则可以看成是N个有序的子序列，每个子序列的长度为1
//然后两两归并，得到N/2个长度为2或1的子序列
//重复归并步骤，直至得到一个长度为N的有序序列
public static void MergeSort(int[] arr){
//拆分
sortArr(arr,0,arr.length-1);
//归并
//merge(arr,0, arr.length/2 - 1, arr.length-1);
System.out.println(Arrays.toString(arr));
}
private static void sortArr(int[] arr, int startIndex, int endIndex) {
int centerIndex = (endIndex + startIndex)/2;
if(startIndex < endIndex){
sortArr(arr,startIndex,centerIndex);
sortArr(arr,centerIndex+1,endIndex);
merge(arr,startIndex,centerIndex,endIndex);
}
}
private static void merge(int[] arr, int startIndex, int centerIndex, int endIndex) {
//定义左边数组的起始索引
int i = startIndex;
//定义右边数组的起始索引
int j = centerIndex + 1;
//定义临时数组的索引
int index = 0;
//定义临时数组
int[] temp = new int[endIndex - startIndex + 1];
while (i <= centerIndex && j <= endIndex){
if (arr[i] > arr[j]) {
temp[index] = arr[j];
j++;
} else if (arr[i] <= arr[j]) {
temp[index] = arr[i];
i++;
}
index++;
}
//处理剩余元素
while (i <= centerIndex){
temp[index] = arr[i];
i++;
index++;
}
while (j <= endIndex){
temp[index] = arr[j];
j++;
index++;
}
//还原数组
for (int k = 0; k < temp.length; k++) {
arr[k+startIndex] = temp[k];
}
}
}
基数排序
package com.cm.array;
/**
* @Author: YorSaeng
* @CreateTime: 2021-07-28-19:53
* @Description: com.cm
*/
public class RadixSort {
//基数排序：利用分配再收集进行排序
public static void radixSort(int[] arr){
//定义二维数组存放分配的数据元素
int[][] temp = new int[10][arr.length];
//定义一维的统计数组存放相关索引下的数据个数
int[] counts = new int[10];
int max = getMax(arr);
//获取最大值的位数长度
int len = String.valueOf(max).length();
//按照位数循环，可以对相同位数的数值进行分配
for (int i = 0, n = 1; i < len; i++, n *= 10) {
for (int j = 0; j < arr.length; j++) {
int remainder = arr[j]/n%10;
//将分配的arr[j]存储到temp数组中
//counts[remainder]++代表该索引(余数值)下的数据个数，每次存储使个数值+1
temp[remainder][counts[remainder]++] = arr[j];
}
//还原数组
int index = 0;
for (int k = 0; k < counts.length; k++) {
if(counts[k]!=0){
for (int h = 0; h < counts[k]; h++) {//counts[k]为索引下的数据个数
arr[index] = temp[k][h];
index++;
}
}
counts[k] = 0;
}
}
}
//获取数组的最大值
private static int getMax(int[] arr) {
int temp = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]>temp){
temp = arr[i];
}
}
return temp;
}
}
标签：index,arr,int,++,length,数组,排序,public 来源： https://www.cnblogs.com/YorSaeng/p/15115000.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。