数据结构和算法学习笔记——排序

最新推荐文章于 2024-07-19 19:11:19 发布
最新推荐文章于 2024-07-19 19:11:19 发布
阅读量77 收藏
点赞数
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62082569/article/details/125703520
版权

        排序算法的内容会随着博主的学习进度更新，内容介绍了各个算法的原理，并且都有代码示例。

目录

1.Comparable接口介绍

2.冒泡排序

3.选择排序

4.插入排序

※5.希尔排序

※6.归并排序

    6.1递归

    6.2归并排序

※7.快速排序

※8.堆排序

1.Comparable接口介绍

        介绍：在一个需要可以进行比较的类实现Comparable接口，并重写Comparable接口的compareTO方法，以此来提供一个比较规则，从而实现类的比较。代码示例如下：

//Student类
public class Student implements Comparable<Student> {

    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写Comparable类中的compareTo方法
    @Override 
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("张三", 18);
        Student student2 = new Student("李四", 16);
        System.out.println(getMaxAge(student1, student2));
    }

    //实现比较方法
    public static Student getMaxAge(Student o1, Student o2) {
        int n = o1.compareTo(o2);
        if(n >= 0) return o1;
        else  return o2;
    }
}

2.冒泡排序

        原理：比较相邻元素，如果前一个元素比后一个元素大，就交换这两个元素的位置；每一次遍历都对每一对相同元素做同样的，直到最后排序完成。代码示例如下：

package SortDemo;

//冒泡排序实现
public class Bubble {

    //排序
    public static void sort(Comparable[] a) {
        for(int i = a.length - 1; i > 0; i--) {
            for(int j = 0; j < i; j++) {
                if(greater(a[i], a[j]))
                    exchange(a, i, j);
            }
        }
    }

    //比较两个值v和w的大小
    public static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    
    //交换数组a中下标为i和j的值
    public static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

}

package SortDemo;

import java.util.Arrays;

//冒泡排序测试
public class Test {
    public static void main(String[] args) {
        Integer[] a = {8,4,2,3,6,7,5,1,0};
        Bubble.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

 冒泡排序的时间复杂度是O(n^2)，所以它适用于较小量的比较场景。

3.选择排序

        原理：在每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则进行交换，并假定其他某个索引处的值为最小值，但索引未变。示例代码如下：

package SelectionDemo;

public class Selection {

    //排序
    public static void sort(Comparable[] a) {
        for(int i = 0; i < a.length; i++) {
            int minIndex = i;
            for(int j = i + 1; j < a.length; j++) {
                if(greater(a[minIndex], a[j]))
                    minIndex = j;
            }
            exchange(a, i, minIndex);
        }
    }

    //比较两个值v和w的大小
    public static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    //交换数组a中下标为i和j的值
    public static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

package SelectionDemo;

import java.util.Arrays;

//选择排序测试
public class SelectionTest {
        public static void main(String[] args) {
            Integer[] a = {8,4,2,3,6,7,5,1,0};
            Selection.sort(a);
            System.out.println(Arrays.toString(a));
        }
    }

  选择排序的时间复杂度是O(n^2)，所以它适用于较小量的比较场景。

4.插入排序

原理：

  1. 形象地把所有的元素分为两组，已排序组和未排序组；
  2. 找到未排序组中的第一个元素，向已排序组中进行插入；
  3. 倒叙遍历已排序组，依次与未排序组的第一个元素进行比较，符合条件进行交换并进行下一次比较，若不符合条件，即已排序没有比未排序组的第一个元素小的，则跳出当前循环并进行未排序组下一个元素的排序。

代码示例如下：

package InsertionDemo;

public class Insertion {

    //排序
    public static void sort(Comparable[] a) {
        for(int i = 1; i < a.length; i++) {
            for(int j = i; j > 0 ; j--) {
                if(greater(a[j - 1], a[j]))
                    exchange(a, j - 1, j);
                else
                    break;
            }
        }
    }

    //比较两个值v和w的大小
    public static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    //交换数组a中下标为i和j的值
    public static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

package InsertionDemo;

import java.util.Arrays;

//插入排序测试
public class InsertionTest {
    public static void main(String[] args) {
        Integer[] a = {8,4,2,3,6,7,5,1,0};
        Insertion.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

   插入排序的时间复杂度是O(n^2)，所以它适用于较小量的比较场景。

※5.希尔排序

原理：

  1. 选定一个增长量h，按照增长量h作为数组分组的依据，对数据进行分组；
  2. 对分好组的每一组数据完成插入排序；
  3. 减小增长量，最小减为1，重复第二步。

增长量确定依据：

int h = 1;

//h的增长规律
while(h < 数组长度/2) {
    h =2 * h + 1;
}

//h的减小规律
h = h / 2;

代码示例如下： 

package ShellDemo;

//希尔排序实现
public class Shell {

    public static void sort(Comparable[] a) {
        int h = 1;
        while(h < a.length) {
            h = 2 * h + 1;
        }
        //当增长量h=1时，排序结束
        while(h >= 1) {
            //找到待排序的元素
            for(int i = h; i < a.length; i++) {
                //将待排序元素插入已排序组中
                for(int j = i; j >= h; j -= h) {
                    if(greater(a[j], a[j - h]))
                        exchange(a, j, j - h);
                    else
                        break;
                }
            }
            h = h / 2;
        }
    }

    //比较两个值v和w的大小
    public static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    //交换数组a中下标为i和j的值
    public static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

package ShellDemo;

import java.util.Arrays;

//希尔排序测试
public class ShellTest {
    public static void main(String[] args) {
        Integer[] a = {8,4,2,3,6,7,5,1,0};
        Shell.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

        在进行大量数据排序时，希尔排序所用时间是冒泡、选择和插入排序的千分之一，所以希尔排序适合进行大量数据排序的场景。

※6.归并排序

    6.1递归

        定义：在定义方法时，在方法的内部调用方法的本身，称之为递归。

public void show() {
    System.out.println("aaa");
    show();
}
//这样写实际上有些错误，没有结束条件，会进入死循环

         实际应用代码示例如下：

//求n的阶乘
public class FactorialTest {
    public static void main(String[] args) {
        System.out.println(factorial(5));   //120
    }

    public static long factorial(int n) {
        if(n == 1)
            return 1;
        else
            return n * factorial(n - 1);
    }
}

    6.2归并排序

        原理：通过递归，将原数组从中间分为两组，直至分到不能分为止，然后对分组后的数组进行排序，再将排序后的数组归并到原数组，完成排序。代码示例如下：

package MergeDemo;

public class Merge {

    //辅助数组
    static Comparable[] assist;

    //对数组a进行排序
    public static void sort(Comparable[] a) {
        //初始化辅助数组
        assist = new Comparable[a.length];
        //定义lo记录数组最小索引，定义hi记录数组最大索引
        int lo = 0;
        int hi = a.length - 1;
        //对数组a中从索引lo到索引hi的元素排序
        sort(a, lo, hi);
    }

    //对数组a中从索引lo到索引hi的元素排序
    public static void  sort(Comparable[] a, int lo, int hi) {
        if(hi <= lo)
            return;
        //对数组进行分组
        int mid = lo + (hi - lo) / 2;
        //对分组后的数组元素进行排序
        sort(a, lo, mid);   //对索引lo到索引mid的元素排序
        sort(a, mid + 1, hi);   //对索引mid+1到索引hi的元素排序
        //将排完序的两个数组归并
        merge(a, lo, mid, hi);
    }

    private static void merge(Comparable[] a, int lo, int mid, int hi) {
        //定义三个指针
        int i = lo ;
        int p1 = lo;
        int p2 = mid + 1;
        //对两组数据的元素进行比较，并存入辅助数组
        while(lo <= mid && p2 <= hi) {
            if(greater(a[p1], a[p2]))
                assist[i++] = a[p1++];
            else
                assist[i++] = a[p2++];
        }
        //如果指针p1没有走完，那么顺序移动p1指针，把对应元素放到辅助数组的对应索引处
        while(p1 <= mid)
            assist[i++] = a[p1++];
        //如果指针p2没有走完，那么顺序移动p2指针，把对应元素放到辅助数组的对应索引处
        while(p2 <= hi)
            assist[i++] = a[p2++];
        //将辅助数组中的数据拷贝到原数组中
        for(int index = lo; index <= hi; index++)
            a[index] = assist[index];
    }

    //比较两个值v和w的大小
    public static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    //交换数组a中下标为i和j的值
    public static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

}

package MergeDemo;

import java.util.Arrays;

//归并排序测试
public class MergeTest {
    public static void main(String[] args) {
        Integer[] a = {8,4,2,3,6,7,5,1,0};
        Merge.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

归并排序的时间复杂度减小到了O(logn)，适合于对大量数据进行排列的场合。

视频教程：黑马程序员Java数据结构与java算法，全网资料最全数据结构+算法教程，154张java数据结构图_哔哩哔哩_bilibili

※7.快速排序

    原理：

  1. 设置一个分界值，通过该分界值将数组分成左右两部分；
  2. 将大于或等于分界值的放在分界值右边，小于分界值的放在左边；
  3. 分别对分界值两边的数组重复上述过程；（可以看出这是一个递归）
  4. 再通过递归分别对左右两个数组进行排序，当递归结束，整个数组就排好了。

代码示例如下：

视频教程：黑马程序员Java数据结构与java算法，全网资料最全数据结构+算法教程，154张java数据结构图_哔哩哔哩_bilibili

※8.堆排序

        待补充

MasterBao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
秋招算法笔记集合（深度学习机器学习数据结构等）.zip
09-06
总的来说，《秋招算法笔记集合》是一个全面的备考资源，不仅覆盖了基础的数据结构和算法，还包括了前沿的机器学习和深度学习理论。通过深入学习和实践这些内容，求职者将能够提升自己的技术水平，增加在秋季招聘中...
《Java数据结构和算法》学习笔记(2)——4种简单排序算法
03-14
总之，插入排序、冒泡排序和选择排序是计算机科学基础课程中的经典算法，它们的原理和实现是每个程序员应该掌握的基础知识。通过理解和实践这些算法，开发者可以更好地理解和应对更复杂的编程挑战。
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
《数据结构》学习笔记——排序
weixin_45243288的博客
11-09 956
数据结构——排序概述选择排序简单选择排序堆排序插入排序简单插入排序希尔排序交换排序冒泡排序快速排序时间复杂度下界归并排序递归算法非递归算法 概述 在计算机中，所谓排序就是将一组无序的记录序列调整为有序的记录序列。 一个排序算法是指一种能将一串记录序列按照某种特定的方式进行调整的一种方法。 选择排序 简单选择排序 简单选择排序（Simple Selection Sort）是一种直观的排序算法，其思想是在未排序的序列中选择最小的元素和序列的首位元素交换，接下来在剩下的未排序序列中再选出最小元素与序列的第二位元
408数据结构学习笔记——外部排序
JiangNan_1002的博客
04-20 6749
1.外部排序 2.外部排序的概念 3.败者树 4.置换选择排序 5.最佳归并树
数据结构与算法学习笔记——堆排序
qq_29384339的博客
09-15 276
1) 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。 2) 堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆，注意︰没有要求结点的左孩子的值和右孩子的值的大小关系。 3) 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆 4) 大顶堆举例说明
数据结构学习笔记—— 基数排序
小宇y的博客
11-13 4059
基数排序与前面的排序算法不一样，它不基于比较和移动元素来进行排序，而是基于多关键字排序的思想，将一个逻辑关键字分为多个关键字，它是基于关键字各位的大小进行排序的。基数排序有两种实现方式：`最高位优先法`和`最低位优先法`，分别是按关键字高次位排序和低次位排序。 > 例如，下面通过最低位优先法，对给定的关键字序列{110，119，007，911，114，120，122}进行排序：
数据结构——排序之冒泡排序
Renswc的博客
03-22 3893
冒泡排序（BubbleSort）是一种计算机科学领域的较简单的排序算法。它的基本思想是通过重复遍历待排序的数据集，并依次比较相邻的两个数据项，如果它们的顺序错误则进行交换。这个过程会持续重复直到所有相邻的数据项都已经交换完毕，此时说明该数据集已经排好序。冒泡排序的名称来源于排序过程中，较小的数据项会被逐渐“浮”到数组顶部，这个过程就像碳酸饮料中二氧化碳气泡最终会上浮到顶部的现象一样。因此，这种排序算法因其这一特性而得名。冒泡函数的核心思想。
算法基础学习笔记——①排序
VLOKL的博客
05-26 1461
算法基础学习笔记——①排序
数据结构与算法学习笔记——基数排序、总结
qq_29384339的博客
09-09 282
基数排序
408数据结构学习笔记——归并排序、基数排序
JiangNan_1002的博客
04-20 1677
1.归并排序 2.基数排序
408数据结构学习笔记——冒泡排序、快速排序
JiangNan_1002的博客
04-20 1654
1.冒泡排序 2.快速排序 3.王道课后题
《Java数据结构和算法》学习笔记(5)——递归 归并排序
03-14
在本篇《Java数据结构和算法》学习笔记中，我们将深入探讨递归和归并排序。递归是一种强大的编程技术，常用于解决复杂问题，而归并排序则是利用递归实现的一种高效排序算法。 首先，让我们理解什么是递归。递归是...
《Java数据结构和算法》学习笔记(3)——栈和队列
03-14
本文将基于《Java数据结构和算法》学习笔记中的“栈和队列”部分进行深入探讨。 栈（Stack）是一种线性数据结构，遵循后进先出（LIFO, Last In First Out）的原则。在栈中，元素的添加（压栈）和移除（弹栈）都是在...
考研笔记（数学+802数据结构）.zip
01-16
《考研笔记——数学与802数据结构深度解析》 在考研这条艰辛的道路上，有效的复习资料至关重要。这份“考研笔记（数学+802数据结构）.zip”压缩包，便是为准备考取重庆邮电大学（重邮）研究生的同学量身打造的一份...
【18】输出字符菱形
2301_78786609的博客
07-19 180
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 92
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 155
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
树与二叉树
2201_76027754的博客
07-15 789
树和二叉树
C++学习：数据结构与算法分析笔记
"C++数据结构与算法的学习笔记，涵盖了数据结构、算法分析以及相关编程概念，旨在帮助学习者掌握核心编程技巧并提升问题解决能力。" 在这份"C++数据结构与算法学习笔记"中，重点讲解了以下几个关键知识点： 1. **...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值