数据结构与算法基本思想

本文详细介绍了数据结构与算法的基础思想,涵盖了二分查找、八大排序算法(如快速排序、冒泡排序等)、二叉查找树、哈希表及其冲突处理、拓扑排序、动态规划、分治法、贪心算法等核心概念。通过对各个算法的原理、特点、代码实现的讲解,帮助读者深入理解这些基础算法。
摘要由CSDN通过智能技术生成

二分查找

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
            while i
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值