Java&python基础算法编码

1、两个有序数组合并成一个数组，要求合并后的数组依然是有序的

//python代码如下：
li = [1,2,4,6,9]
li2 = [3,4,7,14,16]
li_com = []
i=0
j=0
while i<li.__len__() and  j<li2.__len__():
    if li[i]<li2[j]:
        li_com.append(li[i])
        i += 1
    else:
        li_com.append(li2[j])
        j += 1
while i<li.__len__():
    li_com.append(li[i])
    i += 1
while j<li2.__len__():
    li_com.append(li2[j])
    j += 1
print(li_com)

//Java代码如下
public class CombinList {
	public static void main(String[] args) {
		int [] num1 = {2,6,8,10,12};
		int [] num2 = {1,3,7,13,15,17};
		int [] result = new int[num1.length+num2.length];
		
		int i=0,j=0,k =0;
		while(i<num1.length&&j<num2.length){
			if(num1[i]<num2[j]){
				result[k++]=num1[i++];
			}else{
				result[k++]=num2[j++];
			}
		}
		while(i<num1.length){
			result[k++]=num1[i++];
		}
		while(j<num2.length){
			result[k++]=num2[j++];
			
		}
		for(int m = 0;m<result.length;m++){
			System.out.print(result[m]+" ");
		}
	}

}

2、计算数组中每个数字出现的次数

//python代码
li = [1,2,3,4,5,6,4,3,7,8,2,1]
dic = {}
for i in li:
    if i in dic.keys():
        dic[i] += 1
    else:
        dic[i] =1
print(dic)

//Java代码
import java.util.*;
import java.util.Map.Entry;

public class CalNum {

	public static void main(String[] args) {
		int [] arr = {1,2,3,4,2,3,6,9,6,7};
		Map <Integer,Integer> cal= new HashMap<Integer, Integer>();
		for(int i = 0;i<arr.length;i++){
			if(cal.get(arr[i])==null){
				cal.put(arr[i], 1);
				}
			else{
				cal.put(arr[i], cal.get(arr[i])+1);
			}
		}
		Set<Entry<Integer, Integer>> en_set = cal.entrySet();
		for(Entry<Integer, Integer>ent:en_set){
			System.out.println(ent.getKey()+"----------"+ent.getValue());
		}
		  }
}

3、斐波那契数列

//python代码
#非递归算法
arr = [1,2]
index = 2
while index < 5:
    arr.append(arr[index-1]+arr[index-2])
    index += 1
print(arr)

#递归算法
def func_feibonaqi(num):
   if num >2:
       return func_feibonaqi(num-1)+func_feibonaqi(num-2)
   if num == 1:
       return 1
   if num == 2:
       return 2
print(func_feibonaqi(5))

//Java代码
public class Feibonaqi {
	public static void main(String[] args) {
		Feibonaqi f = new Feibonaqi();
		//递归算法
		int temp = f.feibonaqi(9);
		System.out.println(temp);
		//非递归算法
		int num[] = new int[51];
	    num[1]=1;
		num[2]=1;
		for(int i =3;i<=50;i++){
			num[i]=num[i-1]+num[i-2];
		}
		System.out.println(num[9]);
		
	}
	
	public int feibonaqi(int num){
		if(num>2){
			return feibonaqi(num-1)+feibonaqi(num-2);
		}if(num ==1){
			return 1;
		}
		if(num==2){
			return 2;
		}
		
	}

}

4、插入排序

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列

//python代码
li = [8,3,6,1,90,9,10,5,7]
i = 1
while i<li.__len__():
    j = i
    while j>0:
        if li[j]>li[j-1]:
            tem = li[j]
            li[j]=li[j-1]
            li[j-1]=tem
        j -=1
    i += 1
print(li)

//Java代码
public class InsertSort {
	public static void main(String[] args) {
		int [] a = {7,9,3,5,8,4,1,8,1,5};
        for(int i = 1;i<a.length;i++){
			for(int j = i;j>0;j--){
				if(a[j]>a[j-1]){
					int tem = a[j];
					a[j]=a[j-1];
					a[j-1]=tem;
				}
				
			}
		}
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]);
		}
	}

}

5、冒泡排序

比较相邻的元素，如果第一个比第二个大，就交换他们的位置；对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，最后的元素应该会是最大的数

#python代码
li = [5,3,8,12,678,34,4,9,8]
i=li.__len__()-1
while i>0:
    j = 0
    while j<i:
        if li[j]>=li[j+1]:
            tem = li[j]
            li[j]=li[j+1]
            li[j+1]=tem
        j +=1
    i -= 1

print(li)

//Java代码
public class MaopaoSort {
	public static void main(String[] args) {
		int [] a = {7,9,3,5,8,4};
		boolean flag;
		for(int i = a.length-1;i>=0;i--){
			flag=true;
			for(int j = 0;j<i;j++){
				if(a[j]>a[j+1]){
					int tem = a[j+1];
				    a[j+1]=a[j];
				    a[j]=tem;
				    flag = false;
				}
			}
			
			if(flag){
				break;
			}
			for(int k = 0;k<a.length;k++){
				System.out.print(a[k]);
			}
			System.out.println();
		}
	}

}

6、二分查找
利用二分查找的前提是数组是已经排好序的

#python代码
def halfSearch(num):
    li = [1,4,7,9,12,34,67,345,2345]
    low = 0
    high = li.__len__()-1
    while low <= high:
        mid = (low+high)//2
        if li[mid] == num:
            return mid
        if li[mid] > num:
            high = mid-1
        if li[mid] < num:
            low = mid+1
        return None
i = halfSearch(12)
if i!= None:
    print("已经查找到结果，下标为：",i)

//Java代码
public boolean search(int [] ar,int num){
		int low = 0;
		int high = ar.length-1;
		int mid=(low+high)/2;;
		while(low<=high){
			 mid = (low+high)/2;
			//System.out.println(mid);
			if(ar[mid]<num){
				low = mid+1;
			}
			if(ar[mid]>num){
				high=mid-1;
			}
			if(ar[mid] == num){
				System.out.println(mid);
				return true ;
			}
		}
		return false;
	}

7、快速排序

设要排序的数组是A[0].....A[N-1]，首先任意选取一个数据（通常选作数组的第一个数）作为关键数据，然后将所有比他小额数都放在他的前面，所有比他大的数据都放到他的后面，这个过程通常称作为一趟快速排序