面试中常见的查找与排序

二分查找（折半查找），它仅适应于有序的顺序表
public static int binSearch(int nums[],int des){
int low = 0;
int high = nums.length -1;
int middle = 0;
while(low<=high){
middle=(low+high)/2;
if(nums[middle]==des)
return middle;
else if(nums[middle]>des)
high = middle-1;
else
low = middle+1;
}
return -1;
}
插入排序（直接插入排序时间复杂度O(n*2)，折半排序O(n*2)，希尔排序最坏的情况的情况O(n*2））
- 直接插入排序
  基本思想：
  　　把n个待排序的元素看成一个有序表和一个无序表，开始时有序表中只有一个元素，无序表中有n-1个元素；排序过程即每次从无序表中取出第一个元素，将它插入到有序表中，使之成为新的有序表，重复n-1次完成整个排序过程。
  　实例：
  　　0.初始状态 3，1，5，7，2，4，9，6（共8个数）
  　　   有序表：3；无序表：1，5，7，2，4，9，6
  　　1.第一次循环，从无序表中取出第一个数 1，把它插入到有序表中，使新的数列依旧有序
  　　   有序表：1，3；无序表：5，7，2，4，9，6
  　　2.第二次循环，从无序表中取出第一个数 5，把它插入到有序表中，使新的数列依旧有序
  　　   有序表：1，3，5；无序表：7，2，4，9，6
  　　3.第三次循环，从无序表中取出第一个数 7，把它插入到有序表中，使新的数列依旧有序
  　　   有序表：1，3，5，7；无序表：2，4，9，6
  　　4.第四次循环，从无序表中取出第一个数 2，把它插入到有序表中，使新的数列依旧有序
  　　   有序表：1，2，3，5，7；无序表：4，9，6
  　　5.第五次循环，从无序表中取出第一个数 4，把它插入到有序表中，使新的数列依旧有序
  　　   有序表：1，2，3，4，5，7；无序表：9，6
  　　6.第六次循环，从无序表中取出第一个数 9，把它插入到有序表中，使新的数列依旧有序
  　　   有序表：1，2，3，4，5，7，9；无序表：6
  　　7.第七次循环，从无序表中取出第一个数 6，把它插入到有序表中，使新的数列依旧有序
  　　   有序表：1，2，3，4，5，6，7，9；无序表：（空）
  代码：public static void insertSort(int[] a){
  int n = a.length;
  int i,j;
  for(i=1;i<n;i++){
  //temp为本次循环待插入有序列表中的数
  int temp=a[i];
  //寻找temp插入有序列表的正确位置
  for(j=i-1;j>=0 &&a[j]>temp;j--){
  //元素后移，为插入temp做准备
  a[j+1]=a[j];
  }
  //插入temp
  a[j+1]=temp;
  }
  }
- 折半排序
  基本思想：
  　　折半插入算法是对直接插入排序算法的改进，排序原理同直接插入算法：
  　　把n个待排序的元素看成一个有序表和一个无序表，开始时有序表中只有一个元素，无序表中有n-1个元素；排序过程即每次从无序表中取出第一个元素，将它插入到有序表中，使之成为新的有序表，重复n-1次完成整个排序过程。
  　　与直接插入算法的区别在于：在有序表中寻找待排序数据的正确位置时，使用了折半查找/二分查找。、
  public static void binaryInsertSort(int[] a){
  int n = a.length;
  int i,j;
  for(i=1;i<n;i++){
  //temp为本次循环待插入有序列表中的数
  int temp = a[i];
  int low = 0;
  int high = i-1;
  //寻找temp插入有序表的正确位置，使用二分查找法
  while (low<=high) {
  int mid = (low + high) / 2;
  if (a[mid] > temp) {
  high = mid - 1;
  } else {
  low = mid + 1;
  }
  }
  for(j=i-1;j>=low;j--){
  //元素后移，为插入temp做准备
  a[j+1]=a[j];
  }
  //插入temp
  a[low]=temp;
  }
  }
- 希尔排序
  基本思想：
  　　希尔排序的实质就是分组插入排序，又称缩小增量法。
  　　将整个无序序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序时，再对全体元素进行一次直接插入排序。
  　　因为直接插入排序在元素基本有序的情况下，效率是很高的，因此希尔排序在时间效率上有很大提高。
  　实例：
  　　无序序列：int a[] = {3,1,5,7,2,4,9,6};
  　　第一趟时： n=8; gap=n/2=4; 把整个序列共分成了4个子序列{3，2}、{1，4}、{5，9}、{7，6}
  　　第二趟时：gap=gap/2=2; 把整个序列共分成了2个子序列{2，5，3，9}、{1，6，4，7}
  　　第三趟时：对整个序列进行直接插入排序
  
  　　希尔排序是不稳定的
  private void shellSort2(int[] a){
  int n=a.length;
  int i,j,k,gap;
  for(gap=n/2;gap>0;gap/=2){
  for(i=0;i<gap;i++){
  for(j=i+gap;j<n;j+=gap){
  int temp = a[j];
  for(k=j-gap;k>=0 && a[k]>temp;k-=gap){
  a[k+gap]=a[k];
  }
  a[k+gap]=temp;
  }
  }
  
  }
  }
交换排序（冒泡排序时间复杂度O(n*2）,快速排序最好是O(log(n+1))向上取整，最坏是O(n*2)，平均情况为O(nlog(n))
- 冒泡排序
  基本思想：
  　　在要排序的一组数中，对当前还未排好序的范围内的全部数据，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的数往上冒。即依次比较相邻的两个数，若发现它们的排序与排序要求相反时，就将它们互。
  　实例：
  　　待排序数组 int a[] = {49,38,65,97,76,13,27,32};
  　　共 N=8 个数据，需要 N-1=7 趟排序，第 i 趟排序共比较 N-i 次
  　　每趟排序都会找出一个待排序数据中的较大值
  
  　　第一趟排序：
  　　　　第1次比较调整：49和38比较，49>38，交换位置：　　38 49 65 97 76 13 27 32
  　　　　第2次比较调整：49和65比较，49<65，不交换位置：　38 49 65 97 76 13 27 32
  　　　　第3次比较调整：65和97比较，65<97，不交换位置：　38 49 65 97 76 13 27 32
  　　　　第4次比较调整：97和76比较，97>76，交换位置：　　38 49 65 76 97 13 27 32
  　　　　第5次比较调整：97和13比较，97>13，交换位置：　　38 49 65 76 13 97 27 32
  　　　　第6次比较调整：97和27比较，97>27，交换位置：　　38 49 65 76 13 27 97 32
  　　　　第7次比较调整：97和32比较，97>32，交换位置：　　38 49 65 76 13 27 32 97
  　　第二趟排序：
  　　　　第1次比较调整：38和49比较，38<49，不交换位置：　38 49 65 76 13 27 32 97
  　　　　第2次比较调整：49和65比较，49<65，不交换位置：　38 49 65 76 13 27 32 97
  　　　　第3次比较调整：65和76比较，65<76，不交换位置：　38 49 65 76 13 27 32 97
  　　　　第4次比较调整：76和13比较，76>13，交换位置：　　38 49 65 13 76 27 32 97
  　　　　第5次比较调整：76和27比较，76>27，交换位置：　　38 49 65 13 27 76 32 97
  　　　　第6次比较调整：76和32比较，76>32，交换位置：　　38 49 65 13 27 32 76 97
  　　第三趟排序：
  　　　　第1次比较调整：38和49比较，38<49，不交换位置：　38 49 65 13 27 32 76 97
  　　　　第2次比较调整：49和65比较，49<65，不交换位置：　38 49 65 13 27 32 76 97
  　　　　第3次比较调整：65和13比较，65>13，交换位置：　　38 49 13 65 27 32 76 97
  　　　　第4次比较调整：65和27比较，65>27，交换位置：　　38 49 13 27 65 32 76 97
  　　　　第5次比较调整：65和32比较，65>32，交换位置：　　38 49 13 27 32 65 76 97
  　　第四趟排序：
  　　　　第1次比较调整：38和49比较，38<49，不交换位置：　38 49 13 27 32 65 76 97
  　　　　第2次比较调整：49和13比较，49>13，交换位置：　　38 13 49 27 32 65 76 97
  　　　　第3次比较调整：49和27比较，49>76，不交换位置：　38 13 27 49 32 65 76 97
  　　　　第4次比较调整：49和32比较，49>32，交换位置：　　38 13 27 32 49 65 76 97
  　　第五趟排序：
  　　　　第1次比较调整：38和13比较，38>13，交换位置：　　13 38 27 32 49 65 76 97
  　　　　第2次比较调整：38和27比较，38>27，交换位置：　　13 27 38 32 49 65 76 97
  　　　　第3次比较调整：38和32比较，38>32，交换位置：　　13 27 32 38 49 65 76 97
  　　第六趟排序：
  　　　　第1次比较调整：13和27比较，13<27，不交换位置：　13 27 32 38 49 65 76 97
  　　　　第2次比较调整：27和32比较，27<32，不交换位置：　13 27 32 38 49 65 76 97
  　　第七趟排序：
  　　　　第1次比较调整：13和27比较，13<27，不交换位置：　13 27 32 38 49 65 76 97
  　Java实现：
  public static void bubbleSort(int []a){
  int n =a.length;
  for(int i=0;i<n;i++){
  for(int j=i+1;j<n;j++){
  if(a[i]>a[j]){
  int temp=a[i];
  a[i]=a[j];
  a[j]=temp;
  }
  }
  }
  }
- 快速排序
  基本思想：
  　　通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
  　　1.设置 low=0, high=N-1。
  　　2.选择一个基准元素赋值给temp,即temp=a[low]。
  　　3.从high开始向前搜索，即由后开始向前搜索（high--），找到第一个小于temp的值，将a[high]和a[low]交换。
  　　4.从low开始向前后搜索，即由前开始向后搜索（low++），找到第一个大于temp的值，将a[high]和a[low]交换。
  　　5.重复第3步和第4步，直到 low==high ,3,4步中，若没找到符合条件的值，执行 high-- 或 low++ ，直到找到为止。进行交换时 low和high的位置不变。当low==high时循环结束。
  Java实现：
  public static int getMiddle(int[]numbers,int low,int high){
  int temp = numbers[low];//数组的第一个作为中轴
  while (low<high){
  while (low<high && numbers[high]>temp){
  high--;
  }
  numbers[low]=numbers[high];//比中轴小的记录移到低端
  while (low<high &&numbers[low]<temp){
  low++;
  }
  numbers[high]=numbers[low];//比中轴大的记录移到高端
  }
  numbers[low]=temp;//中轴记录到尾
  return low;//返回中轴的位置
  }
  public static void quickSort(int[]numbers,int low,int high){
  if(low<high){
  int middle = getMiddle(numbers,low,high);//对numbers数组进行一分为二
  quickSort(numbers,low,middle-1);//对低字段进行递归排序
  quickSort(numbers,middle+1,high);//对高字段进行递归排序
  }
  }
选择排序
- 简单选择排序
  算法思想：每趟初始默认设定待排序数列中的第一个元素为最小（或最大）的元素；
  将其与后面的元素逐一进行比较，若其大于（或小于）某一元素，则将这一元素记为最小（或最大）的元素，并按此方式继续向后比较；
  当所有元素都比较过后，最终记录的元素即为该趟排序中最小（或最大）的元素，将其与待排序数列中的第一个元素交换位置；
  去除起始位置排序完成的元素，将包含剩余元素的待排序数列按上述步骤进行排序；
  执行(n-1)趟后，所有元素排序完成。
  Java实现：
  public void sort(int[] arr){
  //需要执行的趟次(n-1)
  for(int i =0;i<arr.length-1;i++){
  //默认设置起始位置为最小
  int min=i;
  //将当前最小的元素与后面的元素逐一比较
  for(int j=i+1;j<arr.length;j++){
  //若当前最小元素大于后面的元素，将后面的元素设为最小
  if(arr[min]>arr[j]){
  min=j;
  }
  }
  //将最小的元素交换到起始位置
  int temp=arr[i];
  arr[i]=arr[min];
  arr[min]=temp;
  }
  }

面试中常见的查找与排序相关推荐

c++ 查找 list中最长的字符串_查找不重复字符的最长子字符串（编程面试中常见题-用8种编程语言来回答）...
查找不重复字符的最长子字符串(编程面试中常见题-用8种编程语言来回答) 给定一个字符串str,找到不重复字符的最长子字符串. 比如我们有 "ABDEFGABEF", 最长的字符串是 ...
数据结构 - 二叉树 - 面试中常见的二叉树算法题
数据结构 - 二叉树 - 面试中常见的二叉树算法题数据结构是面试中必定考查的知识点,面试者需要掌握几种经典的数据结构:线性表(数组.链表).栈与队列.树(二叉树.二叉查找树.平衡二叉树.红黑树).图 ...
数据结构 - 链表 - 面试中常见的链表算法题
数据结构 - 链表 - 面试中常见的链表算法题数据结构是面试中必定考查的知识点,面试者需要掌握几种经典的数据结构:线性表(数组.链表).栈与队列.树(二叉树.二叉查找树.平衡二叉树.红黑树).图. ...
校招面试中常见的算法题整理【长文】
⭐️我叫恒心,一名喜欢书写博客的研究生在读生. 原创不易~转载麻烦注明出处,并告知作者,谢谢!!! 这是一篇近期会不断更新的博客欧~~~ 有什么问题的小伙伴欢迎留言提问欧. 文章目录前言一.链表 ...
linux运维培训后面试,Linux运维岗位面试中常见的面试问题汇总
今天小编要跟大家分享的文章是关于Linux运维岗位面试中常见的面试问题汇总.正准备参加Linux运维面试的小伙伴们来和小编一起看一看吧,希望本篇文章能够对正在从事Linux运维工作的小伙伴们有所帮助. ...
JavaScript 面试中常见算法问题详解
JavaScript 面试中常见算法问题详解,翻译自 https://github.com/kennymkchan/interview-questions-in-javascript.下文提到的很多问 ...
java面试技术问题_11个JAVA面试中常见技术问题
原标题:11个JAVA面试中常见技术问题大家在平常面试java的过程中都会遇到哪些难题呢?还有一些即将去面试java的童鞋们,你们想知道技术面试中会涉及到哪些点吗?达妹为你整理Java面试中会被问到 ...
Java面试中常见的高并发解决方案
Java面试中常见的高并发解决方案一般来讲,提高系统应对高并发能力的解决方案可以从以下几个方面入手: (1)高性能服务器 (2)高性能数据库 (3)高效编程语言 (4)高性能web容器提高数据库性 ...
前端面试中常见的算法问题
虽说我们很多时候前端很少有机会接触到算法.大多都交互性的操作,然而从各大公司面试来看,算法依旧是考察的一方面.实际上学习数据结构与算法对于工程师去理解和分析问题都是有帮助的.如果将来当我们面对较为复杂 ...

面试中常见的查找与排序

面试中常见的查找与排序相关推荐

最新文章

热门文章