常见排序算法

biienu

已于 2022-03-30 23:21:39 修改

阅读量63

点赞数

分类专栏： leetcode做题笔记文章标签： java leetcode 算法排序算法

于 2022-03-30 23:09:54 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/qq_51134950/article/details/123859680

版权

leetcode做题笔记专栏收录该内容

35 篇文章 1 订阅

订阅专栏

目录

1.冒泡排序
2. 选择排序
3.插入排序
4. 希尔排序
5. 归并排序
6. 快速排序
7. 堆排序

1.冒泡排序

package com.biienu.sorttest;

/**
 * @Author: biienu
 * @Date: 2022/3/30 9:43
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] temp = {2,1,0,-1, 10,-10};
        sort(temp);
        for(int i : temp){
            System.out.print(i + "   ");
        }
    }
    static void sort(int[] nums){
        int len = nums.length;
        for (int i = 0; i < len - 1; i++) {
            for(int j = 0; j < len - i - 1; j++){
                if(nums[j] > nums[j + 1]){
                    swap(nums, j, j + 1);
                }
            }
        }
    }
    static void swap(int[] nums, int a, int b){
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

2. 选择排序

package com.biienu.sorttest;

/**
 * @Author: biienu
 * @Date: 2022/3/30 9:52
 * 选择排序
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] temp = {2,1,0,-1, 10, -1};
        sort(temp);
        for(int i : temp){
            System.out.print(i + "   ");
        }
    }
    static void sort(int[] nums){
        int len = nums.length;
        for (int i = 0; i < len - 1; i++) {
            int min = i;
            for (int j = i; j < len ; j++) {
                if(nums[j] < nums[min]){
                    min = j;
                }
            }
            if(min != i){
                swap(nums, i, min);
            }
        }
    }
    static void swap(int[] nums, int a, int b){
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

3.插入排序

package com.biienu.sorttest;

/**
 * @Author: biienu
 * @Date: 2022/3/30 10:10
 * 插入排序
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] temp = {2,1,0,-1, 10};
        sort(temp);
        for(int i : temp){
            System.out.print(i + "   ");
        }
    }
    static void sort(int nums[]){
        int len = nums.length;
        for (int i = 1; i < len; i++) {
            int j;
            int temp = nums[i];
            for (j = i; j > 0; j--) {
                if(nums[j - 1] > temp){
                    nums[j] = nums[j - 1];
                    continue;
                } else break;
            }
            nums[j] = temp;
        }
    }
}

4. 希尔排序

package com.biienu.sorttest;

/**
 * @Author: biienu
 * @Date: 2022/3/30 9:52
 * 选择排序
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] temp = {2,1,0,-1, 10, -1};
        sort(temp);
        for(int i : temp){
            System.out.print(i + "   ");
        }
    }
    static void sort(int[] nums){
        int len = nums.length;
        for (int i = 0; i < len - 1; i++) {
            int min = i;
            for (int j = i; j < len ; j++) {
                if(nums[j] < nums[min]){
                    min = j;
                }
            }
            if(min != i){
                swap(nums, i, min);
            }
        }
    }
    static void swap(int[] nums, int a, int b){
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

5. 归并排序

package com.biienu.sorttest;

/**
 * @Author: biienu
 * @Date: 2022/3/30 11:20
 * 归并排序
 */
public class MergeSort {
    public static void main(String[] args) {
        int[] temp = {2,1,0,-1, 10};
        mergeSort(temp, 0, temp.length-1 );
        for(int i : temp){
            System.out.print(i + "   ");
        }
    }
    static void mergeSort(int[] arr, int left, int right){
        if(left < right){
            int mid = left + (right - left) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }
    static void merge(int[] arr, int left, int mid, int right){

        //定义一个新的数组
        int[] tempArray = new int[right - left + 1];
        int l1 = left, l2 = mid + 1;
        int index = 0;
        while(l1 <= mid && l2 <= right){
            if(arr[l1] < arr[l2]){
                tempArray[index ++] = arr[l1++];
            } else{
                tempArray[index ++] = arr[l2++];
            }
        }
        //
        if(l1 <= mid){
            System.arraycopy(arr, l1, tempArray, index, mid - l1 + 1);
        }
        if(l2 <= mid) {
            System.arraycopy(arr, l2, tempArray, index, right - l2 + 1);
        }
        System.arraycopy(tempArray, 0,arr, left, right - left + 1);
    }
}

6. 快速排序

package com.biienu.sorttest;

/**
 * @Author: biienu
 * @Date: 2022/3/30 11:52
 * 快速排序
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] temp = {2,1,0,-1,-1,-1, 10};
        quickSort(temp, 0, temp.length-1 );
        for(int i : temp){
            System.out.print(i + "   ");
        }
    }
    static void quickSort(int[] nums, int left, int right){
        if(left < right){
            int index = partion1(nums, left,right);
            quickSort(nums, left, index - 1);
            quickSort(nums, index + 1, right);
        }
    }

    private static int partion(int[] nums, int left, int right) {

        int pivot = nums[left];
        while(left < right){

            //移动右right
            while(left < right && nums[right] >= pivot){
                right--;
            }
            if(left < right) nums[left] = nums[right];
            while (left < right && nums[left] <= pivot){
                left++;
            }
            if(left < right) nums[right] = nums[left];
        }
        nums[left] = pivot;
        return left;
    }
    private static int partion1(int[] nums, int left, int right){
        int pivot = nums[left];
        int start = left;
        while (left < right){
            while(left < right && nums[right] >= pivot){
                right--;
            }
            while (left < right && nums[left] <= pivot){
                left++;
            }
            if(left >= right) break;
           swap(nums, left, right);
        }
        swap(nums, start, left);
        return left;
    }
    static void swap(int[] nums, int a, int b){
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

7. 堆排序

package com.biienu.sorttest;

/**
 * @Author: biienu
 * @Date: 2022/3/30 15:13
 * 堆排序
 */
public class HeapSort {
    public static void main(String[] args) {

        int[] nums = {1,2,3,4,-1,-2,-3};
        sort(nums);
        for(int i : nums){
            System.out.print(i + "   ");
        }
    }

   static void sort(int[] nums){
        int len = nums.length;
        //开始下沉建堆
       for(int i = len / 2 ; i >= 0; --i){
           sink(nums, i, len);
       }
       /**
        * 排序：最上面的和最后一个元素交换，然后最上面的元素再进行下沉
        */
       int k = len;
       while(k > 0){
           swap(nums, 0, k - 1);
           sink(nums, 0, --k);
       }

   }

   //下沉操作
    /**
     * 当前节点的左子节点 index * 2 + 1, 右子节点 index * 2 + 2
     * 当前节点的父节点 (index - 1) / 2
     */
    static void sink(int[] nums, int index, int len){

        while(index * 2 + 1 < len){
            //子节点
            int j = index * 2 + 1;
            if(j + 1 < len && nums[j] < nums[j + 1]){
                j++;
            }
            if(nums[index] < nums[j]){
                swap(nums, index, j);
            } else break;
            index = j;
        }
    }
    static void swap(int[] nums, int a, int b){
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }

}

github地址

https://github.com/biienu

关注

0
点赞
踩
0

收藏

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

目录1.冒泡排序2. 选择排序3.插入排序4. 希尔排序5. 归并排序6. 快速排序7. 堆排序1.冒泡排序package com.biienu.sorttest;/** * @Author: biienu * @Date: 2022/3/30 9:43 * 冒泡排序 */public class BubbleSort { public static void main(String[] args) { int[] temp = {2,1,0,-1, 10,-10}
复制链接

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。