Java交换排序：冒泡排序和快速排序

Java交换排序：冒泡排序和快速排序

冒泡排序：

冒泡排序（Bubble Sort）是一种典型的交换排序。比较相邻的数值大小，若相邻中两个数值，前一个数值大于后一个数值，则交换他们两个的位置；否则，不交换。以此类推，直到最后一个数字。 （数值小的往前放，数值大的往后放） 就像石头沉入水底一样，小石头质量小，冒泡小；大石头质量大，冒泡大。

举例：有一个原数组，经历一次冒泡排序的过程;原数组为：14,6,3,10,2

 第一次比较：14和6比较，14>6，他们两个交换位置;

 第二次比较：14和3比较，14>3，他们两个交换位置;

 第三次比较：14和10比较，14>10，他们两个交换位置;

 第四次比较：14和2比较，14>2，他们两个交换位置;

冒泡练习：随机产生5个1到100的数字，装入数组，然后通过冒泡排序，由小到大排列出来

package com.zzm.sort;

import java.util.Random;

public class Bubble {
    public static void main(String[] args) {
        bubble();
    }

    // 冒泡-随机产生5个1到100的数字
    public static void bubble() {
        int[] arr = new int[5];
        for (int i = 0; i < 5; i++) {
            arr[i] = new Random().nextInt(100) + 1;// 随机产生5个1到100的数字
        }
        System.out.println("冒泡排序原来数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        System.out.println("-----------------------------------");

        for (int i = 0; i < arr.length - 1; i++) {// 排序次数，数字长度为5，因为只用比较4次，所以减1
            for (int j = 0; j < arr.length - 1 - i; j++) {// 每次排序大的放后面，因为j+1>数组长度，所以减1；因为每排一轮最大的就放后面了，减i可以增加效率
                if (arr[j] >= arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.print("第" + (i + 1) + "次排序结果：");
            for (int k = 0; k < arr.length; k++) {
                System.out.print(arr[k] + " ");
            }
            System.out.println();
        }
    }
}

快速排序：

快速排序：快速排序其实是冒泡排序的一种改进版；在冒泡排序中，比较的是相邻的两个数，进过比较，大数值的往后面方法，小数值的往前面放，每次遍历一次数组，就能找到一个遍历中最大的数，放在最后，经过多次遍历数组，多次找到遍历中最大的数放在后面，最终实现数组由小到大排序。而快速排序，是在要排序的原数组中，找一个数作为标准，与第一个数或者最后一个数作比较，最终实现，这个作为标准的数，它左边的数都比它小，它右边的数狗比它大。这就算是完成一次排序了。再经过递归，就可以实现数组的由小到大的数组排序。

举例：有一个原数组，经理一次快速排序的过程;原数组为：58,62,42,92,35

 我选着第一个数58作为标准；大的放后面，小的放前面

第一次比较：58和35比较，58>35,58在前面，35在后面，交换它们的位置

第二次比较：58和62比较，58<62,58在后面，62在前面，交换它们的位置

第三次比较：58和92比较，58<92,58在前面，92在后面，不变换位置

第四次比较：58和42比较，58>42,58在前面，42在后面，交换它们的位置

第一次排序完成后：58左边的数都比58小，58右边的数都比58大；

快排练习：随机产生5个1到100的数字，装入数组，然后通过快速排序排序，由小到大排列出来

package com.zzm.sort;

import java.util.Random;

public class Quicksort {
    public static void main(String[] args) {
        int[] arr=new int[5];
        for(int i=0;i<5;i++){
            arr[i]=new Random().nextInt(100)+1;
        }
        System.out.println("原生快速排序数组为：");
        for(int j=0;j<5;j++){
            System.out.print(arr[j]+" ");
        }
        System.out.println();
        System.out.println("-------------------");
        
        int start=0;
        int end=arr.length-1;
        quicksort(arr,start,end);
        System.out.println("快速排序后的数组为：");
        for(int k=0;k<5;k++){
            System.out.print(arr[k]+" ");
        }
        
    }

    public static void quicksort(int[] arr, int low ,int high) {
        int start=low;
        int end=high;
        int key=arr[low];//不变的
        
        while(end>start){//快排第一遍，找到一个数左边的都比他小，右边的都比他大
            while(end>start&&arr[end]>=key){//拿第一个数跟最后一个数比
                end--;//第一个数比最后一个数小，就比倒数第二个，，，，以此类推
                }
                if(arr[end]<=key){//如果第一个数>=最后一个数，就交换位置
                    int t=arr[end];
                    arr[end]=arr[start];
                    arr[start]=t;
                }
            while(end>start&&arr[start]<=key){
                start++;    
                }
                if(arr[start]>=key){
                    int t=arr[start];
                    arr[start]=arr[end];
                    arr[end]=t;
                }
            }
            
            if(start>low){//标准数，左边的递归
                quicksort(arr,low,start-1);
            }
            if(end<high){//标准数，右边的递归
                quicksort(arr,end+1,high);
            }
            
        }
        
}