一些经典算法的记录与回顾

一.快速排序时间效率为：O(nlogn);

void quick_sort(int s[],int l,int r)
{
    int i,j,x;
    if(l<r){
        i=l;
        j=r;
        x=s[i];
        while(i<j){
            while(i<j&&s[j]>x)j--;
            if(i<j)s[i++]=s[j];
            while(i<j&&s[i]>x)i++;
            if(i<j)s[j--]=s[i];
        }
        s[i]=x;//问题1：什么时候开始递归？答：当和j相遇的时候，将中间值确定位置后；
        quick_sort(s,l,i-1);//问题2：下一次递归选择的基准是什么？答：选择分治后数组的第一个值；
        quick_sort(s,i+1,r);
    }
}

二.冒泡排序时间复杂度O(n2)

for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
　　　　if(arr[j]>arr[j+1]){
　　　　　　int temp=arr[j];
　　　　　　arr[j]=arr[j+1];
　　　　　　arr[j+1]=temp;
　　　　 }
　　}
}

详细解释转自：https://www.cnblogs.com/onepixel/articles/7674659.html（时间复杂度以及思想）

三.二分查找法时间复杂度（O（logn））

 int low = 0, high = lenght(data) - 1;
 while (low <= high) {
      int mid = low + (high - low) / 2;
      if (data[mid] == key) {
          return mid;
      } else if (data[mid] > key) {
          high = mid - 1;
      } else {
         low = mid + 1;
      }
}

二分查找法可以应用于最大上升子序列的问题；

import bisect

while True:
    try:
        num=int(input())
        a=map(int,input().split())
        c=[]
        for i in a:
            x=bisect.bisect_left(c,i)//本质就是二分查找法，找到i则返回左侧下标，没有则返回对应位置
            if x==len(c):
                c.append(i)
            else:
                c[x]=i
        print(len(c))
    except:
        break
//这里最后存储的数组不一定是最大上升数组，可能其中有替换（我的想法）
//需要打印出来时候的解决方式
//判断最后一个值是否小于前一个值，
//是的话，找到输出数组的下标c.index()，分别确定该数的前一个与后一个值，在原数组中对这个区间的值进行搜索（倒序查找，避免出现相同的情况）

牛顿迭代法

//求平方根：二分法
private static float sqrt(float num,float e){
    
    float low = 0F;
    float high = num;
    float guess,e0;
    int count = 0;
    do{
        guess = (low+high)/2;
        if(guess*guess>num){
            high=guess;
            e0=guess*guess-num;
        }else{
            low=guess;
            e0=num-guess*guess;
        }
        count++
    }while(e0>e);

    return guess;
}

关键的迭代公式

private static float sqrtNewto(float num,float){
	float guess=num/2;//随便选择一个数先
	float e0;
	int count=0;
	do{
		guess=(guess+num/guess)/2;//不断修正的公式
		e0=guess*guess-num;
		
		count++;
	}while(e0>e);
	
	return guess;
}

一些经典算法的记录与回顾

猜你喜欢