数据结构几大排序算法Java实现

原理这里不再赘述，只进行代码的具体实现，需要看具体的原理分析，以下链接还是很不错的：
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++];
        }
    }
}

暂时就只整理这几个，希望能帮到大家~