排序

第一节 排序

1.1排序概述

排序（sorting）的功能是将一个数据元素的任意序列，重新排列成一个按关键字有序的序列。

 

 

内部排序和外部排序

一类是整个排序过程在内存储器中进行，称为内部排序；

另一类是由于待排序元素数量太大，以至于内存储器无法容纳全部数据，排序需要借助外部存储设备才能完成，这类排序称为外部排序。

本章介绍的排序方法都属于内部排序

 

比较排序和非比较排序

大部分排序都是需要通过比较首先来判断大小，作为排序的依据的。

但是也有例外的，比如计数排序、基数排序，不需要进行比较。效率可以做到更高，但是会有一些限制条件，也可能需要更多的空间。

 

冒泡排序、选择排序、直接插入排序是最基本的三种排序，效率最低，但是算法简单。排序的学习一般从这三种排序算法开始。

 

 

1.2冒泡排序

冒泡排序的算法

1) 整个数列分成两部分：前面是无序数列，后面是有序数列

2) 初始状态下，整个数列都是无序的，有序数列是空

3) 如果一个数列有n个元素，则至多需要n-1趟循环才能保证数列有序

4) 每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加1）

5) 每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可（而不是数列的末尾）

6) 如果前一个大于后一个，交换

[算法1]

import java.lang.reflect.Array;
import java.util.Arrays;

public class testbubble {
    public static void main(String[] args) {
        int[] arr= {75,87,56,45,89,100,76,34,89,97};

        //排序前输出
        System.out.println("排序前");
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");

        }


        //冒泡排序

        for (int i=0;i<arr.length-1;i++){
            for (int j=0;j<arr.length-1;j++){
                //如果前一个数大于后一个数，就交换
                if(arr[j]>arr[j+1]){
                    //交换
                    int temp;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;

                }
            }
        }

        //输出排序后
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));

    }
}

缺点1：每一趟比较都要比较到数组的最后，没有必要，只要比较到无序数列的最后即可

  for(int j=0;j<Arr.length-1;j++){ }

        i      j<?

        0      <6

        1      <5

        2      <4

        3      <3

        i      j<6-i    Arr.length-1-i     

解决：j<Arr.length-1 修改为 j<Arr.length-1-i     

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;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;

                }
            }
        }

缺点2：不管是否有序，都要进行n-1趟循环；

     如何判断有序：比较了一趟，没有发生交换

     解决：定义一个符号量flag，默认有序true；发生交换，置为false，

     一趟循环结束后，根据flag的值判断是否有序；有序，退出即可；

import java.lang.reflect.Array;
import java.util.Arrays;

public class testbubble {
    public static void main(String[] args) {
        int[] arr= {75,87,56,45,89,100,76,34,89,97};

        //排序前输出
        System.out.println("排序前");
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");

        }


        //冒泡排序

        for (int i=0;i<arr.length-1;i++){
            //1. 假设有序
            boolean flag = true;
            //2.小循环：每一趟循环都从数列的前两个元素开始进行比较，
            for (int j=0;j<arr.length-1-i;j++){
                //如果前一个数大于后一个数，就交换
                if(arr[j]>arr[j+1]){
                    //交换
                    int temp;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;

                    flag=false;
                }
            }
            System.out.println("------------"+i+"------------");
            //3.判断是否有序，有序，退出
            if(flag){
                break;
            }

        }

        //输出排序后
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));

    }
}