【算法】Day2-排序

1.冒泡排序

思路

每一次从i和i+1两两比较，如果i大的话，i和i+1交换顺序，一直到i=N-1.时间复杂度O(N^2)，额外空间复杂度O(1)

代码解析

当数组为空的情况不需要排序，当数组长度小于1的情况不需要排序。相当于用end从末尾开始，来区分已经排好序的队列；用i从0开始来寻找最大的数，每次循环都是寻找最大的数把它放到末尾

Java

public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int end = arr.length - 1; end > 0; e--) {
			for (int i = 0; i < end; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(arr, i, i + 1);
				}
			}
		}
	}

public static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] ^ arr[j];
		arr[j] = arr[i] ^ arr[j];
		arr[i] = arr[i] ^ arr[j];
	}

Python

arry = [2,4,6,8,1,9,0]

def swap(arry,i,j):
    tem = arry[i]
    arry[i] = arry[j]
    arry[j] = tem

def bubble_sort(arry):
    if (arry == None)or(len(arry)< 2):
        print("1")
        return
    for end in range(len(arry)-1,0,-1):
        for i in range(0,end):
            if arry[i]>arry[i+1]:
                swap(arry,i,i+1)
    print(arry)

bubble_sort(arry)

• 这里如果需要从大到小排序，代码如下：

def bubble(arry):
    for end in range(len(arry)-1,0,-1):
        for i in range(0,end):
            if arry[i]<arry[i+1]:
                swap(arry,i,i+1)

    print(arry)

条件三段式：

• a[i]<b[j]?a[i++]:b[j++];
• (条件) ? (符合条件所返回的值) : (不符合条件所返回的值)

2.选择排序

思路

选择排序的思路是对于已有的一个数列，初始值为i=0，然后从0到最后一个中，找到最小的一个放到index = 0的位置，之后再从i+1到末尾找到最小的一个放到1的位置。以此类推。

• 时间复杂度O(N^2)，额外空间复杂度O(1)

Python

def select_sort(arry):
    if(arry == None)or(len(arry) <2):
        return
    for i in range(0,len(arry)-1):
        minIndex = i
        #最小下标默认为i,然后找最小的下标
        for j in range(i+1,len(arry)):
            if arry[j] < arry[minIndex]:
                minIndex = j
        swap(arry,i,minIndex)
    print(arry)

def swap(arry,i,j):
    tem = arry[i]
    arry[i] = arry[j]
    arry[j] = tem

• 然后是从大到小排列

def select(arry):
    for i in range(0,len(arry)-1):
        maxindex = i
        for j in range(i+1,len(arry)):
            if arry[j]>arry[maxindex]:
                maxindex = j
        swap(arry,i,maxindex)
    print(arry)

Java

public static void selectionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			}
			swap(arr, i, minIndex);
		}
	}

3.插入排序

思路

插入的思路类似于

• 时间复杂度O(N^2)，额外空间复杂度O(1)
• 最好情况：已经排好的：O(N)
• 最差情况：逆序排序：0(N^22)

代码解析

默认i = 0是已经排好序了，从1开始往后N-1选取数，把新拿出来的数和之前的做比较。所以第一层排序是从i = 1开始。

第二层排序是从j=i-1开始，选了的数字i和j比较，如果j>j+1，就要交换，直到j=0，j不断前移。

Java

public static void insertionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 1; i < arr.length; i++) {
			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
				swap(arr, j, j + 1);
			}
		}
	}

Python

def insert_sort(arry):
    if (arry == None) or (len(arry) < 2):
        return
    for i in range(1,len(arry)):
        for j in range(i-1,-1,-1):
            if arry[j]>arry[j+1]:
                swap(arry,j,j+1)
    print(arry)

• 换成从大到小的排序

def insert(arry):
    if (arry == None) or (len(arry) < 2):
        return
    for i in range(1,len(arry)):
        for j in range(i-1,-1,-1):
            if arry[j]<arry[j+1]:
                swap(arry,j,j+1)
    print(arry)