原理这里不再赘述,只进行代码的具体实现,需要看具体的原理分析,以下链接还是很不错的:
https://blog.csdn.net/weixin_41948075/article/details/100499887?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.edu_weight&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.edu_weight
交换排序
交换排序主要有冒泡排序和快速排序。
冒泡排序实现
public class bubblesort {
public static void main(String[] args) {
int[] arr={3,4,7,5,1,2};
arr=bubblesort(arr);
for (int i:arr) {
System.out.print(i);
}
}
//冒泡从下向上,将最小的浮起来;一般冒泡理解为这种;
public static int[] bubblesort(int[] arr){
int len=arr.length;
for(int i=1;i<len;i++){
for(int j=len-1;j>=i;j--){
if(arr[j-1]>arr[j]){
int temp=arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}
}
}
return arr;
}
//冒泡从上到下,把当前最大的沉下去;
public static int[] bubblesort01(int[] arr){
int len=arr.length;
for(int i=len-1;i>=0;i--){
for(int j=0;j<i;j++){
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
}
快速排序
public class quicksort {
public static void main(String[] args) {
int[] arr={1,5,1,1,1};
//quicksort02(arr);
quicksort(arr,0,arr.length-1);
for (int i:arr) {
System.out.print(i);
}
}
//快速排序的递归实现;
public static void quicksort(int[]arr,int low,int high){
if(low>high)return;
int i=low;
int j=high;
int rev=arr[low];
while(i<j){
while(i<j&&arr[j]>=rev){
j--;
}
while(i<j&&arr[i]<=rev){
i++;
}
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
int temp1=arr[i];
arr[i]=arr[low];
arr[low]=temp1;
quicksort(arr,low,i-1);
quicksort(arr,i+1,high);
}
快排有递归和非递归两种。这边非递归一直出问题,不知道哪里的情况;
插入排序
插入排序有直接插入排序和希尔排序
直插法
public class insertsort {
public static void main(String[] args) {
int[] arr={5,4,3,2,1};
insertsort(arr);
for (int i:arr) {
System.out.print(i);
}
}
public static void insertsort(int[] arr){
for(int i=1;i<arr.length;i++){
for(int j=i;j>0;j--){
if(arr[j]<arr[j-1]){
int temp=arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}
}
}
}
}
希尔排序
public static void shellSort(int[] arr){
//inc是增量
int j=0;
int inc=arr.length/2;
//增量默认是长度的一半,每次变为之前的一半,直到最终数组有序
while(inc>0){
for(int i=inc ; i<arr.length; i++){
int temp = arr[i];
//将当前的数与减去增量之后位置的数进行比较,如果大于当前数,将他后移
for(j=i-inc; j>=0;j-=inc){
if(arr[j]>temp){
arr[j+inc] = arr[j];
}else{
break;
}
}
//将当前数放到空出来的位置
arr[j+inc]=temp;
}
inc=inc/2;
}
System.out.println(Arrays.toString(arr));
}
选择排序
选择排序有简单选择排序法和堆排序;
选择排序
import java.util.Arrays;
public class simplesort {
public static void main(String[] args) {
int[] arr={5,6,3,4,1,2};
simplesort(arr);
System.out.println(Arrays.toString(arr));
}
public static void simplesort(int[] arr){
int len=arr.length;
for(int i=0;i<len-1;i++){
int min=i;
for(int j=i+1;j<len;j++){
if(arr[j]<arr[min]){
min=j;
}
}
//这里进行一下判断;不进行也行,但是建议判断一下
if(i!=min) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
}
堆排序
package sort0711;
public class heapsort {
//堆排序演示
public static void main(String[] args) {
int[] arr = {16, 7, 3, 20, 17, 8};
heapSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
/**
* 创建堆,
* @param arr 待排序列
*/
private static void heapSort(int[] arr) {
//创建堆
for (int i = (arr.length - 1) / 2; i >= 0; i--) {
//从第一个非叶子结点从下至上,从右至左调整结构
adjustHeap(arr, i, arr.length);
}
//调整堆结构+交换堆顶元素与末尾元素
for (int i = arr.length - 1; i > 0; i--) {
//将堆顶元素与末尾元素进行交换
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
//重新对堆进行调整
adjustHeap(arr, 0, i);
}
}
/**
* 调整堆
* @param arr 待排序列
* @param parent 父节点
* @param length 待排序列尾元素索引
*/
private static void adjustHeap(int[] arr, int parent, int length) {
//将temp作为父节点
int temp = arr[parent];
//左孩子
int lChild = 2 * parent + 1;
while (lChild < length) {
//右孩子
int rChild = lChild + 1;
// 如果有右孩子结点,并且右孩子结点的值大于左孩子结点,则选取右孩子结点
if (rChild < length && arr[lChild] < arr[rChild]) {
lChild++;
}
// 如果父结点的值已经大于孩子结点的值,则直接结束
if (temp >= arr[lChild]) {
break;
}
// 把孩子结点的值赋给父结点
arr[parent] = arr[lChild];
//选取孩子结点的左孩子结点,继续向下筛选
parent = lChild;
lChild = 2 * lChild + 1;
}
arr[parent] = temp;
}
}
堆排序参考了别人的,原理比较简单,但大顶堆的创建和调整还是比较比较难实现的。
归并排序
import java.util.Arrays;
public class mergesort {
public static void main(String []args){
int []arr = {9,8,7,6,5,4,3,2,1};
sort(arr);
System.out.println(Arrays.toString(arr));
}
public static void sort(int []arr){
int []temp = new int[arr.length];//在排序前,先建好一个长度等于原数组长度的临时数组,避免递归中频繁开辟空间
sort(arr,0,arr.length-1,temp);
}
private static void sort(int[] arr,int left,int right,int []temp){
if(left<right){
int mid = (left+right)/2;
sort(arr,left,mid,temp);//左边归并排序,使得左子序列有序
sort(arr,mid+1,right,temp);//右边归并排序,使得右子序列有序
merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
}
}
private static void merge(int[] arr,int left,int mid,int right,int[] temp){
int i = left;//左序列指针
int j = mid+1;//右序列指针
int t = 0;//临时数组指针
while (i<=mid && j<=right){
if(arr[i]<=arr[j]){
temp[t++] = arr[i++];
}else {
temp[t++] = arr[j++];
}
}
while(i<=mid){//将左边剩余元素填充进temp中
temp[t++] = arr[i++];
}
while(j<=right){//将右序列剩余元素填充进temp中
temp[t++] = arr[j++];
}
t = 0;
//将temp中的元素全部拷贝到原数组中
while(left <= right){
arr[left++] = temp[t++];
}
}
}
暂时就只整理这几个,希望能帮到大家~