python实现数据结构1.认识复杂度和简单排序算法

已于 2022-07-05 22:55:43 修改
阅读量523 收藏
点赞数
分类专栏： python数据结构 文章标签： 数据结构 排序算法 算法
于 2022-07-05 17:37:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycfxxr/article/details/125622584
版权

在这里插入图片描述
时间复杂度常数操作的指标
常数操作：和数据量无关，固定时间的东西
数组取值
±*/位运算

非常数操作：和数据量有关，时间不固定
链表取值

额外空间复杂度：只需要额外几个变量就可以完成就是O(1)，如果是数组，就是O(N)，加起来即可

时间复杂度：估计最差情况。常数操作数量表达式，不要低阶项，只要高阶项，不要高阶项的系数
相同时间复杂度，需要实际去跑去测试。
平均最好不需要理解
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

选择排序
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
异或运算：无进位相加
在这里插入图片描述
在这里插入图片描述
保证AB所指向的内存不是同一块内存

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

javacode

Code01_SelectionSort.java

package class01;

import java.util.Arrays;

public class Code01_SelectionSort {

	public static void selectionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			}
			swap(arr, i, minIndex);
		}
	}

	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			selectionSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		selectionSort(arr);
		printArray(arr);
	}

}

Code02_BubbleSort.java

package class01;

import java.util.Arrays;

public class Code02_BubbleSort {

	public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int e = arr.length - 1; e > 0; e--) {
			for (int i = 0; i < e; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(arr, i, i + 1);
				}
			}
		}
	}

	public static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] ^ arr[j];
		arr[j] = arr[i] ^ arr[j];
		arr[i] = arr[i] ^ arr[j];
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			bubbleSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		bubbleSort(arr);
		printArray(arr);
	}

}

Code03_InsertionSort.java

package class01;

import java.util.Arrays;

public class Code03_InsertionSort {

	public static void insertionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 1; i < arr.length; i++) {
			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
				swap(arr, j, j + 1);
			}
		}
	}

	public static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] ^ arr[j];
		arr[j] = arr[i] ^ arr[j];
		arr[i] = arr[i] ^ arr[j];
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			insertionSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		insertionSort(arr);
		printArray(arr);
	}

}

Code04_BSExist.java

package class01;

public class Code04_BSExist {

	public static boolean exist(int[] sortedArr, int num) {
		if (sortedArr == null || sortedArr.length == 0) {
			return false;
		}
		int L = 0;
		int R = sortedArr.length - 1;
		int mid = 0;
		while (L < R) {
			mid = L + ((R - L) >> 1);
			if (sortedArr[mid] == num) {
				return true;
			} else if (sortedArr[mid] > num) {
				R = mid - 1;
			} else {
				L = mid + 1;
			}
		}
		return sortedArr[L] == num;
	}

}

Code05_BSNearLeft.java

package class01;

public class Code05_BSNearLeft {

	// 在arr上，找满足>=value的最左位置
	public static int nearestIndex(int[] arr, int value) {
		int L = 0;
		int R = arr.length - 1;
		int index = -1;
		while (L < R) {
			int mid = L + ((R - L) >> 1);
			if (arr[mid] >= value) {
				index = mid;
				R = mid - 1;
			} else {
				L = mid + 1;
			}
		}
		return index;
	}

}

Code06_BSAwesome.java

Code07_EvenTimesOddTimes.java

package class01;

public class Code07_EvenTimesOddTimes {

	public static void printOddTimesNum1(int[] arr) {
		int eO = 0;
		for (int cur : arr) {
			eO ^= cur;
		}
		System.out.println(eO);
	}

	public static void printOddTimesNum2(int[] arr) {
		int eO = 0, eOhasOne = 0;
		for (int curNum : arr) {
			eO ^= curNum;
		}
		int rightOne = eO & (~eO + 1);
		for (int cur : arr) {
			if ((cur & rightOne) != 0) {
				eOhasOne ^= cur;
			}
		}
		System.out.println(eOhasOne + " " + (eO ^ eOhasOne));
	}

	public static void main(String[] args) {
		int a = 5;
		int b = 7;

		a = a ^ b;
		b = a ^ b;
		a = a ^ b;

		System.out.println(a);
		System.out.println(b);

		int[] arr1 = { 3, 3, 2, 3, 1, 1, 1, 3, 1, 1, 1 };
		printOddTimesNum1(arr1);

		int[] arr2 = { 4, 3, 4, 2, 2, 2, 4, 1, 1, 1, 3, 3, 1, 1, 1, 4, 2, 2 };
		printOddTimesNum2(arr2);

	}

}

Code08_GetMax.java

package class01;

public class Code08_GetMax {

	public static int getMax(int[] arr) {
		return process(arr, 0, arr.length - 1);
	}

	public static int process(int[] arr, int L, int R) {
		if (L == R) {
			return arr[L];
		}
		int mid = L + ((R - L) >> 1);
		int leftMax = process(arr, L, mid);
		int rightMax = process(arr, mid + 1, R);
		return Math.max(leftMax, rightMax);
	}

}

Code09_FindOneLessValueIndex.java

package class01;

public class Code09_FindOneLessValueIndex {

	public static int getLessIndex(int[] arr) {
		if (arr == null || arr.length == 0) {
			return -1; // no exist
		}
		if (arr.length == 1 || arr[0] < arr[1]) {
			return 0;
		}
		if (arr[arr.length - 1] < arr[arr.length - 2]) {
			return arr.length - 1;
		}
		int left = 1;
		int right = arr.length - 2;
		int mid = 0;
		while (left < right) {
			mid = (left + right) / 2;
			if (arr[mid] > arr[mid - 1]) {
				right = mid - 1;
			} else if (arr[mid] > arr[mid + 1]) {
				left = mid + 1;
			} else {
				return mid;
			}
		}
		return left;
	}

	public static void printArray(int[] arr) {
		for (int i = 0; i != arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int[] arr = { 6, 5, 3, 4, 6, 7, 8 };
		printArray(arr);
		int index = getLessIndex(arr);
		System.out.println("index: " + index + ", value: " + arr[index]);

	}

}
漫漫行程路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅析代码圈复杂度及认知复杂度
「 虚幻私塾」
01-26 692
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 写在开始 圈复杂度用来描述一段代码“可测性”很好（可测性这里指需要构建完善的覆盖全面的单元测试需要付出多少代价），但它的设计模型很难得出一个很好的“可读性&可维护性”的测量结果 新版soanrqube引入了认知复杂度的概念，这个复杂度指标弥补了圈复杂度的一些不足，能更准
数据结构(基于python实现)02-算法复杂度分析
python狗刨笔记
03-22 415
计算机基本的构造模块：数据结构和算法 所以提到数据结构，那么就不得不提算法。而如何评价一个算法的质量呢？ 第一个层次就是正确性、第二个层次就是可读性和易维护性、最后就是分析一个算法的复杂度 算法复杂度：1、空间复杂度 2、时间复杂度 1、空间复杂度： 空间复杂度的计算需要计算程序运行所需的资源，一个显著的评价标准就是程序运行时的内存使用量。 2、时间复杂度: 运行...
Python面试题-每周积累02
qq_42958642的博客
05-17 308
1.ascii、unicode、utf-8、gbk 区别？
2021-03-02
weixin_48800850的博客
03-02 84
二分法(四) 无序也能二分–局部最小值问题 public class Code04_BSAwesome { public static int oneMinIndex(int[] arr){ int N = arr.length; if (arr == null || N == 0){ return -1; } if (N == 1){ return 0; }
二分法（折半查找法）局部最小问题
Whynotwu的博客
06-13 447
局部最小问题，无序数组中找到一个局部最小即可 分为三种情况 0<1 小/ N-1>N \ \ 先降后升，中间必定存在局部最小 / 只要具有排他性的问题都可以用二分 public class Code07_BSAwesome { //局部最小问题，无序数组中找到一个局部最小即可 //arr是无序数组 public static int getLessIndex(int[]arr){ if(arr==null||arr.length=..
二分
weixin_34007291的博客
03-13 58
一、在数组中查找局部最小的数 思路：二分查找 代码: def getLessIndex(arr): if not arr: return -1 n = len(arr) if n == 1 or arr[0] < arr[1] : return 0 if arr[n-1] < ar...
【算法与数据结构1】认识时间复杂度和简单排序算法
weixin_50935299的博客
02-07 442
当两个时间复杂度一样时，直接跑程序对比 一、选择排序 算法思想：第一趟从n个元素的数据序列中选出关键字最小/大的元素并放在最前/后位置，下一趟从n-1个元素中选出最小/大的元素并放在最前/后位置。以此类推，经过n-1趟完成排序。 public static void seletionSort(int arr[]) { if(arr == null || arr.length<2) { return; }
利用Python实现数据结构常见的八大排序算法
02-20
以下是利用Python实现数据结构中常见的八大排序算法的知识点。 1. 直接插入排序：直接插入排序是一种简单的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置...
Python实现经典排序算法.rar
01-11
本资源"Python实现经典排序算法.rar"包含了一系列用Python编写的经典排序算法的源代码，这对于学习和理解排序算法的原理及其在Python中的实现极具价值。 首先，让我们来探讨一下排序算法的基本概念。排序算法是一种...
使用Python实现五大排序算法，算法数据结构
04-07
在IT领域，排序算法是数据处理和计算机科学的基础，它们被广泛应用于各种场景，如数据库管理、数据分析和算法设计。本文将详细介绍使用Python实现的五种常见排序算法：选择排序、冒泡排序、插入排序、分割排序（快速...
常见数据结构与算法的Python实现及学习笔记.zip
06-16
本资源包"常见数据结构与算法的Python实现及学习笔记.zip"聚焦于使用Python语言来阐述这些概念，这对于Python开发者或者正在学习Python的学生来说是一份宝贵的资源。下面，我们将深入探讨其中涵盖的一些关键知识点。...
Python 基础课程《17.数据结构与算法》
05-29
综上所述，本章节详细介绍了数据结构与算法的基本概念和常见类型，包括逻辑结构、物理结构、线性表（顺序表和链表）、栈与队列以及排序算法（冒泡排序和选择排序）。通过对这些基础知识的学习，可以帮助开发者更好地...
leetcode刷题前置知识总结，2021年Java开发进阶
m0_64867152的博客
12-16 466
public class Code04_BSExist { public static void main(String[] args) { int[] arr = {1, 2, 4, 6, 10, 20, 21, 33, 43, 54}; System.out.println(exist(arr, 55)); } public static boolean exist(int[] arr, int num) { if (arr == null || arr.length == 0) { return fa
时间复杂度为O(NlogN)的排序
m0_51706126的博客
10-29 395
认识时间复杂度为O(NlogN)的排序 剖析递归行为和递归行为时间复杂度的估算 用递归方法找一个数组中的最大值，系统上是怎么做的？ 求中点的时候一般不使用(L+R)/2，防止溢出。 public class Code08_GetMax { public static int getMax(int[] arr){ return process(arr, 0 , arr.length -1); } public static int process(int[] arr
leetcode刷题前置知识总结
codingToMaster的博客
09-19 432
认识二分法： 1)在一个有序数组中，找某个数是否存在 2)在一个有序数组中，找>=某个数最左侧的位置 3)在一个有序数组中，找<=某个数最右侧的位置 4)局部最小值问题 查找一个数是否存在： package com.zy.class001; public class Code04_BSExist { public static void main(String[] args) { int[] arr = {1, 2, 4, 6, 10, 20, 21, 3
算法基础01-复杂度、排序、二分、异或
weixin_42503072的博客
01-28 382
文章目录1 时间复杂度、空间复杂度、排序、异或运算1.1 时间复杂度1.1.1 排序操作1.1.1.1 选择排序1.1.1.2 冒泡排序1.1.1.3 插入排序1.2 空间复杂度1.3 常数项时间复杂度1.4 算法最优解1.5 常见时间复杂度1.6 算法和数据结构脉络1.7 认识对数器1.8 认识二分法1.9 认识异或运算 1 时间复杂度、空间复杂度、排序、异或运算 1.1 时间复杂度 常数时间操作： 算数运算：+ - * / 位运算：>>（带符号右移动）、 >>>（不带
局部最小值位置练习
njudongchen的博客
02-25 306
定义局部最小的概念。arr长度为1时，arr[0]是局部最小。arr的长度为N(N>1)时，如果arr[0]class Solution { public: int getLessIndex(vector<int> arr) { if(arr.empty()) return -1; if(arr.size()==1)
图解大顶堆的构建、排序过程
最新发布
sagima_sdu的博客
08-12 485
开始，
Python实现排序算法时间复杂度详解：冒泡、快速与堆排序
在"排序算法时间复杂度分析-信号生成及DFT的Python实现方式"这份课件中，主要探讨了排序算法在计算机科学中的重要性，特别是通过具体的算法示例来深入理解它们的内部工作原理。课程涵盖了以下关键知识点： 1. 冒泡...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值