冒泡排序，选择排序，快速排序算法小总结

冒泡排序，选择排序，快速排序

排序算法小总结

开始接触算法的内容，写下博客防止自己忘记，可以有资料供自己翻阅。

仅是自己的个人理解！！！

冒泡排序

1. 原理
   简单来说，冒泡算法就是比较相邻的两个元素，两两比较，大的在右边，小的在左边，一次循环里面把整个数组（长度为n）的最大数放在最右边，第二次循环，比较的是n-1个数，上限比第一次少1，因为最右边的已经是最大的了，在第一次循环已经排好了；重复两两比较，这n-1个中最大的数也放在最右边…一共循环n-1次。
   2.实现
   用Java语言写的

package Alogthim;
/*
冒泡排序
拿着相邻的元素比较，大的放在右边，小的放在左边，再继续向右走一位，与后续的继续比较
 */
/*
第一次循环
原始：3 5 8 2 4 1 9
开始循环：3和5比较，5在右，5和8比较，8在右，8和2比较，8在右，8和4比较，8在右，8和1比较，8在右，8和9比较，9在右，8在左
循环结束，此时数组是3 5 2 4 1 8 9
*/
 /*
第二次循环
3和5比较，5在右，5和2比较，5在右，5和4比较，5在右，5和1比较，5在右，5和8比较，8在右，5在左
循环结束，此时数组是3 2 4 1 5 8 9
*/
/*
第三次循环
3和2比较，3在右，3和4比较，4在右，4和1比较，4在右，4和5比较，5在右
循环结束，此时数组是2 3 1 4 5 8 9
 */
/*
第四次循环
2和3比较，3在右，3和1比较，3在右，3和4比较，4在右
循环结束，此时数组是2 3 1 4 5 8 9
 */
/*
第五次循环
得到2 1 3 4 5 8 9
 */
/*
第六次循环
得到1 2 3 4 5 8 9
 */
public class BubSort {
    public static void main(String[] args) {
        int [] a = {3,6,8,2,4,111,9};
//        for ( int i= 0 ; i<a.length ; i++){
//            for( int j= 0; j <a.length-1-i; j++ ){
//                if (a[j]>=a[j+1]){
//                    int temp=a[j];
//                    a[j]=a[j+1];
//                    a[j+1]=temp;
//                }
//            }
//        }
        for ( int i= a.length-1 ; i>0 ; i--){
            for( int j= 0; j <i; j++ ){
                if (a[j]>=a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        for( int i=0;i<a.length;i++){
            System.out.print(a[i]+"  ");
        }
    }
}

选择排序

1.原理
选择排序的原理和冒泡类似，同样是两两比较，但是不是比较相邻的两个元素值，而是选定一个最小值去比较，假设，我现在认为数组（长度为n）的第一个元素设为min，接下来就是拿第二个元素去与设定好的最小值比较，如果第二个比第一个小，就交换位置，否则，就保持不动；然后拿出第三个元素与上一轮比较出来的最小值进行比较，同样是大的在左边，小的在右边,一直循环下去，直至循环n-1次。
2.实现：Java代码实现

package Alogthim;
/*
每一次都是从这堆要比较的数据中找到最小的值，拿着这个最小的值与最左边的元素交换位置
选择排序比冒泡排序好在每次交换的位置为1
选择排序的效率比冒泡排序的效率高

选择排序的关键在于找最小
 */
public class SelectSort {
    public static void main(String[] args) {
        int [] a ={5, 3, 8,8,9,10,7};
//        第一种
//        for (int i = 0; i < a.length-1; i++)
//        {
//            int min = i ;
//            for (int j = i+1; j < a.length; j++)
//            {
//                if (a[min]>a[j])
//                {
//                    int temp =a[j];
//                    a[j]=a[min];
//                    a[min]=temp;
//                }
//
//            }
//        }
        //第二种
        for (int i = 0; i < a.length-1; i++)
        {
            int min = i ;
            for (int j = i+1; j < a.length; j++)
            {
                if (a[min]>a[j])
                min=j;
            }
            if (min!=i)
            {
                int temp;
                temp = a[min] ;
                a[min]=a[i];
                a[i]=temp;
            }
        }
        for ( int i = 0;i< a.length;i++)
        {
            System.out.println(a[i]);
        }

    }
}

快速排序

1.原理：
快速排序是利用一个基准，大于基准的放在右边，小于基准的放在左边，然后再对基准两边的集合再各选一个基准，重复上述操作，直至排序完成。
当在基准的右边找到一个比基准小的数，就将这个数移到基准的的位置，就是交换位置，而基准等到i=j的时候，即走到中间位置，基准放在这里。
2.Java实现

package Alogthim;

import java.util.Arrays;

public class QuickSort {
    public static void quicksort(int s[], int l, int r) {
//快速排序

            if (l < r)
            {
                //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
                int i = l, j = r, x = s[l];
                while (i < j)
                {
                    while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
                        j--;
                    if(i < j)
                    {
                        int temp = s[j];
                        s[j] = s[i];
                        s[i] = temp;
//                        s[i] = s[j];
//                        i++;
                    }
//                        s[i++] = s[j];

                    while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                        i++;
                    if(i < j)
                    {
                        int temp = s[i];
                        s[i] = s[j];
                        s[j] = temp;
                    }
//                        s[j--] = s[i];
                }
                s[i] = x;
                quicksort(s, l, i - 1); // 递归调用
                quicksort(s, i + 1, r);
            }
        }


    public static void main(String[] args) {

        int[] a = { 49, 38, 85,49,65, 97, 88,985,451,552,45,15,16,85,276, 13, 27, 30 ,-45,-78};
        quicksort(a,0,a.length-1);
        System.out.println(Arrays.toString(a));
    }
}