排序算法

1. 插入排序

   def inster_sort(lists):
       count = len(lists)
       for i in range (1,count):
           key = lists[i]
           j = i -1
           while j>=0:
               if lists[j] > key:
                   lists[j+1] = lists[j]
                   lists[j] = key
               j -= 1
        return lists
   # 时间复杂度O(n**2)，空间复杂度O(1) ，稳定
   

2. 希尔排序

   def shell_sort(lists):
       # 希尔排序
       count = len(lists)
       step = 2
       group = count / step
       while group > 0:
           for i in range(0, group):
               j = i + group
               while j < count:
                   k = j - group
                   key = lists[j]
                   while k >= 0:
                       if lists[k] > key:
                           lists[k + group] = lists[k]
                           lists[k] = key
                       k -= group
                   j += group
           group /= step
       return lists
   

3. 冒泡排序

   def bubble_sort(lists):
       # 冒泡排序
       count = len(lists)
       for i in range(0, count):
           for j in range(i + 1, count):
               if lists[i] > lists[j]:
                   lists[i], lists[j] = lists[j], lists[i]
       return lists
   # 时间复杂度O(n*2)，空间复杂度O(nlog2N)，稳定
   

4. 快速排序

   def quick_sort(lists, left, right):
       # python 快速排序
       if left >= right:
           return lists
       key = lists[left]
       low = left
       high = right
       while left < right:
           while left < right and lists[right] >= key:
               right -= 1
           lists[left] = lists[right]
           while left < right and lists[left] <= key:
               left += 1
           lists[right] = lists[left]
       lists[right] = key
       quick_sort(lists, low, left - 1)
       quick_sort(lists, left + 1, high)
       return lists
   # 时间复杂度O(n*log2N)，空间复杂度O(nlog2N)，不稳定
   

   # include 
   # include 
   # define BFU_SIZE 10
   # c 快速实现
   # 打印数组元素
   void display(int array[],int maxlen){
       int i ;
       for(i=0;iarray[begin]){
                   swap(&array[i],&array[j]);
                   j--;
               }
               else{
                   i++;
               }
           }
           # 此时数组分成了两个部分，进行比较，确定 基准数
           if(array[i]>=array[begin]){
               i--;
           }
           swap(&array[begin],&array[i]);
           quicksort(array,maxlen,begin,i);
           quicksort(array,amxlen,j,end);
       }
   }
   
   int main(){
       int n;
       int array[BUF_SIZE]={}
       int maxlen=BUF_SIZE
       
       printf("排序之前");
       display(array,maxlen)
       
       quicksort(array,amxlen,0,maxxlen-1);
       printf("排序之后");
       display(araay,maxxlen);
   
       retunr 0;
   }
   

5. 直接选择排序

   def select_sort(lists):
       # python 选择排序
       count = len(lists)
       for i in range(0, count):
           min = i
           for j in range(i + 1, count):
               if lists[min] > lists[j]:
                   min = j
           lists[min], lists[i] = lists[i], lists[min]
       return lists
   # 时间复杂度O(n**2)，空间复杂度O(1)，不稳定
   

   # c 选择排序
   void selection_sort(int arr[],int n){
       int i,j,k;
       for(i=0;i

6. 堆排序

   from collections import deque
   L=deque([34,23,32,45,67,87])
   l.appendleft(0)
   
   def element_exchange(numbers,low,high):
       temp=numbers[low]
       i=low
       j=2*i
       
       while j<=high:
           # 如果右节点较大，则j指向右节点
           if jnumbers[j]:
               # 将numbers[j]放到双亲节点上
               numbers[i]=numbers[j]
               i=j
               j=i*2
           else:
               break;
       # 被调整节点放入最终位置        
       numbers[i]=temp
   
   def top_heap_sort(numbers):
       length=len(numbers)-1
       # 指定第一个元素的下标，是无序序列的第一个非叶子节点
       first_exchange_element=length/2
       # 建立初始堆
       print first_exchange_element
       for x in tange(first_exchange_element):
           element_exchange(numbers,first_exchange_element-x,length)
       # 将根节点放到最终位置，继续堆排序
       for y in range(length-1):
           temp=numbers[1]
           numbers[1]=numbers[length-y]
           numbers[length-y]=temp
           element_exchange(numbers,1,length-y-1)
   # 时间复杂度O(n*log2N),空间复杂度O(1),不稳定
   

7. 归并排序

   # 进行拆分
   def merge_sort(lists):
       # 长度不足1，直接返回
       if len(lists) <= 1:
           return lists
       # 二分
       num = len(lists) / 2
       # 递归拆分
       left = merge_sort(lists[:num])
       right = merge_sort(lists[num:])
       # 执行比较
       return merge(left, right)
   # 进行比较合并
   def merge(a,b):
       c = []
       h=j=0
       while j

8. 基数排序

   import math
   def radix_sort(lists, radix=10):
       k = int(math.ceil(math.log(max(lists), radix)))
       bucket = [[] for i in range(radix)]
       for i in range(1, k+1):
           for j in lists:
               bucket[j/(radix**(i-1)) % (radix**i)].append(j)
           del lists[:]
           for z in bucket:
               lists += z
               del z[:]
       return lists
   

9. 斐波那契数列

   # 递归实现
   def item( num ):
       if num == 0 :
           res = 0
       elif num == 1:
           res = 1
       else:
           res = item ( num - 1) + item (num -2)
       return res
   
   def printFibo( no ):
       i = 0
   
       while i < no:
           print item(i)
           i += 1
   

   # 迭代器实现，返回一个列表
   def fibo(num):
       numList = [0,1]
   
       for i in range(num - 2):
           numList.append(numList[-2] + numList[-1])
       return numList
   

10. 深度遍历

    def DFS(nodes):
        # queue是堆栈
        # order是存放的具体路径
        queue,order=[],[]
        queue.append(nodes)
        while queue:
            v=queue.pop()
            order.append(v)
            for w in sequense[v]:
                if w not in order and w not in queue:
                    queue.append(w)
        return order
    

11. 广度遍历

    def BFS(node):
        queue,order=[],[]
        queueu.append(node)
        order.append(node)
        while queue:
            v=queue.pop()
            for w in sequense[v]:
                if w not in order:
                    order.append(w)
                    queue.append(w)
        return order
    

12. 二分查找

    def binary_search(find,list1):
        low=0
        high=len(list1)
        while lowfind:
                high=mid-1
            else:
                low=mid+1
        return -1
    

    ​