排序算法二（冒泡）（C+Python）

冒泡排序

时间复杂度O(n2)，空间复杂度O(1)，该排序算法稳定！

int swap(int a[],int i,int j){   //交换两元素的位置
	int temp = a[i];
	a[i] = a[j];
	a[j] = temp;
}

void bubbleSort(int a[],int n){
	for(int m = 0;m < n-1;m++){   //每次最大的元素都会放到最底端
		for(int k = 0;k < n-1-m;k++){   //比较相邻元素的大小，较大的后移
			while(a[k] > a[k+1]){
				swap(a,k,k+1);
			}
		}
	}
}

class BSList:
    def __init__(self, lis = None):
        self.lis = lis

    def bubble_sort_simple(self):
        length = len(self.lis)
        for i in range(length):
            for j in range(i + 1, length):
                if self.lis[i] > self.lis[j]:
                    self.lis[i], self.lis[j] = self.lis[j], self.lis[i]

    def bubble_sort(self):
        length = len(self.lis)
        for i in range(length -1,0,-1):
            count = 0
            for j in range(0,i):
                if self.lis[j] > self.lis[j + 1]:
                    self.lis[j],self.lis[j + 1] = self.lis[j + 1],self.lis[j]
                 count += 1
            if count == 0:
                return   

    def __str__(self):
        ret = ""
        for i in self.lis:
            ret += " %s" %i
        return ret


if __name__ == "__main__":
    bslist = BSList([4,1,7,2,9,0,3,2,5])
    bslist.bubble_sort_simple()
    print(bslist)
    bslist2 = BSList([4, 1, 7, 2, 10, 0, 3, 2, 5])
    bslist2.bubble_sort()
    print(bslist2)

注意在python实现的排序算法中，第一种与C实现的没有区别，时间复杂度为O(n^2)；在第二种实现方式中，引入变量count，该变量用于当原数列为有序时，直接返回，减少排序时间！最理想的情况下时间复杂度为O(n)!

堆排序

https://www.cnblogs.com/kkun/archive/2011/11/23/2260286.html
这里说的堆是指的一种数据结果，这个数据结果其实就是完全二叉树，对于完全二叉树，则除了叶子结点，别的结点都是由两个孩子的，分别是左孩子和右孩子，如果一个节点为i，则它的左孩子为2i+1，右孩子为2i+2。如果不理解可以看上面那个博客！它对整个过程作了详细的说明。
时间复杂度O(nlogn)，空间复杂度 O(1)，是不稳定的！注意，堆排序属于冒泡排序的进阶版！

void Heapify(int a[],int i,int size){   //从a[i]向下进行堆调整
	int left_child = 2*i+1;    //左孩子的索引
	int right_child = 2*i+2;   //右孩子的索引
	int max = i;       //先认为i为最大的值，然后与左右孩子比较，选出最大值
	if(left_child < size && a[left_child] > a[max])
		max = left_child;
	if(right_child < size && a[right_child] > a[max])
		max = right_child;
	if(max != i){
		int temp = a[i];
		a[i] = a[max];
		a[max] = temp;
		Heapify(a,max,size);   //通过递归调用，调整堆，在该代码中，是建立最大堆
	}
}
 
int BuildHeap(int a[],int n){   //建堆
	int heap_size = n;
	for(int i = heap_size/2 - 1; i >= 0; i--)  //从每一个非叶子结点开始往下调整
		Heapify(a,i,heap_size);
	return heap_size;
}
 
void HeapSort(int a[],int n){     
	int heap_size = BuildHeap(a,n);   //建立一个最大堆
	while(heap_size > 1){   //堆元素大于1，说明还没有完成排序
		int temp = a[0];    //将堆定元素和最后一个元素进行交换，并且在堆中去掉最后一个元素
		a[0] = a[--heap_size];
		a[heap_size] = temp;
		Heapify(a,0,heap_size);   //对新堆进行自顶而下的调整，形成最大堆
	}
}

class HeapSort:
    def __init__(self,lis):
        self.lis = lis

    def adjust_heap(self,lis,i,size):
        lchild = 2 * i + 1
        rchild = 2 * i + 2
        max = i
        if i < size // 2:
            if lchild < size and self.lis[lchild] > self.lis[max]:
                max = lchild
            if rchild < size and self.lis[rchild] > self.lis[max]:
                max = rchild
            if max != i:
                self.lis[max],self.lis[i] = self.lis[i],self.lis[max]
                self.adjust_heap(self.lis,max,size)

    def build_heap(self,lis,size):
        for i in range(0,(size//2))[::-1]:  #注意此处的写法，//是取整的意思
            self.adjust_heap(lis,i,size)

    def heap_sort(self,lis):
        size = len(self.lis)
        self.build_heap(lis,size)
        for i in range(0,size)[::-1]:
            self.lis[0],self.lis[i] = self.lis[i],self.lis[0]
            self.adjust_heap(lis,0,i)

    def __str__(self):
        ret = ""
        for i in self.lis:
            ret += " %s" %i
        return ret

def main():
    bslist = HeapSort([4, 1, 7, 2, 9, 0, 3, 2, 5])
    bslist.heap_sort(bslist)
    print(bslist)