冒泡,简单选择,直接插入排序比较(Java版)

冒泡,简单选择,直接插入这三种排序都是简单排序。

工具类

package Utils;

import java.util.Arrays;

public class SortUtils {
    public static void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void printString(int[] a){

        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

package BubbleSort;
import java.util.Arrays;
import Utils.SortUtils;

public class Demo02 {

    public static void bubbleSort(int[] a){
        int len = a.length;
        boolean flag = true;
        for(int i=0; i<len-1 && flag; i++){
            flag = false;//假设无须交换
            for(int j=0; j< len-1-i; j++)
            {
                if(a[j+1]<a[j]){
                    flag = true;//交换了
                    SortUtils.swap(a,j+1,j);
                }
            }
        }
    }

    public static void main(String[] args) {

        int[] a = {2,3,5,4,1,6,9,8,7};
        bubbleSort(a);
        SortUtils.printString(a);

    }
}

简单选择排序

package SimpleSort;
import java.util.Arrays;
import Utils.SortUtils;

public class Demo {

    public static void simpleSort(int[] arr){
        int min;
        for (int i = 0; i < arr.length; i++) {
            min = i;//假设第一个数据为最小的数据

            for (int j = i+1; j < arr.length; j++) {
                if(arr[min]>arr[j]){
                    min = j;
                }
            }
            if(i!=min){
                SortUtils.swap(arr, min, i);
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {2,3,5,4,1,6,9,8,7};
        simpleSort(a);
        SortUtils.printString(a);
    }
}

直接插入排序

package InsertSort;
import Utils.SortUtils;

public class Demo {
    public static void insertSort(int[] a){
        int temp,j;
        for (int i = 0; i < a.length-1; i++) {
            if(a[i]>a[i+1]){//后一个数据小于前一个数据
                temp = a[i+1];//放入缓存区
                for (j = i; j>=0&&a[j]>temp; j--) {
                    a[j+1] = a[j];//往后移动
                }
                //因为前面减一之后做的判断,所以这里加一
                a[j+1] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {2,3,5,4,1,6,9,8,7};
        insertSort(a);
        SortUtils.printString(a);
    }
}

比较三种排序

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-08-06 03:45:41

冒泡,简单选择,直接插入排序比较(Java版)的相关文章

Java实现数组的冒泡,选择,插入排序

[笔记]冒泡,选择,插入三者的排序算法时间复杂度均是O(N2)级,排序主要是执行比较和交换(复制)操作,相对来说:选择排序较冒泡排序减少了交换次数:而插入排序左边是一直保持有序的.[参考书籍]Java数据结构与算法 以下是源代码,针对数组的操作,存取元素为基本类型: 1 import java.util.Random; 2 3 class HighArray{ 4 private long[] array; 5 private int nElems,i_mark; 6 public HighAr

Java数据结构和算法(三)——冒泡、选择、插入排序算法

上一篇博客我们实现的数组结构是无序的,也就是纯粹按照插入顺序进行排列,那么如何进行元素排序,本篇博客我们介绍几种简单的排序算法. 1.冒泡排序 这个名词的由来很好理解,一般河水中的冒泡,水底刚冒出来的时候是比较小的,随着慢慢向水面浮起会逐渐增大,这物理规律我不作过多解释,大家只需要了解即可. 冒泡算法的运作规律如下: ①.比较相邻的元素.如果第一个比第二个大,就交换他们两个. ②.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.这步做完后,最后的元素会是最大的数(也就是第一波冒泡完成

简单的猜数字(JAVA版)

按书上的样例来操作的. 不过,书上提到的BUG,我没有在看下一章时就解决了哈.. 从网上查找的删除数组元素的方法. 其实,将数据结构更改为ARRAYLIST,可能更简单.:) GameHelper.java import java.io.*; public class GameHelper { public String GetUserInput(String prompt) { String inputLine = null; System.out.println(prompt + " &qu

day6 反射,hashlib模块,正则匹配,冒泡,选择,插入排序

一.反射(自省) 首先通过一个例子来看一下本文中可能用到的对象和相关概念. import sys # 模块,sys指向这个模块对象import inspectdef foo(): pass # 函数,foo指向这个函数对象 class Cat(object): # 类,Cat指向这个类对象 def __init__(self, name='kitty'): self.name = name def sayHi(self): # 实例方法,sayHi指向这个方法对象,使用类或实例.sayHi访问

选择式排序法之选择排序法实现 -java版

计算算法时间复杂度比冒泡快一点 选择排序法核心思想是,第一次从R[0] ~R[n-1]中选择最小值然后与R[0]交换,第二次从R[1] ~R[n-1]中选取最小值与R[1]交换---第i次呢就是从R[i-1] ~R[n-1]中选取最小值,与R[i-1]元素交换:对于一个含有n个元素的数组,最多交换n-1次就得到了一个排序码从小到大的有序序列. package com.PengRong.A; import java.util.*; /** * * @author PengRong * */ pub

冒泡、选择、插入排序算法——基础排序算法详解。

冒泡排序 大(小)的数慢慢“浮”到队列尾端. 原理(步骤): 第一步:比较相邻两数,从小到大排序时,第一个数大于第二个数时,交换两数位置, 第二步:接着对数列中第二对(第二个数和第三个数)重复第一步操作,比完所有数之后最大(小)的数已经在最右边.第一轮结束. 第三步:针对除最后一个数外的数重复一.二步(排完剩下的最后一个数就已经有序). 时间复杂度:(N-1)+(N-2)+...+1 = N*(N-1)/2 复杂度为O(N2). Java实现: public static int[] Bulle

冒泡、选择、插入排序

1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<time.h> 4 5 //数组元素的个数 6 #define SIZE 15 7 8 //初始化数组 9 void initArray(int *arr, int len); 10 11 //打印数组元素 12 void printArray(int *arr, int len); 13 14 //交换两个数 15 void swap(int *a, int *b)

第四篇、快速、冒泡、选择、插入排序

1.快速排序 实现: 1.取中间一个数作为支点 2.分别在支点的左右两边进行查找,如果左边查找到比支点大,右边查找到比支点小,就交换位置,如此循环,比支点小的数就排在了左边,比支点大的就排在右边 3.左右两边再用递归排序,就可以完成排序操作 /** *@brief 快速排序 *@params arr 数组 left 起始位置 right总点位置 */ void quickSort(int arr[],int left,int right) { int i = left; int j = righ

冒泡、选择、插入排序 不带对数器版本

1 package com.aixuexi.contact; 2 3 public class BubbleSort { 4 public static void main(String[] args) { 5 int arr[] = new int[] {985,2,6}; 6 //冒泡 O(N*N) 7 for(int end = arr.length-1; end > 0; end--) { 8 for(int i = 0; i < end; i++) { 9 if(arr[i] >

第六章 排序-冒泡,选择,插入排序

哔哩哔哩数据结构讲解地址:https://space.bilibili.com/356198029 本代码视频讲解地址:https://www.bilibili.com/video/av74560022 冒泡排序 #include<iostream> using namespace std; void bubble(int[], int); int main() { int array [] = {55,2,6,4,32,12,9,73,26,37}; int len = sizeof(arr