基本排序算法

基本排序算法

你说多了，有人觉得你是傻逼。你一句不说，有人觉得你在在装逼，是吧，也许是吧。还有就是，我不是吹的，你要跟我打架，不出一分钟，我就要你跪在地上。
*
*
*
*
掐着我的人中，求我不要死。
前些天学到了一些基本的排序算法，自己记录一下，就当是复习了。大概就是简单的选择排序，冒泡排序，归并排序，快速排序这一些。
先是选择排序，时间复杂度为O(n**2)，先是第一次for循环，预留一个位置，接着在for循环，逐个对比寻找最小的数，最后交换位置。

def selector_sort(datas, comp=lambda x, y: x<y):
      items = datas[:]
      for i in range (len(items)-1):
            min_num = i
            for j in range(i+1, len(items)):
                 if comp(items[j], items[min_num]):
                        items[j], items[min_num] = items[min_num], items[j]
     return items                   

冒泡排序

def bubble_sort(datas, comp=lambda x, y: x>y):
      items = datas[:]
      swapped = False
      for i in range(len(items) - 1):
           for j in range(len(items) - 1 -i):
               if comp(items[j], items[j + 1]):
                    items[j], items[j + 1] = items[j + 1] , items[j]
                    swapped = True
      if not swapped :
           break
      return items
                          

冒泡排序进阶版

def bubble_sort(datas, comp=lambda x, y: x>y):
      items = datas[:]
      swapped = False
      for i in range(len(items)-1):
           swapped = False
           for j in range(i, len(items) - 1 - i):
                if comp(items[j], items[j +1]):
                      items[j], items[j+1] = items[j+1], items[j]
                      swapped = True
           if swapped:
                swapped = False
                for j in range(len(items)-i - 1, i , -1):
                if comp(items[j-1],items[j]):
                     items[j-1], items[j] = items[j], items[j -1]
                     swapped = True
           if not swapped:
                break
      return items                         
                                 

上面所谓的进阶就是在第二个for循环时，先是从前往后，在从后往前进行比较。接下来就是归并排序，它会使用递归的方法。

def merge_sort(items, comp=lambda x, y: x<=y):
   if len (items) < 2:
      return items[:]     # 判断是否已经分到只为一个元素，若不是接着分
   mid = len(items)//2    # 对于数组分开时，除二取整
   left = merge_sort(items[:mid],comp)  # 对于左边的细分
   right = merge_sort(items[mid:],comp)  # 对于右边的细分
   return merge(left,right,comp)  # 合并且进行排序


def merge(items1, items2, comp=lambda x, y:x<=y）:
    items = []
    index1, index2 = 0, 0   # 此时进来的两个数据是已经排序好了的，现在是合并
    while index1 <len(items1) and index2<len(items2):
        if  comp(items1[index1], items2[index2]):
             items.append(items1[index1])
             index1 += 1
        else:
             items.append(items2[index2])
             index2 += 1
    items += items1[index1]
    items += items2[index2]
    return items
                  

接下来就是快速排序了。它主要是不断地找一个标准位，按照左小右大的规则排序，直到序列有序为止。

def quick_sort(origin_items, comp=lambda x, y: x <= y):
    items = origin_items[:]
    _quick_sort(items, 0, len(items) - 1, comp)
    return items
def _quick_sort(items, start, end, comp):
    if start < end:
        pos = _partition(items, start, end, comp)
        _quick_sort(items, start, pos - 1, comp)
        _quick_sort(items, pos + 1, end, comp)

def _partition(items, start, end, comp):
    pivot = items[end]
    i = start - 1
    for j in range(start, end):
        if comp(items[j], pivot):
            i += 1
            items[i], items[j] = items[j], items[i]
    items[i+1], items[end] = items[end], items[i+1]
    return i+1

好了就这些了，大概就是这么个意思。我常常在夜深人静的时候，在冥想自己到底是怎么做到学业感情两边误的。