数据结构与算法—（java实现）

最新推荐文章于 2023-07-17 18:01:33 发布
最新推荐文章于 2023-07-17 18:01:33 发布
阅读量179 收藏
点赞数
分类专栏： java 算法 文章标签： 数据结构算法 快速排序 冒泡排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EQuaker/article/details/110921082
版权
java 同时被 2 个专栏收录
27 篇文章 0 订阅
订阅专栏
算法
2 篇文章 0 订阅
订阅专栏

写在前面：

一，冒泡排序 

  • 基本思想
    对当前还未排好序的范围内的全部数，自左向右对相邻的俩个数依次进行比较和调整，让较大的数下沉，较小的数往上冒。即：每当俩相邻的数比较后发现他们的排序与排序的要求相反时，就将他们交换。每次遍历都可确定一个最大值放到待排数组的末尾，下次遍历，对该最大值以及它之后的元素不再排序。

  • java代码实现

public static void main(String[] args){

        int arr[] = {11,2,3,5,6,8,9,0,1,4,7};
        //打印排序前的数组
        System.out.println("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        popSort(arr);
        //打印排序后的数组
        System.out.println("\n" + "排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }

    public static void popSort(int[] arr){

        int count = 0;
        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 temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            count++;
            System.out.print("\n第"+count+"次排序：");
            for (int  k= 0; k < arr.length; k++) {
                System.out.print(arr[k] + " ");
            }
        }

    }

运行结果如下：

 

二，选择排序

  • 基本思想
    选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

  • java代码实现

public static void main(String[] args){

        int arr[] = {11,2,3,5,6,8,9,0,1,4,7};
        //打印排序前的数组
        System.out.println("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }   
        selectSort(arr);
        //打印排序后的数组
        System.out.println("\n" + "排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }

    public static void selectSort(int[] arr){

        int count = 0;
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){

                if(arr[i]> arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
            count++;
            System.out.print("\n第"+count+"次排序：");
            for (int  k= 0; k < arr.length; k++) {
                System.out.print(arr[k] + " ");
            }
        }
    }

排序结果如下：

 

三，插入排序

  • 基本思想
    插入排序（Insert Sort）是从整个待排序列中选出一个元素插入到已经有序的子序列中去，得到一个有序的、元素加一的子序列，直到整个序列的待插入元素为0，则整个序列全部有序。

  • java代码实现

public static void main(String[] args){

        int arr[] = {11,2,3,5,6,8,9,0,1,4,7};
        //打印排序前的数组
        System.out.println("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }   
        selectSort(arr);
        //打印排序后的数组
        System.out.println("\n" + "排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }



public static void insertSort(int[] arr){

        int count = 0;
        for(int i=0;i<arr.length;i++){

            for(int j=0;j<i;j++){

                if(arr[j]> arr[i]){
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
            count++;
            System.out.print("\n第"+count+"次排序：");
            for (int  k= 0; k < arr.length; k++) {
                System.out.print(arr[k] + " ");
            }
        }
    }

 运行结果如下：

四，快速排序

  • 基本思想
    是冒泡排序法的升级，属于交换排序。通过一趟排序将待排序记录分割成独立的两部分（枢纽值的左边部分和右边部分），其中一部分的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，已达到整个序列有序的目的。

  • 图解如下

 

  • java代码实现

public static void main(String[] args){

        int arr[] = {11,2,3,5,6,8,9,0,1,4,7};
        //打印排序前的数组
        System.out.println("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        quickSort(arr, 0 ,arr.length-1);
        //打印排序后的数组
        System.out.println("\n" + "排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

 }
public static void quickSort(int[] arr, int low, int high){

        if(low > high){
            return;
        }

        int i = low;
        int j = high;
        //int key = arr[i];

        while (i<j){

            while (i<j && arr[j]>arr[i]){
                j--;
            }
            if(i<j){
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
                i++;
            }

            while (i<j && arr[i]<arr[j]){
                i++;
            }
            if(i<j){
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
                j--;
            }
        }

        quickSort(arr, low, i-1);
        quickSort(arr,i+1,high);
}

五，堆排序

基本思想：堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：

同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]  

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]  

ok，了解了这些定义。接下来，我们来看看堆排序的基本思想及基本步骤：

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了

 

步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

　　a.假设给定无序序列结构如下

2.此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

4.找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无需序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

a.将堆顶元素9和末尾元素4进行交换

b.重新调整结构，使其继续满足堆定义

c.再将堆顶元素8与末尾元素5进行交换，得到第二大元素8.

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

再简单总结下堆排序的基本思路：

　　a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

　　b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

　　c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

java代码实现

 

public static void main(String[] args){

        int arr[] = {11,2,3,5,6,8,9,0,1,4,7};
        //打印排序前的数组
        System.out.println("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        heapSort(arr);
        //打印排序后的数组
        System.out.println("\n" + "排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }

public static void heapSort(int[] arr){

        //先堆排序
        for(int i=arr.length/2-1;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);

        }

    }

    public static void adjustHeap(int[] arr, int parent, int length){

        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;

    }

所有代码：

package com.soyuan.cloud.face.web;



public class eq {

    public static void main(String[] args){

        int arr[] = {11,2,3,5,6,8,9,0,1,4,7};
        //打印排序前的数组
        System.out.println("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        //popSort(arr);
        //selectSort(arr);
        //insertSort(arr);
        //quickSort(arr, 0 ,arr.length-1);
        heapSort(arr);
        //打印排序后的数组
        System.out.println("\n" + "排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }
    public static void popSort(int[] arr){

        for(int i=0;i<arr.length-1;i++){

            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j+1]<arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }

        }

    }

    public static void selectSort(int[] arr){

        for(int i=0;i<arr.length;i++){

            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }

        }

    }

    public static void insertSort(int[] arr){

        for(int i=0;i<arr.length;i++){

            for(int j=0;j<i;j++){
                if(arr[i]<arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }

        }

    }


    public static void quickSort(int[] arr, int low, int high){

        if(low > high){
            return;
        }

        int i = low;
        int j = high;
        int key = arr[low];

        while(i<j){
            while(i<j && arr[j]>key){
                j--;
            }
            if(i<j){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j]  = temp;
                i++;
            }

            while(i<j && arr[i]<key){
                i++;
            }
            if(i<j){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j]  = temp;
                j--;
            }

        }
        quickSort(arr, low, i-1);
        quickSort(arr,i+1, high);

    }

    public static void heapSort(int[] arr){

        for(int i=arr.length/2-1;i>0;i--){
            adjustHeap(arr, i, arr.length);
        }

        for(int i = arr.length-1; i>0; i--){
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            adjustHeap(arr, 0, i);
        }


    }

    public static void adjustHeap(int[] arr, int parent, int length){

        int lchild = 2*parent+1;
        int temp = arr[parent];

        while(lchild < length){

            int rchild = lchild+1;
            if(rchild<length&&arr[rchild] > arr[lchild]){
                lchild++;
            }

            if(arr[lchild]<temp){
                break;
            }

            arr[parent] = arr[lchild];
            parent = lchild;
            lchild = 2*lchild+1;

        }

        arr[parent] = temp;


    }



}

 

EQuaker
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——数据结构与算法
m0_75280308的博客
02-21 501
参考链接： hashMap、hashTable、ConcurrentHashMap区别：https://www.cnblogs.com/heyonggang/p/9112731.html。e.hashMap、ConcurrentHashMap:底层是（数组、链表、红黑树）、hashTable（数组、链表）数组Array、栈stack、队列queue、链接LinkedList、树Tree、哈希表、堆heap、图graph。线程安全：vector、hashTable、ConcurrentHashMap。
基于java的数据结构与算法的实现（持续更新）
07-12
基于java语言编写了常见的数据结构计算法，包括栈与队列、哈希表、常见排序算法等
Java-基础（数据结构与算法篇）
weixin_59413946的博客
07-17 2800
数据结构（data structure）：数据在计算机中的存储与组织形式；其主要目的是为了对数据进行高效地访问和修改；数据结构包含数组、链表这样的线性数据结构，也包含树、图这样的复杂数据结构。算法（algorithm）：在特定的计算模型下，旨在解决特定问题的一系列指令。程序 = 数据结构 + 算法。
Java中常用数据结构及方法
Liususiu的秃头日记
12-18 2492
记录总结Java中常用的结构和方法。
算法和数据结构（Java语言）
Johnor的博客
01-27 1220
持续更新中…
Java常见的数据结构与算法
一步一个脚印_binding
12-16 739
数据结构小结
数据结构与算法代码详解JAVA版
08-26
详解了一些经典算法和数据结构，希望对大家有帮助，鄙人能力有限，代码出错的地方请大家多多指正
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
#数据结构与算法java实现 #包括排序，线性表，树，图，散列等基础数据结构.zip
最新发布
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
数据结构与算法Java语言描述
06-22
全网最全Java数据结构与算法详解，PDF全文档详细描述，带详细目录书签，每个算法都有详细图片描述和代码解释，适合深入学习算法与结构
java数据结构+源代码
09-13
查找 串 内排序 树和二叉树 数组和广义表 题 图 线性表 栈和队列，等数据结构，以及代码信息，导入工程可以直接运行，没积分娶我博客下留言给你发http://blog.csdn.net/qq_23994787
Java算法与数据结构
轻风起自远东
03-18 1281
为了提前准备今年的秋招，差不多开始复习算法与数据结构了，以前学算法的时候是以C语言为基础的，现在很久没碰C语言了，决定这次复习用Java实现，基本上是参考的Java算法神书：《数据结构与算法分析——Java语言描述》。 排序 时间复杂度O(n2)的排序 选择排序 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然...
堆排序原理及其js实现
weixin_30648587的博客
07-02 102
图文来源：https://www.cnblogs.com/chengxiao/p/6129630.html 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn...
Java 常见数据结构与算法
王林的博客
09-21 534
常见排序算法和查找算法等
Java数据结构与算法实现
qq_34623223的博客
04-04 391
文章目录1.数据结构1.1 线性表1.1.1线性表的顺序存储与实现1.1.1线性表的链式存储与实现1.2 栈1.2.1 栈的顺序存储实现1.2.2 栈的链式存储实现1.3 队列1.3.1 队列的顺序存储实现1.3.2 队列的链式存储实现1.4 树1.5 图1.5.1 邻接矩阵存储结构1.5.2 邻接表存储结构2.算法2.1 查找2.1.1 顺序查找与二分法查找2.1.2 哈希表2.1.3 二叉查找...
图结构~~
Smiling_lzy的博客
11-14 285
图结构一、基本介绍1、定义2、表示方法2.1、邻接矩阵2.2、邻接表二、图的创建三、图的遍历1、深度优先遍历2、广度优先遍历（BFS） 一、基本介绍 1、定义 当我们需要表示多对多的关系时，我们就需要图 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点 2、表示方法 2.1、邻接矩阵 邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和 col表示的是1…n个点 如上图的邻接矩阵就是 0 1 0 0 1 1 0 1
Java数据结构和算法（一）——简介
IT可乐
11-27 1390
　　本系列博客我们将学习数据结构和算法，为什么要学习数据结构和算法，这里我举个简单的例子。 　　编程好比是一辆汽车，而数据结构和算法是汽车内部的变速箱。一个开车的人不懂变速箱的原理也是能开车的，同理一个不懂数据结构和算法的人也能编程。但是如果一个开车的人懂变速箱的原理，比如降低速度来获得更大的牵引力，或者通过降低牵引力来获得更快的行驶速度。那么爬坡时使用1档，便可以获得更大的牵引力；下...
数据结构与基本算法(Java语言实现)
CXY_Stole的博客
07-07 992
未完待续，有空实时补充
数据结构与算法Java
08-16
- *1* *2* *3* [数据结构与算法详解（含算法分析、动图图解、Java代码实现、注释解析）](https://blog.csdn.net/yuan2019035055/article/details/120262225)[target="_blank" data-report-click={"spm":"1018.2226....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值