六大排序算法及Java实现

最新推荐文章于 2021-11-03 17:37:09 发布
最新推荐文章于 2021-11-03 17:37:09 发布
阅读量242 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44593818/article/details/106502598
版权

冒泡排序

基本思想：

冒泡排序，类似于水中冒泡，较大的数沉下去，较小的数慢慢冒起来，假设从小到大，即为较大的数慢慢往后排，较小的数慢慢往前排。

算法平均时间复杂度为O(n^2)，且较为稳定

img

代码实现
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class BubbleSort {
  public static int[] Data = new int[20];   // 数据数组

  public static void main(String[] args) {

    int Index;   // 数组下标变量

    System.out.println("Input the values(Exit for 0):");

    Index = 0;

    InputStreamReader is = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(is);
    StringTokenizer st;

    do {
      System.out.print("Data:" + Index + ":");
      try {
        String myLine = br.readLine();
        st = new StringTokenizer(myLine);
        Data[Index] = Integer.parseInt(st.nextToken());
      } catch (IOException ioe) {
        System.out.print("IO Error:" + ioe);
      }
      Index++;
    } while (Data[Index - 1] != 0);

    Index--;

    System.out.println("Index:" + Index);
    printArray(Data, Index);

    bubblesort(Index);

    System.out.println("");
    printArray(Data, Index);
  }

  public static void printArray(int[] array, int Index) {
    for (int i = 0; i < Index; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("");
  }

  public static void bubblesort(int Index) {
    for (int i = 0; i < Index - 1; i ++) {
      for (int j = i + 1; j < Index; j ++) {
        if (Data[i] > Data[j]) {
          swap(Data, i, j);
        }
      }
    }
  }

  private static void swap(int[] array, int ind1, int ind2) {
    int temp = array[ind1];
    array[ind1] = array[ind2];
    array[ind2] = temp;
  }
}

选择排序

主要目标：

每次遍历找到剩余数组中最小的元素

中心思想：

1.第一个循环初始化最小值和最小值索引

2.在第一个循环内部再进行一次循环，对数组元素遍历比较，交换最小值及其索引

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class SelectSort {
  public static int[] Data = new int[20];   // 数据数组

  public static void main(String[] args) {

    int Index;   // 数组下标变量

    System.out.println("Input the values(Exit for 0):");

    Index = 0;

    InputStreamReader is = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(is);
    StringTokenizer st;

    do {
      System.out.print("Data:" + Index + ":");
      try {
        String myLine = br.readLine();
        st = new StringTokenizer(myLine);
        Data[Index] = Integer.parseInt(st.nextToken());
      } catch (IOException ioe) {
        System.out.print("IO Error:" + ioe);
      }
      Index++;
    } while (Data[Index - 1] != 0);

    Index--;

    System.out.println("Index:" + Index);
    printArray(Data, Index);

    selectsort(Index);

    System.out.println("");
    printArray(Data, Index);
  }

  public static void printArray(int[] array, int Index) {
    for (int i = 0; i < Index; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("");
  }

  public static void selectsort(int Index) {
    int min = 32767;
    int minIndex = 0;

    for(int i = 0; i < Index - 1; i++) {
      min = 32767;
      minIndex = i;
      for (int j =i;j < Index; j++) {
        if (min > Data[j]) {
          min = Data[j];
          minIndex = j;
        }
      }
      swap(Data, minIndex, i);
    }
  }

  private static void swap(int[] array, int ind1, int ind2) {

    int temp = array[ind1];
    array[ind1] = array[ind2];
    array[ind2] = temp;
  }

}

插入排序

插入排序是一种简单直观而且稳定的排序算法，时间复杂度O(n^2 )，若列表初始排序为正序，则时间复杂度为O(n)，反序或无序均为O(n^2 )

插入排序对几乎已经排好序的数据操作时，效率很高

1 基本思想

将数组的第一个数认为是有序数组，从后往前（从前往后）扫描该有序数组，把数组中其余n-1个数，根据数值的大小，插入到有序数组中，直至数组中的所有数有序排列为止。这样的话，n个元素需要进行n-1趟排序！！！

img

Java代码实现

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class insertsort {
  public static int[] Data = new int[10];   // 数据数组

  public static void main(String[] args) {

    int i;   // 循环变量
    int Index;   // 数组下标变量

    System.out.println("Input the values(Exit for 0):");

    Index = 0;

    Scanner input = new Scanner(System.in);

    InputStreamReader is = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(is);
    StringTokenizer st;

    do {
      System.out.print("Data:" + Index + ":");
      try {
        String myLine = br.readLine();
        st = new StringTokenizer(myLine);
        Data[Index] = Integer.parseInt(st.nextToken());
      } catch (IOException ioe) {
        System.out.print("IO Error:" + ioe);
      }
      Index++;
    } while (Data[Index - 1] != 0);

    Index--;

    System.out.println("Index:" + Index);
    printArray(Data, Index);

    InsertSort(Index);

    System.out.println("");
    printArray(Data, Index);
  }

  public static void printArray(int[] array, int Index) {
    for (int i = 0; i < Index; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("");
  }

  public static void InsertSort(int Index) {
    int i, j, l;
    int InsertNode;   // 哨兵

    for (i = 1; i < Index; i++) {
      InsertNode = Data[i];

      System.out.println("\n---开始寻找哨兵---");
      j = i - 1;
      while (j >= 0 && Data[j] > InsertNode) {
        Data[j + 1] = Data[j];
        j--;
        printArray(Data, Index);
      }
      System.out.println("---开始插入哨兵---");
      Data[j + 1] = InsertNode;
      printArray(Data, Index);
    }
  }
}

堆排序

​ 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最好、最坏、平均时间复杂度均为O(nlogn)，它也是不稳定排序。

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

img

基本思想

将排序序列构造成一个大(小)顶堆，此时整个序列的最大值就是堆顶的根节点。将末尾元素进行交换，此时末尾就为最大值。然后将剩余元素重新构造堆，反复执行。

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

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

不错的博客讲解

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class HeapSort {
  public static int[] Data = new int[20];   // 数据数组

  public static void main(String[] args) {

    int Index = 0;   // 数组下标变量

    System.out.println("Input the values(Exit for 0):");

    InputStreamReader is = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(is);
    StringTokenizer st;

    do {
      System.out.print("Data:" + Index + ":");
      try {
        String myLine = br.readLine();
        st = new StringTokenizer(myLine);
        Data[Index] = Integer.parseInt(st.nextToken());
      } catch (IOException ioe) {
        System.out.print("IO Error:" + ioe);
      }
      Index++;
    } while (Data[Index - 1] != 0);

    Index--;

    System.out.println("Index:" + Index);
    printArray(Data, Index);

    heapsort(Index);

    System.out.println("");
    printArray(Data, Index);
  }

  public static void printArray(int[] array, int Index) {
    for (int i = 0; i < Index; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("");
  }

  /**
   * 将数组排列为大顶堆
   *
   * @param arr    数组
   * @param ind    根节点
   * @param length 数组长度
   */
  public static void adjustHeap(int[] arr, int ind, int length) {

    int temp = arr[ind];

    for(int i = ind * 2 + 1; i < length; i = 2 * i + 1) {

      if (i + 1 < length && arr[i] < arr[i + 1]) {
        i++;
      }

      if (arr[i] > temp) {
        arr[ind] = arr[i];
        ind = i;
      } else {
        break;
      }
    }
    arr[ind] = temp;
  }

  public static void heapsort(int Index) {

    // 构建大顶堆
    for (int i = Index / 2 - 1; i >= 0; i--) {
      adjustHeap(Data, i, Index);
    }

    for (int j = Index - 1; j > 0; j--) {
      swap(Data, 0, j);   // 将堆顶元素与末尾元素进行交换
      adjustHeap(Data, 0, j);   //重新对堆进行调整
    }
  }

  private static void swap(int[] array, int ind1, int ind2) {

    int temp = array[ind1];
    array[ind1] = array[ind2];
    array[ind2] = temp;
  }
}

希尔排序

希尔排序也是插入排序的一种，它是经过改进之后的一个更高效的版本。

基本思想：

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

img

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class ShellSort {
  public static int[] Data = new int[20];   // 数据数组

  public static void main(String[] args) {

    int Index;   // 数组下标变量

    System.out.println("Input the values(Exit for 0):");

    Index = 0;

    InputStreamReader is = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(is);
    StringTokenizer st;

    do {
      System.out.print("Data:" + Index + ":");
      try {
        String myLine = br.readLine();
        st = new StringTokenizer(myLine);
        Data[Index] = Integer.parseInt(st.nextToken());
      } catch (IOException ioe) {
        System.out.print("IO Error:" + ioe);
      }
      Index++;
    } while (Data[Index - 1] != 0);

    Index--;

    System.out.println("Index:" + Index);
    printArray(Data, Index);

    shellsort(Index);

    System.out.println("");
    printArray(Data, Index);
  }

  public static void printArray(int[] array, int Index) {
    for (int i = 0; i < Index; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("");
  }

  public static void shellsort(int Index) {
    int temp;

    for (int gap = Index/2; gap > 1; gap /= 2) {

      // 插入排序
      System.out.println("---插入排序gap:" + gap + " ---");
      for(int i = gap; i < Index; i++) {
        System.out.println("i:" + i);
        int j = i;

        while (j - gap >= 0 && Data[j] < Data[j - gap]) {
          System.out.println("j:" + j);

          temp = Data[j];
          Data[j] = Data[j - gap];
          Data[j - gap] = temp;

          printArray(Data, Index);

          j -= gap;
        }

      }
      System.out.println("");
    }
  }
}

快速排序

主要目标：

找到每个数组元素正确的索引值

中心思想：

  1. 将数组第一个元素设为基准元素

  2. 设两个变量 哨兵i 和 哨兵j，先从j开始，使其从最后一位索引开始递减（j必须大于等于i），直至找到小于基准元素的值，暂停

  3. 哨兵i从第一位索引开始递增（i必须小于等于j），直至找到大于基准元素的值，暂停，若i!= j，则交换 i 和 j 所在位置的数组元素

  4. 若 i==j ，则交换基准元素和i所在位置的数组元素，并且此时根据 索引i 将数组分为前后两部分，将这两个数组进行递归操作。

这篇博客讲的还不错 通俗易懂

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class QuickSort {
  public static int[] Data = new int[20];   // 数据数组

  public static void main(String[] args) {

    int Index;   // 数组下标变量

    System.out.println("Input the values(Exit for 0):");

    Index = 0;

    InputStreamReader is = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(is);
    StringTokenizer st;

    do {
      System.out.print("Data:" + Index + ":");
      try {
        String myLine = br.readLine();
        st = new StringTokenizer(myLine);
        Data[Index] = Integer.parseInt(st.nextToken());
      } catch (IOException ioe) {
        System.out.print("IO Error:" + ioe);
      }
      Index++;
    } while (Data[Index - 1] != 0);

    Index--;

    System.out.println("Index:" + Index);
    printArray(Data, Index);

    quicksort(0, Index - 1);

    System.out.println("");
    printArray(Data, Index);
  }

  public static void printArray(int[] array, int Index) {
    for (int i = 0; i < Index; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println("");
  }

  public static void quicksort(int left, int right) {
    int i = left, j = right;
    int base = Data[left];

//    System.out.print("\n===该数组为");
//    for (int k = left; k <= right; k ++) {
//      System.out.print(" " + Data[k]);
//    }
//    System.out.println(" ===\n");

    while (i < j) {
      while (Data[j] >= base && j > i) {
        j--;
      }

      while (Data[i] <= base && i < j) {
        i++;
      }

      if (i == j) {
        swap(Data, left, i);
//        System.out.println("\n---改变哨兵---");
//        printArray(Data, Data.length);
        quicksort(left, i - 1);
        quicksort(i + 1, right);
        break;
      } else {
        swap(Data, i, j);
//        System.out.printf("\n---交换哨兵i: %d j: %d---\n", i, j);
//        printArray(Data, Data.length);
      }
    }
  }

  private static void swap(int[] array, int ind1, int ind2) {

    int temp = array[ind1];
    array[ind1] = array[ind2];
    array[ind2] = temp;
  }
}
小葱ban豆腐g
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
六大排序算法（java实现）
eyes++的博客
03-13 1626
零：实现Comparable接口比较大小 Java提供了Comparable接口用来定义排序规则，只要求实现一个compareTo方法 此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序 ，类的 compareTo 方法被称为它的自然比较方法 。实现此接口的对象列表（和数组）可以通过 Collections.sort （和 Arrays.sort ）进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素，无需指定比较器。 强烈推荐（虽然不是必需的）使自然排序与 eq
JAVA 中的六大排序算法，含案例和详细注释
qq_62283694的博客
02-27 724
JAVA 中的六大排序算法，含案例和详细注释
java 算法 6种排序
qq_46859110的博客
10-12 728
冒泡排序 package 冒泡排序; import java.util.Arrays; public class Bubble { /** * 对数组a中的元素进行排序 * @param a */ public static int[] sort(int[] a){ for (int i=a.length-1;i>0;i--){ for (int j=0;j<i;j++){
六大排序算法（Java实现）
weixin_30375427的博客
11-12 65
package sort; import java.util.Arrays; public class SortUtils { public static void main(String[] args) { int[] arr = { 54, 26, 93, 17, 77, 31, 44, 55, 20 }; // bubb...
人工智能 java 算法_六大排序算法（Java实现）
weixin_28720767的博客
02-12 414
packagesort;importjava.util.Arrays;public classSortUtils {public static voidmain(String[] args) {int[] arr = { 54, 26, 93, 17, 77, 31, 44, 55, 20};//bubbleSort(arr);//travel(arr);//selectSort(arr);//t...
Java语言实现六种排序算法
07-15
本文将详述Java语言实现的六种经典排序算法：冒泡排序、选择排序、插入排序、归并排序、希尔排序以及快速排序。这些排序算法各有特点，适用于不同的场景。 1. 冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序...
基于Java实现各种基本排序及简单优化
06-28
本文将详细解析标题“基于Java实现各种基本排序及简单优化”所涉及的知识点，并深入探讨每种排序算法的工作原理、实现方式以及可能的优化策略。 首先，我们来逐一分析这六种基本的排序算法： 1. **冒泡排序**：这...
常用排序算法的java实现（冒泡、插入、选择、希尔、归并、快排）
09-25
本篇文章将详细讲解标题中提到的六种常见排序算法的Java实现。 1. **冒泡排序**：冒泡排序是最基础的排序算法之一，它通过不断交换相邻的逆序元素来逐渐将较大的元素“浮”到数组的前端。在Java中，冒泡排序的基本...
Java常用排序算法
06-21
本文将深入探讨Java中常用的六种排序算法：冒泡排序、快速排序、选择排序、直接插入排序、希尔排序以及归并排序。这些算法在不同的场景下各有优势，理解它们的工作原理对于提升编程效率和优化代码性能至关重要。 1....
常用Java排序算法详解
08-31
在编程领域，排序算法是计算机科学中不可或缺的一...在Java中，这些排序算法的实现都依赖于数组，可以灵活地应用于各种数据结构和场景。通过理解和掌握这些排序算法，开发者能够更好地优化代码性能，提高程序运行效率。
java中常见的六大排序算法
qq_39011113的博客
11-03 341
一.Comparable接口介绍 Java提供了一个接口Comparable用来定义排序规则 二.冒泡排序（Bubble Sort） 排序原理： 1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。 2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。 简单来说，就是相邻的元素相互比较，直到排序结束。 冒泡排序的方法： 构造方法：Bubble()：创建Bubble对象...
JAVA的六大经典算法，代码案例简化分析
ykblog.github.io
08-19 9551
java八大经典算法：冒泡、选择、快速、插入、希尔、堆、归并、基数 1.算法实现类 package com.algorithm; /** * * @Title: BubbleSort.java * @Copyright: Copyright (c) 2005 * @Description: * * JAVA六大经典算法 *
java面试必问——六大排序算法
QuinnNorris的博客
05-01 4188
六大排序方法java中有很多中排序方法，其中冒泡排序过于简单，基数排序主要用于研究我们这里不讨论。实际应用和面试中，最常问到的就是下面的六种排序方法，我们将从原理，复杂度，稳定性和实际应用几个方面来讨论他们。
五大常用算法详解
热门推荐
高广超的博客
02-24 1万+
分治法 基本思想 将一个问题，分解为多个子问题，递归的去解决子问题，最终合并为问题的解 适用情况 问题分解为小问题后容易解决问题可以分解为小问题，即最优子结构分解后的小问题解可以合并为原问题的解小问题之间互相独立 实例 二分查找快速排序合并排序大整数乘法循环赛日程表 动态划分算法 基本思想 将问题分解为多个子问题（阶段），按顺序求解，前一个问题的解为后
干翻Java_Java第二次作业第四题
weixin_35720035的博客
02-28 77
文本行输入学生姓名，下来框选择课程名称，文本行输入课程成绩；点击“录入”按钮，相关信息显示在文本区；点击“统计”按钮，将所有录入的成绩的平均成绩显示在另一个文本行中。package naizi;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class UserJFrame extends JFrame i...
六大java语言经典算法-动力节点
weixin_49543720的博客
10-20 277
在程序员们进行编程的时候，对各种数据的处理是少不了的，java语言算法在这个时候就十分重要了。数据算法有很多种，也并不区分哪种计算机语言使用，但是有程序员们常用的java语言经典算法，下面就简单介绍一下六大经典java语言算法。 一、冒泡排序(Bubble Sort) 1、基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。 2、算法描述： (1)比较相邻的元素。如果第一个比第二个大，就交换它们两个; (2)对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数;
算法题——Maximum Gap（JAVA）基数排序
ivyusing的博客
05-13 326
求出数组排序后相连两个数之间最大的差值。
十种常见的排序算法总结(java版)
不能说的秘密的博客
03-06 7213
排序是程序开发中非常常见的操作，对一组任意的数据元素经过排序操作后，就可以把他们变成一组一定规则排序的有序序列。排序算法属于算法中的一种，而且是覆盖范围极小的一种，但彻底掌握排序算法对程序开发是有很大的帮助的。 对于一种算法，一般从如下3个方面来衡量算法的优劣。 时间复杂度 空间复杂度 稳定行 对于一般的排序，可以使用非常简单的排序来完成，如直接选择，直接...
八大排序算法总结与Java实现
11-03 3182
原文：https://itimetraveler.github.io/2017/07/18/%E5%85%AB%E5%A4%A7%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E4%B8%8Ejava%E5%AE%9E%E7%8E%B0/ 概述 因为健忘，加上对各种排序算法理解不深刻，过段时间面对排序就蒙了。
用java代码实现给中文数字排序
最新发布
09-07
要用Java代码实现给中文数字排序，首先我们需要将中文数字转换成对应的阿拉伯数字，然后使用排序算法对阿拉伯数字进行排序，最后将排序后的阿拉伯数字再转回中文数字。 在Java中，可以使用HashMap来建立中文数字和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值