java算法期末复习知识点

1.合并数列算法代码

public List<Integer> merge(List<Integer> A,List<Integer> B){
    int i = 0,j = 0;
    List<Integer>  C = new ArrayList<Integer>();
    while(i<A.size() && j<B.size()){
      if(A.get(i)<B.get(j)){
        C.add(A.get(i));
        i++;
      }else{
        C.add(B.get(j));
        j++;
      }
    }
      if(i==A.size()){
        for(;j<B.size();j++){
          C.add(B.get(j));
        }
      }else{
        for(;i<A.size();i++){
          C.add(A.get(i));
        }
      }
    return C;
    }
}

2.选择算法代码

public List<Integer> sort(List<Integer> nums){
    for(int i = 0;i<nums.size();i++) {
    	for(int j=i+1;j<nums.size();j++) {
    		int jiaohuan;
    		if(nums.get(i)>nums.get(j)) {
    			jiaohuan = nums.get(j);
    			nums.set(j,nums.get(i));
    			nums.set(i,nums.get(j));
    		}
    	}
    }
    return nums;
}

3.冒泡排序算法代码

public List<Integer> sort(List<Integer> nums){
    for(int i = 0;i<nums.size()-1;i++) {
    	for(int j = 0;j<nums.size()-1;j++) {
    		int jiaohuan;
    		if(nums.get(j)>nums.get(j+1)) {
    			jiaohuan = nums.get(j+1);
    			nums.set(j+1, nums.get(j));
    			nums.set(j, jiaohuan);
    		}
    	}
    }
    return nums;
}

4.堆排序思维
·修改子节点值,向上移

·修改子节点值,向下移

·最大堆性质:根节点永远比两个子节点大
·最小堆性质:根节点永远比两个子节点小
5.堆建立
·最大堆
·
6.基数排序思维
·10个桶:0-9
·按最后一位进行排,也就是个十百千,个位桶排序取出再到十位桶
·
7.union,find操作
·find(x):寻找元素 x 所在集合
·union(x,y):把元素 x 和元素 y 所在集合合并成一个集合
·union(x,y)操作,那个树的高度大就拿那个树来当根节点
·路径压缩:find(x) 操作时,找到 x 的根结点 y 之后,再沿着 x 到 y 的路径,改变路径上所有结点的父指针,使其直接指向 y

·
8.递归阶乘代码

public static int factorial(int n){
  if(n==0 && n == 1){
    return 1;
  }else{
    return n*factorial(n-1);
  }
}

9.递归整数幂代码

public static int power(int x,int n){
  if(n==0){
    return 1;
  }else{
    y=power(x,n/2);
    y=y*y;
    if(n%2==1){
      y=y*x;
    }
  }
  return y;
}

10.斐波那契递归算法代码:

public static int factorial(int n){
  if(n ==1 || n==2){
    return 1;
  }else{
    return factorial(n-1)+factorial(n-2);
  }
}

11.数组主元素代码

public int getCandidate(int nums[], int begin, int end ){
  int j = begin,count =1;
  int c = nums[j];
  while(j<end-1 && count>0){
    j++;
    if(nums[j]==c){
      count++;
    }else{
      count--;
    }
  }
  if(j==end-1 && count>0){
    return nums[j];
  }else if(j==end-1 && count == 0){
    return 0;
  }else{
    return getCandidate(nums,j,end);
  }
}

12.分治合并算法代码

public List<Integer> merge_sort(List<Integer> nums,int low,int high){
  int min;
  if(low<high){
    mid = (high-low)/2;
    merge_sort(nums,low,mid);
    merge_sort(nums,mid+1,high);
    merge(nums,low,mid,high,high-low)
  }
  return nums;
}

13.快速排序代码和思维
·
·
·
·
·
·
·
·
·
·
·

public void quick_sort(List<Integer>nums,int n,int m){
  if(n<m){
    int pos=split(nums,n,m)
    int quick_sort(nums,n,pos-1);
    int quick_sort(nums,pos+1,m)
  }
}

14.线性选择排序思维
·利用快速排序的思维去分区找到元素
线性选择,第三大需要几次分区
137,96,88,108,17,87,65,35,76,45,66,18
17,18,88,108,137,87,65,35,76,45,66,96
88,66,45,87,65,35,76,96,108,137
需要两次
15.选择排序思维
·
16.贪婪算法思维
·不断地从问题的 n 个元素中选取一个最优的元素的取值
·背包问题(可以分割),背包中可以放7个物体,背包载重量为20,有7个物体载重价值为12,7,5,19,20,18,13,物理重量分别为4,5,3,9,10,11,18.

17.狄斯奎诺算法思维

确定V1,根据V1去更新

根据权重最小的点V4去更新

根据权重第二小的点V2去更新

更新表之后,第三小的权重的点是V3去更新

根据权重确定V7的点去更新

根据权重确定V6的点去更新

根据权重确定V5的点去更新

18.克鲁斯卡尔算法思维
·选择边的权重最小的优先,但要避免有环


19.普利姆算法思维
·从一点触发,依次选取权值最小的路径,但选取的范围是经过的点的所有边,也要避免有环

20.霍夫曼编码思维

21.图遍历

22.动态规划
·货郎担问题

·最短路径问题

23.最长公共子序列
·
·背包问题:5个物体重量分别为2,2,6,5,4,价值分别为6,3,5,4,6,背包的载重量为10,求装入背包的物体及其总价值
·

posted @ 2021-07-06 00:38  网抑云黑胶SVIP用户  阅读(243)  评论(0编辑  收藏  举报