java实现常见的排序算法

最新推荐文章于 2023-11-03 09:48:37 发布

qq_29934825

最新推荐文章于 2023-11-03 09:48:37 发布

阅读量128

点赞数 1

本文链接：https://blog.csdn.net/qq_29934825/article/details/98449045

版权

冒泡排序

package org.xx.demo4;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = new int[]{32,2131,1231,12,431,121};
		sort(arr);
		System.out.println(Arrays.toString(arr));

	}
	public static void sort(int[] arr){
		for (int i = 0; i < arr.length-1; i++) {
			for(int j = 0;j<arr.length-1-i;j++){
				if (arr[j]>arr[j+1]) {
					int mid = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = mid;
				}
			}
		}
		
		
	}

}

插入排序

package org.xx.demo4;

import java.util.Arrays;

public class InsertSort {
	public static void main(String[] args) {
		int[] arr = new int[]{32,2131,1231,12,431,121};
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	public static void sort(int[] arr) {
		//遍歷所有數字
		for (int i = 1; i < arr.length; i++) {
			//如果当前数字比前一个数字小
			if (arr[i]<arr[i-1]) {
				//把当前数字存储起来
				int temp = arr[i];
				int j;
				//遍历当前数字前面的所有数字（注意j>=0，否则遍历不完整）
				for(j=i-1;j>=0&&arr[j]>temp;j--){
					//把前一个数字赋给后一个数字
					arr[j+1] = arr[j];
				}
				//把临时变量赋给不满足条件的后一个值
				arr[j+1] = temp;
				
			}	
		}	
	}
}

快速排序

package org.xx.demo4;

import java.util.Arrays;

public class QuickSort {
	public static void main (String[] args){
		int[] arr = new int[]{32,2131,1231,12,431,121};
		sort(arr, 0, arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
	public static void sort(int[] arr,int start,int end){
		if (start<end) {
			//把数组中的第0个元素作为标准数
			int stard = arr[start];
			//记录需要排序的下标
			int low = start;
			int high = end;
			//开始循环，找比标准数大的数，和比标准数小的数
			while(low<high){
				//右边的数字比标准数大
				
				while(low<high&&arr[high]>stard){
					high--;
				}
				//当碰到右边的数字等于或者小于标准数，使用右边的数替换掉左边的数
				arr[low] = arr[high];
				//左边的数字比标准数小
				while(low<high&&arr[low]<stard){
					low++; 
				}
				//当碰到左边的数字等于或者大于标准数时，使用左边的数替换掉右边的数
				arr[high] = arr[low];
			}
			//把标准数赋给低所在的位置
			arr[low] = stard;
			//处理所有小的数字
			sort(arr, start, low);
			//处理所有大的数字
			sort(arr, low+1, end);
		}
		
		
	}

}

希尔排序

package org.xx.demo4;

import java.util.Arrays;

public class SheelSort {

	public static void main(String[] args) {
		int[] arr = new int[]{32,2131,1231,12,431,121};
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}

	public static void sort(int[] arr) {
		//遍历所有步长
		for (int d = arr.length/2; d>0; d/=2) {
			//遍历所有元素
			for (int i = d; i < arr.length; i++) {
				//遍历本组中的所有元素
				for (int j = i-d; j>=0; j-=d) {
					if (arr[j]>arr[j+d]) {
						int temp = arr[j];
						arr[j] = arr[j+d];
						arr[j+d] = temp;
					}
				}
			}
		}
		
	}
}

选择排序

package org.xx.demo4;

import java.util.Arrays;

public class SelectSort {

	public static void main(String[] args) {
		int[] arr = new int[]{32,2131,1231,12,431,121};
		sort(arr);
		System.out.println(Arrays.toString(arr));

	}
	public static void sort(int[] arr){
		//遍历所有的数
		for(int i = 0;i<arr.length;i++){
			//给定最小值的索引
			int minIndex = i;
			//把当前的数和后面所有的数依次进行比较，并记录最小值的索引
			for(int j=i+1;j<arr.length;j++){
				if (arr[minIndex]>arr[j]) {
					minIndex = j;
				}
			}
			//如果最小的数和当前遍历数的下标不一致，说明下标为minIndex的数比当前遍历的数还小
			if (i!=minIndex) {
				int temp = arr[i];
				arr[i] = arr[minIndex];
				arr[minIndex] = temp;
			}
		}
	}

}

归并排序

package org.xx.demo4;

import java.util.Arrays;

public class MergeSort {

	public static void main(String[] args) {
		int[] arr = new int[]{32,2131,1231,12,431,121};
		mergeSort(arr, 0, arr.length-1);
		System.out.println(Arrays.toString(arr));

	}
	//归并排序
		public static void mergeSort(int[] arr,int low,int high) {
			int middle=(high+low)/2;
			if(low<high) {
				//处理左边
				mergeSort(arr, low, middle);
				//处理右边
				mergeSort(arr, middle+1, high);
				//归并
				merge(arr,low,middle,high);
			}
		}
		
    
		public static void merge(int[] arr,int low,int middle, int high) {
			//用于存储归并后的临时数组
			int[] temp = new int[high-low+1];
			//记录第一个数组中需要遍历的下标
			int i=low;
			//记录第二个数组中需要遍历的下标
			int j=middle+1;
			//用于记录在临时数组中存放的下标
			int index=0;
			//遍历两个数组取出小的数字，放入临时数组中
			while(i<=middle&&j<=high) {
				//第一个数组的数据更小
				if(arr[i]<=arr[j]) {
					//把小的数据放入临时数组中
					temp[index]=arr[i];
					//让下标向后移一位；
					i++;
				}else {
					temp[index]=arr[j];
					j++;
				}
				index++;
			}
			//处理多余的数据
			while(j<=high) {
				temp[index]=arr[j];
				j++;
				index++;
			}
			while(i<=middle) {
				temp[index]=arr[i];
				i++;
				index++;
			}
			//把临时数组中的数据重新存入原数组
			for(int k=0;k<temp.length;k++) {
				arr[k+low]=temp[k];
			}
		}
}

基数排序

package org.xx.demo4;

import java.util.Arrays;

public class RadixSort {

	public static void main(String[] args) {
		int[] arr = new int[]{32,2131,1231,12,431,121};
		radixSort(arr);
		System.out.println(Arrays.toString(arr));
	}	
	public static void radixSort(int[] arr){
		//存数组中的最大元素
		int max = Integer.MIN_VALUE;
		for(int i=0;i<arr.length;i++){
			if (arr[i]>max) {
				max=arr[i];
			}
		}
		//计算最大数字是几位数
		int maxLength = (max+"").length();
		//用于临时存储数据的数组
		int[][] temp = new int[10][arr.length];
		//用于记录在temp中相应的数组中存放的数字的数量
		int[] counts = new int[10];
		//根据最大的数的位数决定比较的次数
		for(int i=0,n=1;i<maxLength;i++,n*=10){
			//计算每一个数字的余数
			for(int j=0;j<arr.length;j++){
				//计算余数
				int ys = arr[j]/n%10;
				//把当前遍历的数放入指定的数组中
				temp[ys][counts[ys]] = arr[j];
				//记录数量
				counts[ys]++;
			}
			//记录取的元素需要放的位置
			int index = 0;
			//把数字取出来
			for(int k=0;k<counts.length;k++){
				//判断counts数量的数组中当前余数记录的数量不为0，再取
				if (counts[k]!=0) {
					//循环取出元素
					for(int l=0;l<counts[k];l++){
						//取出元素
						arr[index] = temp[k][l];
						index++;
					}
					//把数量置为0
					counts[k]=0;
				}
			}
		}	
	}
}

基数排序之队列实现

package org.xx.demo4;

import java.util.Arrays;

import org.xx.demo2.MyQueue;

public class RadixQueueSort2 {

	public static void main(String[] args) {
		int[] arr = new int[]{32,2131,1231,12,431,121};
		radixSort(arr);
		System.out.println(Arrays.toString(arr));
	}	
	public static void radixSort(int[] arr){
		//存数组中的最大元素
		int max = Integer.MIN_VALUE;
		for(int i=0;i<arr.length;i++){
			if (arr[i]>max) {
				max=arr[i];
			}
		}
		//计算最大数字是几位数
		int maxLength = (max+"").length();
		//用于临时存储队列的数组,对象MyQueue为之前的队列实现代码
		MyQueue[] temp = new MyQueue[10];
		//为队列数组赋值
		for(int i=0;i<temp.length;i++){
			temp[i] = new MyQueue();
		}
		//根据最大的数的位数决定比较的次数
		for(int i=0,n=1;i<maxLength;i++,n*=10){
			//计算每一个数字的余数
			for(int j=0;j<arr.length;j++){
				//计算余数
				int ys = arr[j]/n%10;
				//把当前遍历的数放入指定的队列中
				temp[ys].add(arr[j]);
			}
			//记录取的元素需要放的位置
			int index = 0;
			//把所有队列中的数字取出来
			for(int k=0;k<temp.length;k++){
				//循环取出元素
				while(!temp[k].isEmpty()){
					//取出元素
					arr[index] = temp[k].poll();
					//记录下一个位置
					index++;
				}
			}
		}	
	}
}

堆排序

package org.xx.demo4;
import java.util.Arrays;
public class HeapSort {

	public static void main(String[] args) {
		int[] arr = new int[]{9,6,8,7,0,1,10,4,2};
		heapSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	public static void heapSort(int[] arr){
		//开始节点是最后一个非叶子节点，即最后一个节点的父节点
		int start = (arr.length-1)/2;
		//调整为大顶堆
		for(int i=start;i>=0;i--){
			maxHeap(arr, arr.length, i);	
		}
		//先把数组中的第0个和堆中的最后一个数交换位置，再把前面的处理为大顶堆
		for(int i=arr.length-1;i>0;i--){
			int temp = arr[0];
			arr[0] = arr[i];
			arr[i] = temp;
			//参数0的意思是把根节点调整为大顶堆
			maxHeap(arr, i, 0);
		}
	}
	public static void maxHeap(int[] arr,int size,int index){
		System.out.println(index);
		//左子结点
		int leftNode = 2*index+1;
		//右子节点
		int rightNode = 2*index+2;
		//记录最大值
		int max = index;
		//和两个子节点对比，找出最大的节点
		if (leftNode<size&&arr[leftNode]>arr[max]) {
			max = leftNode;
		}
		if (rightNode<size&&arr[rightNode]>arr[max]) {
			max = rightNode;
		}
		//交换位置
		if (max!=index) {
			int temp = arr[index];
			arr[index] = arr[max];
			arr[max] = temp;
			//交换位置后，可能会破环之前排好的堆，所以，之前排好的堆需要重新调整
			maxHeap(arr, size, max);
		}
	}
}

qq_29934825

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java实现常见的排序算法

冒泡排序package org.xx.demo4;import java.util.Arrays;public class BubbleSort { public static void main(String[] args) { int[] arr = new int[]{32,2131,1231,12,431,121}; sort(arr); System.out.p...
复制链接

扫一扫