1.冒泡排序
package sort;
//冒泡排序
public class BubbleSort {
public static void main(String[] args) {
int[] dong = {3, 9, -1, 10, -2};
boolean flag=false;//标识变量,表示是否进行交换
for (int i = dong.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (dong[j] > dong[j + 1]) {
flag=true;
int temp;
temp = dong[j];
dong[j] = dong[j + 1];
dong[j + 1] = temp;
}
}
if(!flag){//在一趟排序中,一次交换都没有发生过
break;
}else {
flag=false;//重置flag,进行下次交换
}
}
for (int i = 0; i < dong.length; i++) {
System.out.println(dong[i]);
}
}
}
(ps:其中的flag可能在特定的序列中提高冒跑排序的速度的,不写也不影响)
2.插入排序
package sort;
import java.util.Arrays;
//插入排序
public class InsertSort {
public static void main(String[] args) {
int[] arr = {101, 34, 119, 1};
insertSort(arr);
}
//插入排序
public static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
//定义待插入数
int insertVal = arr[i];
int insertIndex = i - 1;//即arr[i]的前面这个数的下标
//给insertVal找到插入的位置
//1.insertIndex>=0保证在给insertIndex找插入位置时,不越界
//2.insertVal<arr[insertIndex]待插入的数,还没有找到插入位置
//3.就需要将arr[insertIndex]后移
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];//insertIndex后移
insertIndex--;
}
//当退出while循环时,说明位置已经找到,insertIndex+1
//这里优化代码
if (insertIndex+1!=i) {
arr[insertIndex + 1] = insertVal;
System.out.println(Arrays.toString(arr));
}
}
}
}
3.归并排序
package sort;
import java.util.Arrays;
//归并排序
public class MergetSort {
public static void main(String[] args) {
int[]arr={8,4,5,7,1,3,6,2};
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 i=left;//初始化i,左边有序序列的初始索引
int j=mid+1;//初始化j,右边有序序列的初始索引
int t=0;//指向temp数组的当前索引
//先把左右两边有序的数据按照规则填充到temp数组中
//直到左右两边的有序序列,有一边处理完毕
while (i<=mid&&j<=right) {//继续
//如果左边的有序序列的当前元素,小于等于右边有序序列的当前元素
//即将左边的当前数据拷贝到temp数组中
//然后t++,i++
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
t += 1;
i += 1;
} else{//如果左边的有序序列的当前元素,大于右边有序序列的当前元素
//即将右边的当前数据拷贝到temp数组中
//然后t++,i++
temp[t] = arr[j];
t += 1;
j += 1;
}
}
//把剩余数据的一边的数据全部填充到temp
while (i<=mid){//左边还有剩余
temp[t]=arr[i];
t += 1;
i += 1;
}
while (j<=right){//右边还有剩余
temp[t]=arr[j];
t += 1;
j += 1;
}
//将temp数组的元素拷贝到arr
//注意,并不是每次都拷贝所有
t=0;
int tempLeft=left;
while (tempLeft<=right){
arr[tempLeft]=temp[t];
t+=1;
tempLeft+=1;
}
}
}
4.快速排序
package sort;
import java.util.Arrays;
//快速排序法
public class QuickSort {
public static void main(String[] args) {
int[] arr={-9,78,0,23,-567,70};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left,int right){
int l=left;//左下标
int r=right;//右下标
//pirvot 中轴值
int pirvot=arr[(left+right)/2];
//while循环的目的是让比pirvot值小的放在左边,大的放在右边
while (l<r){
//在pirvot的左边一直找,找到大于等于pirvot值,才退出
while (arr[l]<pirvot){
l+=1;
}
//在pirvot的右边一直找,找到小于等于pirvot值,才退出
while (arr[r]>pirvot){
r-=1;
}
//如果l>=r,说明pirvot的左右两边的值,已经按照左边全部小于等于pirvot,右边全是大于等于pirvot
if (l>=r){
break;
}
//交换
int temp=0;//临时变量
temp=arr[l];
arr[l]=arr[r];
arr[r]=temp;
//如果交换完后,发现这个arr[l]==pirvot值相等,前移
if (arr[l]==pirvot){
l-=1;
}
//如果交换完后,发现这个arr[r]==pirvot值相等,后移
if (arr[r]==pirvot){
r+=1;
}
}
//如果l==r,必须l++,r--否则会出现栈溢出
if (l==r){
l+=1;
r-=1;
}
//向左递归
if (left<r){
quickSort(arr,left,r);
}
//向右递归
if (right>l){
quickSort(arr,right,l);
}
}
}
5.桶排序
package sort;
import java.util.Arrays;
//基数排序(桶排序)
public class RadixSort {
public static void main(String[] args) {
int arr[]={53,3,542,748,14,214};
radixSort(arr);
}
//定义一个二维数组,表示十个桶,每个桶就是一个一维数组
//1.二维数组包含10个一维数组
//2.为了防止在放入数的时候,数据溢出,则每个一维数组(桶),大小定为arr.length
//3.基数排序是使用空间换时间的经典算法
public static void radixSort(int[] arr) {
//得到数组中的最大位数
int max=arr[0];//假设第一位数就是最大数
for (int i = 0; i < arr.length; i++) {
if (arr[i]>max){
max=arr[i];
}
}
//得到最大数是几位数
int maxLength=(max+"").length();
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中,实际存放多少数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
//bucketElementCount[0],记录的就是bucket[0]桶的放入数据个数
int[] bucketElementCounts=new int[10];
//这里使用循环处理
for (int i=0,n=1;i<maxLength;i++,n*=10){
//针对每个元素相应位进行排序处理:第一位是个位,第二位是十位,第三位是百位...
for (int j = 0; j < arr.length; j++) {
//取出每个元素的对应位的数
int digitOfElement=arr[j]/n%10;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
bucketElementCounts[digitOfElement]++;
}
//按照每个桶的顺序(一维数组的下标依次取出数据,放入原来数据)
int index=0;
//遍历每一个桶,并将桶中的数据,放入原数组
for (int k=0;k<bucketElementCounts.length;k++){
//如果桶中,有数据,我们才放入到原数组
if (bucketElementCounts[k]!=0){
//循环该桶即第k个桶,放入
for (int l=0;l<bucketElementCounts[k];l++){
//取出元素放入arr
arr[index++]=bucket[k][l];
}
}
//第一轮处理后,需要把bucketElementCounts[k]=0!!!
bucketElementCounts[k]=0;
}
System.out.println(Arrays.toString(arr));
}
6.选择排序
package sort;
//选择排序
public class SelectSort {
public static void main(String[] args) {
int[] dong = {1, 9, 7, 8,2,6,5,3};
for (int i = 0; i <dong.length-1 ; i++) {
int min = i;
for (int j = i+1 ; j < dong.length; j++) {
if (dong[min] > dong[j]) {
min = j;
}
}
if (min != i) {
int temp;
temp=dong[i];
dong[i]=dong[min];
dong[min]=temp;
}
}
for (int i = 0; i <dong.length ; i++) {
System.out.println(dong[i]);
}
}
}
7.希尔排序
package sort;
import java.util.Arrays;
//希尔排序
public class ShellSort {
public static void main(String[] args) {
int[] arr={8,9,1,7,2,3,5,4,6,0};
shellSort(arr);
shellSort2(arr);
}
public static void shellSort(int[] arr) {
int temp = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
//遍历各组的所有元素(共5组,每组2个元素),步长5
for (int j = i -gap; j >= 0; j -=gap) {
if (arr[j] > arr[j + gap]) {//如果当前的元素大于加上步长的那个元素,就交换
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
System.out.println(Arrays.toString(arr));