排序和查找

简介: 排序和查找

1.快排 (不稳定)

https://blog.csdn.net/IT_ZJYANG/article/details/53406764

public static void main(String[] args) {
    int[] x = {3, 5, 1, 0, 2, 7, 6, 7, 9};
    quicSort(x, 0, x.length - 1);
    System.out.printf(Arrays.toString(x));
}
public static void quicSort(int[] a, int start, int end) {
    if (start > end) {
        //如果只有一个元素,就不用再排下去了
        return;
    } else {
        //如果不止一个元素,继续划分两边递归排序下去
        int partition = divide(a, start, end);
        quicSort(a, start, partition - 1);
        quicSort(a, partition + 1, end);
    }
}
public static int divide(int[] a, int start, int end) {
    //每次都以最右边的元素作为基准值
    int base = a[end];
    //start一旦等于end,就说明左右两个指针合并到了同一位置,可以结束此轮循环。
    while (start < end) {
        while (start < end && a[start] <= base)
            //从左边开始遍历,如果比基准值小,就继续向右走
            start++;
        //上面的while循环结束时,就说明当前的a[start]的值比基准值大,应与基准值进行交换
        if (start < end) {
            //交换
            int temp = a[start];
            a[start] = a[end];
            a[end] = temp;
            //交换后,此时的那个被调换的值也同时调到了正确的位置(基准值右边),因此右边也要同时向前移动一位
            end--;
        }
        while (start < end && a[end] >= base)
            //从右边开始遍历,如果比基准值大,就继续向左走
            end--;
        //上面的while循环结束时,就说明当前的a[end]的值比基准值小,应与基准值进行交换
        if (start < end) {
            //交换
            int temp = a[start];
            a[start] = a[end];
            a[end] = temp;
            //交换后,此时的那个被调换的值也同时调到了正确的位置(基准值左边),因此左边也要同时向后移动一位
            start++;
        }
    }
    //这里返回start或者end皆可,此时的start和end都为基准值所在的位置
    return end;
}

2.冒泡排序(稳定)

public static void bubbleSort(int[] arr) {
    //一定要记住判断边界条件,很多人不注意这些细节,面试官看到你的代码的时候都懒得往下看,你的代码哪个项目敢往里面加?
    if (arr == null || arr.length < 2) {
        return;
    }
    //需要进行arr.length趟比较
    for (int i = 0; i < arr.length - 1; i++) {
        //第i趟比较
        for (int j = 0; j < arr.length - i - 1; j++) {
            //开始进行比较,如果arr[j]比arr[j+1]的值大,那就交换位置
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

3.选择排序(不稳定)

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

4.堆排序

https://www.cnblogs.com/neuzk/p/9476419.html

 

 

二分查找

public static int binSearch(int[] a,int e){
int low=0;
int high=a.length-1;
while(low<=high){
  int mid=(low+high)/2;
  if(a[mid]==e){
      return mid;
  }else if(a[mid]
      low=mid+1;
  }else{
      high=mid-1;
  }
}
}

 



相关文章
|
4月前
|
算法
【算法】二分查找——在排序数组中查找元素的第一个和最后一个位置
【算法】二分查找——在排序数组中查找元素的第一个和最后一个位置
|
4月前
|
算法 C++
查找方式:依次查找与二分查找
查找方式:依次查找与二分查找
|
算法
【算法专题突破】二分查找 - 在排序数组中查找元素的第一个和最后一个位置(17)
【算法专题突破】二分查找 - 在排序数组中查找元素的第一个和最后一个位置(17)
72 0
|
算法 C语言 C++
【二分查找】34. 在排序数组中查找元素的第一个和最后一个位置
二分查找是一种高效的查找算法,其时间复杂度为 O(log n)。在许多情况下,我们需要在一个有序数组中找到某个目标值的搜索范围。本文将介绍一种基于二分查找的搜索范围查找算法,该算法能够快速找到目标值在数组中的起始和结束位置。
81 0
|
存储 算法 索引
【数据结构】先排序后查找的查找
【数据结构】先排序后查找的查找
71 0
|
Java
Java数组、排序和查找
Java数组、排序和查找
84 0
|
存储 算法
查找-之有序表查找
待查找的表是有序排列的
102 0
查找-之有序表查找
|
算法 Python
Leedcode升序序列查找元素位置
Leedcode升序序列查找元素位置
79 0
Leedcode升序序列查找元素位置
LeetCode (二分小专题)33搜索旋转排序数组&34在排序数组中查找元素的第一个和最后一个位置&35搜索插入位置
二分查找我想大家都很熟悉,二分查找每次判断并比较元素所在区间进行压缩,每次都可以压缩一半的区间,所以压到1个大小把它你想来看就是(最坏)扩散了n次到达原始长度。
107 0
LeetCode (二分小专题)33搜索旋转排序数组&34在排序数组中查找元素的第一个和最后一个位置&35搜索插入位置

热门文章

最新文章