【算法】数据结构面试算法题目

1 数组去重

python实现

#调用内置函数去重
def func(str):
	len1=len(str)
	len2=len(list(set(str)))
	print("去重后的结果是：",list(set(str)),"	去重个数是：",(len1-len2))
#for 循环去重
def func1(str):
	nums=[]
	for n in str:
		if n not in nums:
			nums.append(n)
	print("去重后的结果是：",sorted(nums),"	去重个数是：",(len(str)-len(nums)))
# while去重
def func2(str):
	len1=len(str)
	for n in str:
		while str.count(n)>1:
			del str[str.index(n)]
	print("去重后的结果是：",sorted(str),"	去重个数是：",(len1-len(str)))

str=[1,3,2,4,2,4,1,6,4,5]
func2(str)

字典去重

#调用内置函数去重
def func(str):
	len1=len(str.values())
	len2=len(list(set(str.values())))
	print("去重后的结果是：",list(set(str.values())),"	去重个数是：",(len1-len2))
#for 循环去重
def func1(str):
	nums=[]
	for n in str.values():
		if n not in nums:
			nums.append(n)
	print("去重后的结果是：",sorted(nums),"	去重个数是：",(len(str.values())-len(nums)))

str=[1,3,2,4,2,4,1,6,4,5]
dirc={1:1,2:2,3:3,4:3}
func2(dirc)

 python字符串追加去重排序

#调用内置函数去重
def func(str1,str2):
	print("去重后的结果是：",sorted(set(str1+str2)),"	去重个数是：",(len(str1+str2)-len(set(str1+str2))))

#for 循环去重
def func1(str1,str2):
	nums=[]
	str=str1+str2
	for n in str:
		if n not in nums:
			nums.append(n)
	print("去重后的结果是：",sorted(nums),"	去重个数是：",(len(str)-len(nums)))
# while去重
def func2(str1,str2):
	str=str1+str2
	for n in str:
		while str.count(n)>1:
			del str[str.index(n)]
	print("去重后的结果是：",sorted(str),"	去重个数是：",(len(str1+str2)-len(str)))

str1=['很好','不错','很好','Very','Book','I','Love','I']
str2=['Java','C#','Python','C#']
func2(str1,str2)

Java实现

import java.util.LinkedList;
import java.util.List;


public class func {
	public static void unique(String[] str){
		// array_unique  
	    List<String> list = new LinkedList<String>();  
	    for(int i = 0; i < str.length; i++) { 
	        if(!list.contains(str[i])) {  
	            list.add(String.valueOf(str[i]));  
	        }  
	    }  
	    System.out.print("去重后的结果："+list+"	 共去重个数："+(str.length-list.size()));
	}
	public static void main(String[] args){
		String[] str={"1","3","2","4","2","4","1","6","4","5"};
		unique(str);
	}

}

 set实现

import java.util.HashSet;
import java.util.Set;

public class func {
	public static void unique(String[] str){
		Set<String> set = new HashSet<String>();
        for (int i=0; i<str.length; i++) {
            set.add(str[i]);
        } 
	    System.out.print("去重后的结果："+set+"	 共去重个数："+(str.length-set.size()));
	}
	public static void main(String[] args){
		String[] str={"Python","SQL","C#","Java","C","Python","R","Matlab","C++","SQL"};
		unique(str);
	}
}

java字符串追加去重实现

/* package whatever; // don't place package name! */

import java.util.*;
import java.util.Set;
import java.util.HashSet;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	/**
	 * 两个数组合并去重
	 * 2016年11月5日12:43:34
	 * 白宁超
	 * str1   long[]  数组1
	 * str2   long[]  数组2
	*/
	public static void disstr(long[] str1,long[] str2 ){
		if(str1.length<=0||str2.length<=0){
			return;
		}
		long[] str= new long[str1.length+str2.length];  
        System.arraycopy(str1, 0, str, 0, str1.length);  
        System.arraycopy(str2, 0, str, str1.length, str2.length);
		Set<Long> set=new HashSet<Long>();
		for(int i=0;i<str.length;i++){
			set.add(str[i]);
		}
		System.out.print("追加去重后的数据是：	"+set+"
		去重个数：	"+(str.length-set.size()));
	}
	

	public static void main (String[] args) throws java.lang.Exception
	{
		long[] str1={10,20,30,50,10,60,40,20};
		long[] str2={50,60,90,80,70};
		disstr(str1,str2);
	}
}

2  求数组中逆序对的总数，如输入数组1,2,3,4,5，6，7,0  逆序对7

Python实现

# 求数组中逆序对的总数，如输入数组1,2,3,4,5，6，7,0  逆序对7
def index(str3):
	res=0
	if(len(str3)<0):	return 0
	if(len(str3)==0):	return str3[-1]
	else:
		for i in str3:
			if(str3[i]>str3[-1]):
				res+=1
	print(res)

str3=[1,2,3,4,5,6,7,0]
#func2(str1,str2)
index(str3)

Java实现

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	public static void func2(){
		int res=0;
		int[] str={1,2,3,4,5,6,7,0};
		for(int i=0;i<str.length;i++){
			for(int j=i;j<str.length;j++){
				if(str[i]>str[j]){
					res++;	
				}
			}
		}
		System.out.print(res);
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		func2();
	}
}

 3 无序数组A，找到第K个最大值，复杂度小于O（NlgN）

Python实现

方法一：时间复杂度set()*sorted（）的复杂度

# 无序数组A，找到第K个最大值，复杂度小于O（NlgN）
def Maxnum(str,n):
	if n>len(str) or n<0:
		print("输入不合法")
		return 0
	numArr=sorted(set(str))
	m=-n
	print(numArr[m])


str3=[1,2,3,4,5,6,7,0]
Maxnum(str3,30)

 方法二：时间复杂度O(n)+sorted（）复杂度

def Maxnum1(str,n):
	newstr=[]
	if n>len(str) or n<=0:
		print("输入不合法")
		return 0
	else:
		for i in str:
			if i not in newstr:
				newstr.append(i)
	print(sorted(newstr)[-n])

str3=[1,2,3,4,5,6,7,0]
Maxnum1(str3,1)

 方法三：时间复杂度O(nlogn)

def bnc_quick(arr,low,high):
	if low < high:
		key=arr[low]
		left=low
		right=high
		while low < high:
			while low < high and arr[high] >= key:
				high -= 1
			arr[low]=arr[high]
			while low < high and arr[low] <= key:
				low += 1
			arr[high]=arr[low]
		arr[low]=key
		bnc_quick(arr,left,low-1)
		bnc_quick(arr,low+1,right)
		
arr=[20,10,30,40,100,60,90,210]
print(arr)
bnc_quick(arr,0,len(arr)-1)
n=3
print(arr[-n])

 方法四：时间复杂度O（n）

from random import randint
def findKthMax(l,k):
	if k>len(l):
		return
	key=randint(0,len(l)-1)
	keyv=l[key]
	sl=[i for i in l[:key]+l[key+1:] if i<keyv]
	bl=[i for i in l[:key]+l[key+1:] if i>=keyv]
	if len(bl)==k-1:
		return keyv
	elif len(bl)>=k:
		return findKthMax(bl,k)
	else:
		return findKthMax(sl,k-len(bl)-1)

 方法五：时间复杂度O(n)

def base_quick(arr,low,high):
	if low < high:
		key=arr[low]
		left=low
		right=high
		while low < high:
			while low < high and arr[high] >= key:
				high -= 1
			arr[low]=arr[high]
			while low < high and arr[low] <= key:
				low += 1
			arr[high]=arr[low]
		arr[low]=key
		return low
		
def findmax(arr,k):
	length = len(arr)
	low = 0
	high = length - 1
	midkey = base_quick(arr, low, high)
	while midkey != k:
		if midkey > k:
			midkey = base_quick(arr, low, midkey - 1)
		elif midkey < k:
			midkey = base_quick(arr, midkey + 1, high)
	return arr[-k:]

Java实现

 方法一：时间复杂度O(NlgN)

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	public static void quickSort(int[] arr,int low,int hight){
		if(low < hight){
			int key=arr[low];
			int left=low;
			int right=hight;
			while(low < hight){
				while(low < hight&&arr[hight] >= key){
					hight--;
				}
				arr[low]=arr[hight];
				while(low <hight&&arr[low] <= key){
					low++;
				}
				arr[hight]=arr[low];
			}
			arr[low]=key;
			quickSort(arr,left,low-1);
			quickSort(arr,low+1,right);
		}
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		int[] arr={1,3,4,6,7,99,45,26};
		for(int i:arr){
			System.out.print(i+" ");
		}
		System.out.println("
**************************************");
		quickSort(arr,0,arr.length-1);
 		for(int i:arr){
			System.out.print(i+" ");
		}
		System.out.println("
**************************************");
		int k=3;
		for(int i=0;i<arr.length;i++){
			if(i==arr.length-k){
				System.out.print("
第"+k+"个最大数是："+arr[arr.length-k]);
			}
	
		System.out.println("
***************	}***********************");
		int n=3;
		System.out.print("前"+n+"个最大数是：
");
		for(int i=arr.length-1;i>=arr.length-n;i--){
			System.out.print(arr[i]+" ");
		}
	}
}

4 排序算法

Python实现冒泡排序

def buttle(arr):
	length = len(arr)
	for i in range(0,length):
		for j in range(i+1,length):
			if(arr[i]>arr[j]):
				arr[i],arr[j]=arr[j],arr[i]
	print(arr)
			
str3=[1,2,13,4,15,6,7,0]
buttle(str3)

Java实现冒泡排序

	public static void buttle(int[] arr){
		int temp=0;
		for(int i=0;i<arr.length;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					temp=arr[j];
					arr[j]=arr[i];
					arr[i]=temp;
				}
			}
		}
		for(int n:arr){
			System.out.print(n+" ");
		}
	}

Python实现快排：

def bnc_quick(arr,low,high):
	if low < high:
		key=arr[low]
		left=low
		right=high
		while low < high:
			while low < high and arr[high] >= key:
				high -= 1
			arr[low]=arr[high]
			while low < high and arr[low] <= key:
				low += 1
			arr[high]=arr[low]
		arr[low]=key
		bnc_quick(arr,left,low-1)
		bnc_quick(arr,low+1,right)
		
arr=[20,10,30,40,100,60,90,210]
print(arr)
bnc_quick(arr,0,len(arr)-1)
print(arr)

Java实现快排：

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	public static void quickSort(int[] arr,int low,int hight){
		if(low < hight){
			int key=arr[low];
			int left=low;
			int right=hight;
			while(low < hight){
				while(low < hight&&arr[hight] >= key){
					hight--;
				}
				arr[low]=arr[hight];
				while(low <hight&&arr[low] <= key){
					low++;
				}
				arr[hight]=arr[low];
			}
			arr[low]=key;
			quickSort(arr,left,low-1);
			quickSort(arr,low+1,right);
		}
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		int[] arr={1,3,4,6,7,99,45,26};
		for(int i:arr){
			System.out.print(i+" ");
		}
		System.out.println("
**************************************");
		quickSort(arr,0,arr.length-1);
 		for(int i:arr){
			System.out.print(i+" ");
		}
	}
}

简单选择排序：

def select(arr):
	for i in range(0,len(arr)):
		min=i
		for j in range(i+1,len(arr)):
			if arr[min] > arr[j]:
				min=j
		arr[min],arr[i]=arr[i],arr[min]
	return arr

5 不借助中间变量的两数字交换：

方法一：

    private static void swapBySelf(int a, int b) {  
        // 在不引入其它变量的情况下交换两个数，利用两数之和来做  
        a = a+b;   //a保存两数之和  
        b = a-b;    //两数之和-b，即为a  
        a = a-b;    //两数之和-b，此时的b已经变成了a，所以相当于sum-a=b  
    }

方法二：

        //还有另一种方法,利用两数之差，即两数之间的距离  
        a = b-a;   //a=两者的差  
        b = b-a;    //b = 原来的b-两数的距离==原来的a  
        a = a+b;    //最终的a=两者之差+原来的a==原来的b  
        System.out.println("swapBySelf second function:a="+a+",b="+b);//又换回来了  

方法三：

    //已知x^k^k==x，即一个数与任意一个数作两次异或运算都会变成原来的自己  
    private static void swapByXOR(int a, int b) {  
        // 在不引入其它变量的情况下交换两个数，利用异或来做  
        a = a^b;   //a保存两数异或的中间结果  
        b = a^b;    //a两次异或b就变成原来的a，并将其赋值给了b  
        a = a^b;    //b两次异或a就变成原来的b，并且将其赋值给了a  
        System.out.println("swapByXOR first function:a="+a+",b="+b);  
          
    }