排序和查找

简介: 排序和查找

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;
  }
}
}

 



相关文章
|
3月前
|
算法
【算法】二分查找——在排序数组中查找元素的第一个和最后一个位置
【算法】二分查找——在排序数组中查找元素的第一个和最后一个位置
|
3月前
|
算法 C++
查找方式:依次查找与二分查找
查找方式:依次查找与二分查找
|
6月前
查找数据
查找数据。
36 1
|
算法
查找
查找是指在图中寻找特定的节点或边的过程。在图中进行查找操作可以帮助我们找到与目标节点或边相关的信息,或者判断图中是否存在某个节点或边。 在图中进行查找操作的常见算法有: 1. 深度优先搜索(DFS):从图中的一个节点开始,沿着一条路径一直深入直到无法再深入为止,然后回溯到上一个节点,继续深入其他路径,直到找到目标节点或遍历完所有节点。 2. 广度优先搜索(BFS):从图中的一个节点开始,先访问它的所有邻居节点,然后再依次访问邻居的邻居节点,直到找到目标节点或遍历完所有节点。 3. Dijkstra算法:用于在带权有向图中找到从一个节点到其他节点的最短路径。该算法通过不断更新节点的最短距离来逐步
74 0
|
6月前
|
人工智能
数组排序,查找
数组排序,查找
|
算法
【算法专题突破】二分查找 - 在排序数组中查找元素的第一个和最后一个位置(17)
【算法专题突破】二分查找 - 在排序数组中查找元素的第一个和最后一个位置(17)
63 0
|
算法 C语言 C++
【二分查找】34. 在排序数组中查找元素的第一个和最后一个位置
二分查找是一种高效的查找算法,其时间复杂度为 O(log n)。在许多情况下,我们需要在一个有序数组中找到某个目标值的搜索范围。本文将介绍一种基于二分查找的搜索范围查找算法,该算法能够快速找到目标值在数组中的起始和结束位置。
73 0
|
存储 算法 索引
【数据结构】先排序后查找的查找
【数据结构】先排序后查找的查找
67 0
|
Java
Java数组、排序和查找
Java数组、排序和查找
79 0