排序算法(三）(选择)（C+python）

选择排序首先就是找到数组中最小的那个元素，然后将其与数组中的第一个元素交换位置；接着在剩余的元素中找到最小的元素，将其与第二个元素交换位置。如此往复，直到将针整个数组排序。其实就是不断的在剩余数组中找最小的元素。所以它的运行时间和输入无关，它的移动也是最少的。

选择排序

时间复杂度O(n^2)，空间复杂度O(1)，不稳定！

选择和冒泡的区别：选择是每次遍历未排序的数组，选出最小或最大的值，将其放在未排序的头或尾位置，而冒泡是每次遍历数组，两两比较相邻的值，并对未排序的进行交换，最终将当前的最大或最小的值放在未排序的头或尾位置。

void SelectionSort(int a[], int n)
{
    for (int i = 0; i < n - 1; i++)         // i为已排序序列的末尾
    {
        int min = i;                        //将未排序的末尾的值赋给a[min]
        for (int j = i + 1; j < n; j++)     // 未排序序列
        {
            if (a[j] < a[min])              // 找出未排序序列中的最小值
            { 
                min = j;         
            }
        }
        if (min != i)
        {
            int temp = a[min];
            a[min] = a[i];
            a[i] = temp;
        }
}

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

    def selectSort(self,lis):
        length = len(self.lis)
        for i in range(0,length-1):
            min = i
            for j in range(i + 1,length):
                if self.lis[j] < self.lis[min]:
                    min = j
            if min != i:
                self.lis[min],self.lis[i] = self.lis[i],self.lis[min]

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

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

鸡尾酒排序

鸡尾酒算法说白了就是先从低到高再从高到低比较元素之间的大小，这样可以减小循环的次数。它的时间复杂度是O(n^2)，空间复杂度是O(1),是稳定的！

void CocktailSort(int a[],int n){
int left = 0;
int right = n-1;
while(left < right){
    for(int i = left; i < right; i++){
        if(a[i] > a[i+1]){
            int temp = a[i];
            a[i] = a[i+1];
            a[i+1] = a[i];
        }
    }
    right--;
    for(int i = right; i > left; i--){
        if(a[i] < a[i-1]){
            int temp = a[i];
            a[i] = a[i-1];
            a[i-1] = a[i];
        }
    }
    left++;
}
}

快速排序

快速排序是对选择排序的一种改进算法，也称为划分交换排序。
它的平均时间复杂度是O(nlogn)，最坏的情况是O(n^2)，空间复杂度一般为O(logn)，最差为O(n)，这个算法是不稳定的。

int swap(int a[], int i, int j){
	int temp = a[i];
	a[i] = a[j];
	a[j] = temp;
}

int Partition(int a[], int left, int right){
	int pivot = a[right];  //每次排序都会找到一个参考值，这个值一般取最后一个元素
	int tail = left - 1;    //tail为小于参考值的子数组最后一个元素的索引
	for( int i = left;i < right; i++){  //遍历基准以外的其他元素
		if(a[i] <= pivot){  //把小于等于基准的元素放在前一个数组的尾部
			tail++;
			if(tail != i){
				swap(a, tail, i);
			}
		}
	}
	swap(a, tail+1, right);  //把基准放到前一个子数组的末尾位置
	return tail+1;       //返回基准的索引
}

void quickSort(int a[], int left, int right){
	if(left >= right)
		return;
	int pivot_index = Partition(a, left, right);   //基准索引
	quickSort(a, left, pivot_index - 1);
	quickSort(a, pivot_index + 1, right);
}

在程序中，给的数组是a[]={65,2,17,3,29,32,43,1,56}，在后续的调用Partition()函数的循环之中，总共有6轮数组的调整
第一轮：2,17,3,29,32,43,1,56,65；这一轮中,tail+1=7,right=8
第二轮：1,17,3,29,32,43,2,56,65；这一轮中,tail+1=0,right=6
第三轮：1,2,3,29,32,43,17,56,65；这一轮中,tail+1=2,right=6
第四轮：1,2,3,17,32,43,29,56,65；这一轮中,tail+1=3,right=6
第五轮：1,2,3,17,29,43,32,56,65；这一轮中,tail+1=4,right=6
第六轮：1,2,3,17,29,32,43,56,65；这一轮中,tail+1=5,right=6
为什么第二轮到第三轮中，tail+1从0直接跳转到2，因为在第三轮中我们可以看到1,2,3中的有序了，所以3没有与17进行交换，但是 Partition()函数还是运行了，所以tail也自增了1，所以严格来说上述数组其实有7轮循环。

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

    def Partition(self,lis,left,right):
        pivot = self.lis[right]
        tail = left -1
        for i in range(left,right):
            if self.lis[i] <= pivot:
                tail += 1
                if tail != i:
                    self.lis[tail],self.lis[i] = self.lis[i],self.lis[tail]
        self.lis[tail + 1],self.lis[right] = self.lis[right],self.lis[tail + 1]
        return tail + 1

    def quickSort(self,lis,left,right):
        if left > right:
            return
        pivot_index = self.Partition(self.lis,left,right)
        self.quickSort(self.lis, left, pivot_index - 1)
        self.quickSort(self.lis, pivot_index + 1, right)

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

def main():
    lis = [4, 1, 7, 2, 9, 0, 3, 2, 5]
    bslist = QuickSort(lis)
    right = len(lis)
    bslist.quickSort(bslist,0,right - 1)
    print(bslist)

if __name__ == "__main__":
    main()