选择排序 冒泡排序 简单插入排序

排序:

public class SortDemo {
    public static void main(String[] args) {
        int[] arr = { 5, 8, 9, 12, 55, 565, 421, 12, 2512, -5, -56 };
        // int[] arr = { 6, 9, 4589, 442, 458, 5232, -788, 7, 545, -44, 55, -11
        // };
        // selectionSort(arr);
        // bubbleSort(arr);
        directInsertSort(arr);
        printSort(arr);
    }

    // 选择排序 每趟都确定arr[i]的数 每次都是arr[i]的数和后面的所有arr[j]的数比较 满足就交换
    // 第一趟 int[] arr = { -56, 8, 9, 12, 55, 565, 421, 12, 2512, -5, 5 };
    private static void selectionSort(int[] arr) {
        // 第一个开始比到最后第二个就可以了
        for (int i = 0; i < arr.length - 1; 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;
                }
            }
        }
    }

    // 冒泡排序 每趟两两交替比较 一趟下来最大/最小的已经在最端了
    // 第一趟 int[] arr = {5,8,9,12,55,421,12,565,-5,-56,2512}
    private static void bubbleSort(int[] arr) {
        // 我的思维逻辑习惯这个
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }

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

        // 数据结构正统
        // for (int i = 0; i < arr.length - 1; i++) {
        // for (int j = arr.length - 1; j > i; j--) {
        // if (arr[j] < arr[j - 1]) {
        // int temp = arr[j - 1];
        // arr[j - 1] = arr[j];
        // arr[j] = temp;
        // }
        // }
        // }
    }

    // 直接插入排序 相当于打牌
    // 变化的那次 int[] arr = { 5, 8, 9, 12, 55, 565, 565, 12, 2512, -5, -56 };  temp=421 i=6
    // 变化的那次 int[] arr = { 5, 8, 9, 12, 55, 421, 565, 12, 2512, -5, -56 };
    private static void directInsertSort(int[] arr) {
        // 第二个元素开始遍历
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j > 0; j--) {
                if (arr[j - 1] > temp) {
                    // 数组下标后移
                    arr[j] = arr[j - 1];
                } else {
                    break;
                }
            }
            // break代表不需要比较了 直接赋值
            arr[j] = temp;
        }
    }

    private static void printSort(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

}

时间: 2024-11-10 14:11:53

选择排序 冒泡排序 简单插入排序的相关文章

排序(二)__冒泡排序、简单选择排序和直接插入排序

前面<排序(一)__综述>提到按照算法的复杂度分为简单算法和改进算法两大类,本文主要就简单算法中的冒泡排序.简单选择排序和直接插入排序进行通俗详细的解析. 一.冒泡排序 1.基本概念 冒泡排序是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止.(动态图来自维基百科) 2.关键代码(优化之后) void BubbleSort(SqList *L) { int i,j; Status flag=TRUE;            //flag用作标记,避

排序算法学习之简单排序(冒泡排序,简单选择排序,直接插入排序)

一.冒泡排序 冒泡排序算是最基础的一种算法了,复杂度为O(N^2),其基本思想是:从最低端数据开始,两两相邻比较,如果反序则交换.代码如下: /*最基本的冒泡排序*/ void BubbleSort1 (int n, int *array) /*little > big*/ { int i, j; for (i=0; i<n-1; i++) { for (j=n-1; j>i; j--) { if (array[j] < array[j-1]) { int temp = array

冒泡排序、简单选择排序、直接插入排序

冒泡排序(Bubble Sort)的基本思想:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止.时间复杂度为O(n2). 简单选择排序(Simple Selection Sort)的基本思想:通过n-i次关键字之间的比较,从n-i+1个记录中选出关键字最小的记录,并和第i个记录交换.应该说,尽管与冒泡排序同为O(n2), 但简单选择排序的性能上还是要略优于冒泡排序. 直接插入排序(Straight Insertion Sort)的基本思想:将一个记录插入到前面已经排序好的有序表中

C语言-简单选择排序与直接插入排序的实现

/* Name: selectSort and insertSort Copyright: nyist Author: 润青 Date: 01/10/18 19:30 Description: 实现了简单选择排序与直接插入排序 */ #include<stdio.h> int a[100]; int n; void selectSort(); void insertSort(); int main(){ scanf("%d",&n); for(int i=0;i&l

排序(2)---------简单插入排序(C语言实现)

插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间. 通俗解释: ①假设初始序列的第一个元素是有序的(当一个序列只有1个元素时,我们可以认为其是有序的). ②从第二个元素开始与前面的元素进行比较,如果比前面的大

01. Java的经典排序--选择排序--冒泡排序--折半查找(二分查找)

Java的经典排序--选择排序--冒泡排序--折半查找 选择排序 选择排序 3 2 1 5 8 0 1 3 2 5 8 1 1 2 3 5 8 2 1 2 3 5 8 3 1 2 3 5 8 public static void main(String[] args) { int[] arr={3,2,1,5,8}; selectSort(arr); for(int i = 0 ; i < arr.length ; i ++){ System.out.println(arr[i]) ; } }

php排序介绍_冒泡排序_选择排序法_插入排序法_快速排序法

这里我们介绍一些常用的排序方法,排序是一个程序员的基本功,所谓排序就是对一组数据,按照某个顺序排列的过程. 充效率看 冒泡排序法<选择排序法<插入排序法 排序分两大类: 内部排序法 交换式排序法 冒泡法 基本思想: 冒泡排序法 案例: 1234567891011121314151617181920212223242526 //简单的$arr=array(0,5,-1); //现在我们把函数毛片封装成函数,利用以后使用//数组默认传递的是值,不是地址,&是地址符function bubb

简单选择排序和直接插入排序

简单选择排序 简单选择排序就是通过关键字之间的比较,在记录里面找到最小(或者最大)的数字,并同当前位置交换之. 贴个代码: void SelectSort(SqList *L) { int i, j, min; for (i = 0; i < L->length - 1; i++) { min = i; for (j = i + 1; j < L->length; j++) { if (L->r[min] > L->r[j]) { min = j; } } if

常见排序集合(冒泡排序,选择排序,直接插入排序,二分插入排序,快速排序,希尔排序,归并排序)

一下是一些常见的排序算法: 交换元素(后面算法都有用到): // 交换元素 private static void swap(int[] a, int i, int j) { int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } 冒泡排序(有优化): // 冒泡排序(优化①,②,③,④) private static void bubbleSort(int[] a) { boolean flag = false;// ①表示整个序列是无序的 for