面试中常见的查找与排序

• 二分查找（折半查找），它仅适应于有序的顺序表
  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;
    }
    }​​