[算法] 冒泡、插入排序

冒泡排序

思路：依次比较相邻两个元素的大小，不满足大小关系则交换，每次循环都将最大的数置于数组末尾

实现：双循环，单指针；若一个循环中没有发生交换，提前退出

伪码：

n = len(a)
for i = 1 to n-1
    for j = 0 to n-i-1
        if a[j]>a[j+1]
            swap(a[j],a[j+1])
            flag = true
    if (!flag) break

Python：

def bubbleSort(a):
    flag = 1
    n = len(a)
    for i in range(1,n):
        for j in range(n-i):
            if a[j] > a[j+1]:
                a[j],a[j+1] = a[j+1],a[j]
                flag = 0
        if flag: break
        
>>a=[3,5,2,41,8,3,55]
>>bubbleSort(a)
>>[2,3,3,5,41,55]

Java：

import java.util.Arrays;
import java.util.Random;
public class BubbleSort {
    public static void bubblesort(int[] a, int n) {        
        for(int i = 0; i < n; ++i) {
            boolean flag = false;
            for(int j = 0; j < n-i-1; ++j) {
                if(a[j] > a[j+1]) {
                    int temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                    flag = true;
                }            
            }
            if(flag == false) break;
        }
    }        
}

 

插入排序

思路：将数组分成有序部分和无序部分，无序部分的新元素与有序部分元素依次比较大小，插入

实现：双循环，双指针；内层循环用倒序

伪码：

for i = 0 to n-1
    value = a[i]
　　 j = i -1
    while j >= 0:if a[j] > value
            a[j+1] = a[j]
　　　　 else:break
　　　　 j-=1 
    a[j+1] = value

 Python：

def insertionSort(a):
    n = len(a)
    for i in range(1,n):
        value = a[i]
        j = i-1
        while j >= 0:
            if a[j] > value:
                a[j+1] = a[j]
            else: break
            j-=1
        a[j+1] = value

Java：

public class InsertionSort {
    public static void insertionsort(int[] a,int n) {
        for(int i = 1; i < n; ++i) {
            int temp = a[i];
            int j = i - 1;
            for(; j >= 0; --j ) {
                if(a[j] > temp) {
                    a[j+1] = a[j];
                }else {break;}
                }
                a[j+1] = temp;    
            }
        }
}

注意：

Python中要用while循环，而不是for，因为不知道执行的次数

java程序中for循环的执行顺序是：判断条件-->主体语句-->修改循环条件，j最小取到0，执行完主体语句后，j引用前自减变成-1，但已不满足判断条件故主体语句不执行，最后a[0]=temp结束。整体过程中不会出现下表越界的情况。所以java中的for循环其实相当于while

选择排序

思路：顺序每次取一个数，从剩余的数中选择最小的与之交换，往复，最后得到有序数组