数据结构与算法基本思想

二分查找

java二分查找代码

/**
 * 不使用递归的二分查找
 *title:commonBinarySearch
 *@param arr
 *@param key
 *@return 关键字位置
 */
public static int commonBinarySearch(int[] arr,int key){
   
	int low = 0;
	int high = arr.length - 1;
	int middle = 0;			//定义middle
	
	if(key < arr[low] || key > arr[high] || low > high){
   
		return -1;				
	}
	
	while(low <= high){
   
		middle = (low + high) / 2;
		if(arr[middle] > key){
   
			//比关键字大则关键字在左区域
			high = middle - 1;
		}else if(arr[middle] < key){
   
			//比关键字小则关键字在右区域
			low = middle + 1;
		}else{
   
			return middle;
		}
	}
	
	return -1;		//最后仍然没有找到，则返回-1
}

python二分查找代码

def binary_search(lis, nun):
        left = 0
        right = len(lis) - 1
        while left <= right:   #循环条件
            mid = (left + right) // 2   #获取中间位置，数字的索引（序列前提是有序的）
            if num < lis[mid]:  #如果查询数字比中间数字小，那就去二分后的左边找，
                right = mid - 1   #来到左边后，需要将右变的边界换为mid-1
            elif num > lis[mid]:   #如果查询数字比中间数字大，那么去二分后的右边找
                left = mid + 1    #来到右边后，需要将左边的边界换为mid+1
            else:
                return mid  #如果查询数字刚好为中间值，返回该值得索引
        return -1  #如果循环结束，左边大于了右边，代表没有找到

    lis = [11, 32, 51, 21, 42, 9, 5, 6, 7, 8]
    print(lis)
    lis.sort()
    print(lis)
    while 1:
        num = int(input('输入要查找的数：'))
        res = binary_search(lis, num)
        print(res)
        if res == -1:
            print('未找到！')
        else:
            print('找到！')

八大排序

特点

①排序的平均时间复杂度？
②不稳定的排序有？
③排序的空间复杂度？
④其他特殊情况

①时间的复杂度：
o(log2n):快速排序，希尔排序，归并排序，堆排序（快些归队）,
特殊的为基数排序O(d(n+rd)),其他都是O(n2)
②不稳定的排序：快速排序，希尔排序，简单选择排序，堆排序（快些选对）
③空间复杂度：
归并排序O(n)，快速排序：o(log2n)，基数排序：O(rd)，其他都是O(1)
④其他特殊情况：
1.有序时：直接插入排序和冒泡排序时间复杂度为O(n)，快排为O(n2)

冒泡排序

基本思想：从“第一位”开始，相邻比较，把最值放到最后。如此循环

如果有 n 个数据，那么只需要比较 n–1 轮。而且除了第一轮之外，每轮都不用全部比较。因为经过前面轮次的比较
，已经比较过的轮次已经找到该轮次中最大的数并浮到右边了，所以右边的数不用比较也知道是大的。所以是n-1-i

java实现代码：

public static int[] bubbleSortOnce(){
   
        int[] num = nums;
        
         for(int i=0; i<num.length ;i++){
   
           for(int j =1 ; j < num.length -i; j++){
   
              if(num[j] < num[j-1] ){
   
                     int tmp = num[j];
                    num[j] = num[j-1];
                     num[j-1] = tmp;                    
                }
            }
  }  

python实现代码：

def mp(sz):
    for i in range(0,len(sz)):

        for j in range(0,len(sz)-1):
            if sz[j]>sz[j+1]:
                temp=sz[j]
                sz[j]=sz[j+1]
                sz[j+1]=temp

快速排序

基本思想：

• 从数列中挑出一个元素，称为 “基准”；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区操作；
• 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

java实现代码：

void Function(int a[],int low,int high){
   
	int i=low,j=high,temp;
	
	if(low<high){
   
		temp=a[low];//把第一位作为基准

		while(i<j){
   
			while(i<j&&a[j]>=temp){
   
				j--;
			}
			if(i<j){
   
				a[i]=a[j];
				i++;
			}

			while(i<j&&temp>a[i]){
   
				i++;
			}
			if(i<j){
   
				a[j]=a[i];
				j--;
			}
		}
		a[i]=temp;

		Function(a,low,i-1);
		Function(a,i+1,high);
	}
}

python实现代码：

def kp(a,low,high):
    i=low
    j=high
    if low<high:
        temp=a[low]
        while i<j:
            while i<j and a[j]>=temp:
                j=j-1
            if i<j:
                a[i]=a[j]
                i=i+1