high

3 月，跳不动了？>>> 1、思想 每次选出一个基准，然后将数组剩下的元素分为两部分，一部分小于基准放到左边，一部分大于基准放到右边。然后对基准左右两部分分别做同样处理，分治思想。 2、时间复杂度 最快 O(nlogn) ，最坏 O (n^2) ，平均 O(nlogn) 。 3、代码实现 //常规版 public class quickSort { public static void QuickSort(int[] arr){ QSort(arr, 0, arr.length-1); } private static void QSort(int[] arr, int low, int hight) { int pivot; if(low < hight){ pivot = Partition(arr, low, hight); QSort(arr, low, pivot-1); QSort(arr, pivot+1, hight); } } private static int Partition(int[] arr, int low, int hight) { if(arr == null || low < 0 || hight >= arr.length){ new Exception(); } int pivotkey = arr[low]; while(low <

排序 稳定排序和不稳定排序 假设Ri=Rj(0<=i,j<=n-1,i≠j)，且在排序前的序列中Ri领先于Rj(即i<j)，若在排序后的序列中Ri仍领先于Rj，则称所用的排序方法是稳定的，否则是不稳定的。 内部排序：待排序记录存放在内存 外部排序：排序过程中需对外存进行访问的排序 插入排序：直接插入排序、折半插入排序、希尔排序、表插入排序 交换排序：起泡排序、快速排序 选择排序：简单选择排序、堆排序 归并排序：2-路归并排序 分配排序 插入排序 直接插入排序 上面的过程很直观，挺简单的，对我来说比较好理解 //我自己写了一种，还有一种都是一样的，后面那种对理解shell排序比较有帮助 void straisort ( int r [ ] , int n ) { int i , j , k ; for ( i = 2 ; i <= n ; i ++ ) { r [ 0 ] = r [ i ] ; j = i - 1 ; for ( k = 1 ; k <= j ; k ++ ) { if ( r [ 0 ] < r [ k ] ) r [ k + 1 ] = r [ k ] ; else { r [ k + 1 ] = r [ 0 ] ; break ; } } } } void straisort ( int r [ ] , int n ) { int i , j ; for (

快速排序的时间复杂度是O(NlogN) 算法描述 先从序列中取出一个数作为基准数 分区过程, 将比这个数大的数全部放到它的右边, 小于或等于它的数全部放到它的左边 再对左右区间重复第二步, 直到各区间只有一个数 假设对 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 进行排序, 首先在这个序列中随便找一个基准数(用来参照), 比如选择 6 为基准数, 接下来把所有比基准数大的数放在6的右边, 比6小的数放在左边 原理分析: 选择最左边的数为基准数key 设立两个游标 low 和 high , 分别指向数组的最低位和最高位 然后high先动, 如果high位上的数比key大, 则向前走, 如果high-1位上的数比key大, 继续向前走, 直到该位上的数<=key 此时比较low位, 如果<=key, low向后走, 变为low+1, 依次类推, 直到该位上的数比key大 交换high和low位上的数 重复以上步骤, 直到low=high , 交换 key 和 high 位上的值 最后进行递归操作 #!/usr/bin/env python # coding:utf-8 # 设置最低位和最高位 def quickSort(nums, low, high): # 设置一个比较基准key key = nums[low] while low<high: # 如果最高位的数

1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <string.h> 4 5 #define ARRAY_SIZE 10 6 7 int binarySearch(int *arr, int size, int target) 8 { 9 int low = 0; 10 int high = size - 1; 11 while (low < high) 12 { 13 int mid = low + (high - low) / 2; 14 //当low+high超过整数范围会发生溢出，变为负数 15 //int mid = (low + high) / 2; 16 if (arr[mid] < target) 17 { 18 low = mid + 1; 19 } 20 else if (arr[mid] > target) 21 { 22 high = mid - 1; 23 } 24 else 25 { 26 return mid; 27 } 28 } 29 return -1; 30 } 31 int main(int argc, char **argv) 32 { 33 int array_unsort[ARRAY_SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 34 int

二分查找（binary-search）是一种算法，输入是一个有序的元素列表（仅当列表是有序的时候，二分查找才管用）。若查找的元素包含在列表中，二分查找返回其位置，否则返回null。 1.查找的范围 low = 0 high = len(list) -1 2.检查中间的元素 mid = (low + high)/2 # 如果（low + high）是奇数，python自动将mid向下圆整 guess =list[mid] #猜的数字小了，修改low if guess < item: low = mid +1 #猜的数字大了，修改high if guess > item: high = mid -1 3. 完整代码如下: def binary_search(list,item): low = 0 high = len(list)-1 while low <= high: mid = int((low + high)/2) guess = list[mid] if guess == item: return mid elif guess > item: high = mid -1 else: low = mid +1 return None my_list= [1,3,5,7,9] print(binary_search(my_list,3)) print(binary_search

先看一段示例代码: public class TestMain { public static void main ( String [ ] args ) { Integer a = 66 ; Integer b = 66 ; System . out . println ( "a等于b:" + ( a == b ) ) ; //结果是true Integer c = 166 ; Integer d = 166 ; System . out . println ( "c等于d:" + ( c == d ) ) ; //结果是false } } 为什么会是这样的结果，以上代码看上去只是单纯的赋值，所以我们反汇编看下，底层是否有调用什么方法，而我们却不知道。 以上是部分反汇编后的代码，可以看到反汇编的第一行的66，和我们代码第三行对应，反汇编的第二行则调用的是Integer.valueOf()的方法，对66这个数字进行自动装箱。从这里也可以猜到自动装箱和拆箱在底层是怎么实现的了，其实最后还是调用相应方法来做类型的转换。 所以接下来看 Integer . valueOf ()方法的源码: public static Integer valueOf ( int i ) { //这里做了一个比较，如果在这个范围内的数值，则取IntegerCache里的值，否则新建Integer对象 if (

本文用python3实现了二分查找算法，分别使用递归方法和非递归方法。 （一）递归实现 def binarySearch(s, k): return binarySearch_c(s, 0, len(s) - 1, k) def binarySearch_c(s, low, high, k): if low > high: return -1 mid = low + (high - low) // 2 if s[mid] == k: return mid elif s[mid] > k: return binarySearch_c(s, low, mid - 1, k) else: return binarySearch_c(s, mid + 1, high, k) for _ in range(int(input())): s = list(map(int, input().split())) k = int(input()) print(binarySearch(s, k)) （二）非递归实现 def binarySearch(s, k): low = 0 high = len(s) - 1 while low <= high: mid = low + (high - low) // 2 if s[mid] == k: return mid elif s[mid] > k:

二分查找算法： 用于在有序数组中快速查找所需要的值，前提是数组已经排序 python代码实现： def binary_search ( thelist , item ) : low = 0 high = len ( thelist ) - 1 while low <= high : mid = int ( ( low + high ) / 2 ) if thelist [ mid ] == item : return mid elif thelist [ mid ] < item : low = mid + 1 else : high = mid - 1 return None 验证算法： l = [ 1 , 2 , 4 , 8 , 9 , 10 ] print ( "the index of result: " + str ( binary_search ( l , 8 ) ) ) l = [ 1 , 2 , 4 , 8 , 9 , 10 ] print ( "the index of result: " + str ( binary_search ( l , 12 ) ) ) 来源： CSDN 作者： Robot647 链接： https://blog.csdn.net/m0_46245938/article/details/104133746

[267] High Five Client 00 SendLogOut 01 RequestAttack 03 RequestStartPledgeWar 04 RequestReplyStartPledgeWar 05 RequestStopPledgeWar 06 RequestReplyStopPledgeWar 07 RequestSurrenderPledgeWar 08 RequestReplySurrenderPledgeWar 09 RequestSetPledgeCrest 0B RequestGiveNickName 0C RequestCharacterCreate 0D RequestCharacterDelete 0E SendProtocolVersion 0F MoveBackwardToLocation 10 Say 11 RequestEnterWorld 12 RequestGameStart 13 RequestNewCharacter 14 RequestItemList 15 RequestEquipItem 16 RequestUnEquipItem 17 RequestDropItem 19 RequestUseItem 1A RequestTrade 1B RequestAddTradeItem 1C TradeDone 1F

快速排序 时间复杂度： O(N * log2 N) 最坏情况下： O (N ^ 2） 空间复杂度： O(log2 N) 代码示例： （1）递归实现快速排序 public static void quickSort ( int [ ] array ) { quick ( array , 0 , array . length - 1 ) ; } public static void quick ( int [ ] array , int low , int high ) { int par = partion ( array , low , high ) ; if ( par > low + 1 ) { quick ( array , low , par - 1 ) ; } if ( par < high - 1 ) { quick ( array , par + 1 , high ) ; } } //找基准 public static int partion ( int [ ] array , int low , int high ) { int tmp = array [ low ] ; while ( low < high ) { while ( low < high && array [ high ] >= tmp ) { high -- ; } if ( low >=