分治算法

分治算法：设计算法的另一种常用技巧， 由两部分组成：

1. 分(divide)： 将大的问题拆分成小问题；
2. 治(conquer)：从子问题中得到原问题的解。

分治算法与递归算法：

递归是程序一种特殊的函数调用，不是使用了递归就是分治算法，比如平衡二叉树的搜素，只是使用了递归这种思想。另一方面递归是实现分治主要方法。

 

使用分治法的例子：， 

斐波那契数：

斐波那契数问题使用了分治算法，但是使用递归解决斐波那契数问题违反了递归设计原则的合成效益法则，（理解递归）。

斐波那契数列的排列是：0，1，1，2，3，5，8，13，21，34，55，89，144……，依次类推下去，你会发现，它后一个数等于前面两个数的和。求第5个斐波那契数。

大问题可以通过小问题 a3=a2+a1解决。

#include<stdio.h>

//斐波那契数递归写法 
int Fib_1(int i){
    if(i<=2)
        return 1;
    else
        return Fib_1(i-1)+Fib_1(i-2);
} 
//斐波那契数循环写法 
int Fib_2(int i){
    int k=0,fib,fib1,fib2;
    for(;k<=i;k++){
        if(k<=2){
            fib=fib1=fib2=1;
        }else{
            fib2 = fib1;
            fib1 = fib;
            fib = fib1+fib2;
        }
    }
    return fib;
}

int main(){
    int a = Fib_1(5);
    //int a = Fib_2(5);
    printf("%d",a);
    return 0;
}

快速排序：

快速排序是使用分治算法很好的例子，通过和“关键字”进行比较，消除数字序列中的多个“逆序数”得到有序序列。

#include<stdio.h>

//快速排序(效率=>枢纽元的选择) 
void QuickSort(int *a, int left, int right){
    /*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    if(left >= right){
        return ;
    }
    int i = left;
    int j = right;
    int key = a[left];//枢纽元
    /*当组内执行快速排序*/
    while(i < j){
        while(i < j && key <= a[j]){//得到右边小于关键字的下标 
            j--;
        } 
        a[i] = a[j]; //切换位置，消除逆序数 
         
        while(i < j && key >= a[i]){//得到左边大于关键字的下标
            i++;
        }
        a[j] = a[i]; //切换位置，消除逆序数 
    }
    /*当在当组内找完一遍以后就把中间数枢纽元回归*/ 
    a[i] = key;
    QuickSort(a, left, i - 1);/*左边的小组进行同上的做法*/
    QuickSort(a, i + 1, right);/*右边的小组进行同上的做法*/
} 

int main(){
    int A[6] = {34,8,64,51,32,31};
    QuickSort(A,0,5);//快速排序 
    Display(A,6);
    return 0;
} 

反转链表

func ReverseList(head *ListNode) *ListNode {
    //每个节点执行指向前一个指针的逻辑，知道节点为空
    var beforeNode *ListNode //记录前一个指针
    var tempNextNode *ListNode //临时保存中间指针的变量
    for head != nil {
        tempNextNode = head.Next
        head.Next = beforeNode
        beforeNode = head
        head = tempNextNode
    }
    return beforeNode
}