递归

有一由小到大排列的数组m[],数组大小为n,请用二分法查找算法找出与关键数key相等的元素，若查找成功返回元素在数组中的位置，没找到返回-1. 1 // 二分查找.cpp 2 3 #include "stdafx.h" 4 #include <string> 5 6 int search(int m[],int key,int low,int high) 7 { 8 int mid=(low+high)/2; 9 if (low>high) 10 return -1; 11 if (key==m[mid]) 12 return mid; 13 else if (key<m[mid]) 14 return search(m,key,low,mid-1); 15 else 16 return search(m,key,mid+1,high); 17 } 18 19 void main() 20 { 21 int a[]={1,2,5,7,9,12,16}; 22 int i,len; 23 len=sizeof(a)/sizeof(a[0])-1; 24 i=search(a,12,0,len); 25 printf("%d\n",i); 26 } 来源： https://www.cnblogs.com/xingele0917/archive/2012/10/04/2711628

题目描述 计算给定二叉树的所有左叶子之和。 思路分析 递归终止的条件是什么？一次递归中要进行什么操作？递归想要返回什么信息？ 基于前序递归模板。 终止条件：节点为空 递归中操作：为左叶节点时，将节点值计入sum 可以用基础的前序模板，定义全局变量sum； 也可以将前序模板返回值改成int，则递归想要返回信息就是 左右子树的左叶节点和 + 当前左叶节点和。 代码实现 private int sum = 0 ; public int sumOfLeftLeaves ( TreeNode root ) { if ( root == null ) { return 0 ; } process ( root , false ) ; return sum ; } public void process ( TreeNode root , boolean flag ) { if ( root == null ) { return ; } if ( flag && root . left == null && root . right == null ) { sum += root . val ; } process ( root . left , true ) ; process ( root . right , false ) ; } public static int process (

链接： https://www.nowcoder.com/discuss/112192 目录 1.手撕代码，二分查找，递归非递归 2.java反射机制，优点缺点 3.java线程同步，synchronized锁升级机制，synchronized lock区别 4.项目，感觉最难的一点，怎么解决之类的 5.看成绩单，问我成绩为什么比较差 6.java public private protected default 7.手撕代码，中序遍历，递归非递归 8.学校的一堆事，什么社团经历，最有成就感的事，最失败的事，优点缺点啥的 1.手撕代码，二分查找，递归非递归 采用非递归方式完成二分算法 public static int binarySearch(Integer[] srcArray,int des){ int low=0; int high=srcArray.length-1; while(low<=high){ int middle=(low+high); if(des==srcArray[middle]) return middle; else if(des<srcArray[middle]){ high=middle-1; }else{ low=middle+1; } } return -1; } 采用递归方式完成二分查找算法 int BinSearch(int Array[

闭包 闭包的作用 递归 浅拷贝和深拷贝 正则表达式 正则表达式的特点 创建正则表达式 测试正则表达式test 边界符 字符类 量词符 来源： oschina 链接： https://my.oschina.net/u/4454049/blog/3189026

public static void main ( String [ ] args ) { File file = new File ( "文件夹路径" ) ; long length = method ( file ) ; System . out . println ( length ) ; } public static long method ( File file ) { File [ ] files = file . listFiles ( ) ; long l = 0 ; for ( File f : files ) { if ( f . isFile ( ) ) { l += f . length ( ) ; } else { l += method ( f ) ; } } return l ; } 来源： CSDN 作者： qq_43973203 链接： https://blog.csdn.net/qq_43973203/article/details/104693282

#include <stdio.h> #include <stdlib.h> //quick sort void QuickSort(int r[], int first, int end) { if(first >= end) return; int mid = (first + end) / 2, i = first, j = end, x,temp; x = r[mid]; while(1) { while(r[i] < x) i++; while(r[j] > x) j–; if(i >= j) break; temp = r[i]; r[i] = r[j]; r[j] = temp; } QuickSort(r,first, j - 1); QuickSort(r,j + 1, end); return ; } void ShowArray(int r[], int first, int end) { int i; for (i = first; i <= end; i++) printf("%d “, r[i]); printf(”\n"); } int main() { int n, s, t; int r[20]; scanf("%d", &n); for (int i = 1; i <= n; i++) scanf("%d", &r[i]); s = 1, t =

快速排序(QuickSort) 划分的关键是要求出基准记录所在的位置pivotpos,编程时候的关键点 快速排序： 既然能把冒泡KO掉，马上就激起我们的兴趣，tnd快排咋这么快，一定要好好研究一下。 首先上图： 从图中我们可以看到： left指针，right指针，base参照数。 其实思想是蛮简单的，就是通过第一遍的遍历（让left和right指针重合）来找到数组的切割点。 第一步：首先我们从数组的left位置取出该数（20）作为基准（base）参照物。 第二步：从数组的right位置向前找，一直找到比（base）小的数， 如果找到，将此数赋给left位置（也就是将10赋给20）， 此时数组为：10，40，50，10，60， left和right指针分别为前后的10。 第三步：从数组的left位置向后找，一直找到比（base）大的数， 如果找到，将此数赋给right的位置（也就是40赋给10）， 此时数组为：10，40，50，40，60， left和right指针分别为前后的40。 第四步：重复“第二,第三“步骤，直到left和right指针重合， 最后将（base）插入到40的位置， 此时数组值为： 10，20，50，40，60，至此完成一次排序。 第五步：此时20已经潜入到数组的内部，20的左侧一组数都比20小，20的右侧作为一组数都比20大， 以20为切入点对左右两边数按照

　　这次自己写了一下 　　总结起来就是： 　　归并排序递归和非递归形式是逆过程。 　　两者有的地方是一样的，不一样的地方是： 　　递归是递归拆分成一小段一小段的排序，同时是把A拆成A1 A2，先把A1整个排好，再排A2，最后达到排好整个A的目的。 　　非递归是序列从左往右先按等分的长度(i)逐个排好，长度不够i的在末尾，于是对它排一次序，然后让i两倍递增。 #include <stdio.h> #include <string.h> #include <stdlib.h> #define MAX 1000 #define OK 1 #define ERROR 0 using namespace std; typedef struct { int t[MAX]; int a[MAX]; int length; }ma; void LoadList(ma &m) { int i; for(i=0;i<m.length;i++) printf("%d ",m.t[i]); printf("\n"); } void merge(ma &m,int x,int y,int mid) { int i,p,q; p=x,q=mid,i=x; while(p<mid || q<y) { if(q>=y || (p<mid && m.t[p]<=m.t[q])) m.a[i++]=m.t[p++];

本文同步发布在CSDN： https://blog.csdn.net/weixin_44385565/article/details/94588321 归并排序的基本操作是将两个有序数组合并成一个有序数组，原理是运用分治思想，递归地将一个数组的左右两部分有序数列进行归并。 C/C++的递归实现： 1 // mergeSort.cpp : 递归写法 2 // 3 4 #include <stdio.h> 5 #include <stdlib.h> 6 #define elementType int//自定义数据类型 7 using namespace std; 8 9 void mergeSort(elementType A[], int N);//N为数组大小，统一函数接口 10 void mSort(elementType A[], elementType tmpA[], int L, int rightEnd);//传入左右边界 11 void merge(elementType A[], elementType tmpA[], int L, int R, int rightEnd);//将有序的两个部分进行归并 12 13 14 int main() 15 { 16 int N;//数组大小 17 scanf("%d", &N); 18 elementType* A =

思想：利用的还是分治思想，只不过这次我们把数组以2的倍数划分，然后进行两两合并，划分代码如下： public static void merge(int[] arr){ for(int i = 1;i<arr.length;i *= 2){ mergeSort(arr,i); } } 合并代码如下： public static void mergeSort(int[] arr, int gap) { int[] tmp = new int[arr.length]; int index = 0; int start1 = 0; int end1 = start1 + gap - 1; int start2 = end1 + 1; int end2 = (start2 + gap - 1)>=arr.length?arr.length-1:start2+gap-1; while(start2<arr.length){ while(start1<=end1&&start2<=end2){ if(arr[start1]<arr[start2]){ tmp[index++] = arr[start1++]; }else{ tmp[index++] = arr[start2++]; } } while(start1<=end1){ tmp[index++] = arr[start1++]; }