0
点赞
收藏
分享

微信扫一扫

Linux系统中，`buffer`和`cache` 区别

洒在心头的阳光 2024-08-01 阅读 23
排序算法数据结构java
加载失败

目录


排序

排序的概念：

排序稳定性：

也就是说如果两元素相同排序前啥位置排序后还是啥位置该排序就稳定，反之不稳定。

内排序：

外排序：

常见排序如下图：

以下排序都是实现从小到大。

冒泡排序

实现思路：

  1. 外循环实现比较趟数。
  2. 内循环实现从末尾找到最小值向前排。

如此每一趟都可以将一个最小值排在前面。

代码已优化点：

  1. 使用了一个falg标记，如果该趟没有交换证明数组已经有序，直接结束。
  2. 使用j > i作为第二层循环的结束条件而不是j > 0减少了循环次数。

时间复杂度：O(N^2) 。
空间复杂度：O(1)。
稳定性：稳定。

public void bubbleSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;
            for (int j = array.length - 1; j > i; j--) {
                if(array[j] < array[j - 1]){
                	//交换
                    int tmp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = tmp;
                    
                    flag = true;
                }
            }
            if(!flag){
                break;
            }
        }
    }

选择排序

实现思路：

  1. 外循环控制每次最小值放入的位置。
  2. 内循环找到当前的最小值下标。
  3. 出内循环将最小值与当前应放入位置交换。
    每一次都可以挑选一个最小值出来。与冒泡排序有相似之处，但是冒泡相邻比较交换，选择排序是每次交换最小值。

时间复杂度：O(N^2)。
空间复杂度：O(1)。
稳定性：不稳定。

	// 选择排序
    public void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
            }
            int tmp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = tmp;
        }
    }

实现思路2：

  1. 我们选择时可以将最小值下标和最大值下标一同记录下来。
  2. 已升序为例，将最小值放在前面，最大值放在后面，但是我们要注意如果最大值是左边要换的元素，那在前面换了后要将最大值下标更换为交换后的下标。
//选择排序
    private void selectSort2(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
            int minIndex = left;
            int maxIndex = left;
            
            for(int j = left + 1;j <= right; j++){
                if(nums[j] < nums[minIndex]){
                    minIndex = j;
                }
                if(nums[j] > nums[maxIndex]){
                    maxIndex = j;
                }
            } 
            swap(nums,minIndex,left);
            //排除最大值在走边被换走了
            if(maxIndex == left){
                maxIndex = minIndex;
            }
            swap(nums,maxIndex,right);
            left++;
            right--;
        }
    }

直接插入排序

实现思路：

  1. 外部使用循环控制当前填入前方有序数组的值tmp。
  2. 内部循环从当前前一个下标开始往回遍历，遇到比tmp大的值就往后覆盖，否则就出循环（因为前面已经是有序的了）。
  3. 最后一定要将 j+1 下标置为tmp（因为出第二层循环时要么为-1要么当前j下标值小于等于tmp）。

时间复杂度：O(N^2)。
空间复杂度：O(1)。
稳定性：稳定。

//直接插入排序
public void insertSort(int[] array){
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

希尔排序

实现思路：

  1. 在希尔排序中循环调用修改后的直接插入排序。
  2. gap代表增量，相当于 i 下标与 i + gap * n下标的值为一组。
  3. 对每组进行直接插入排序。

时间复杂度：O(n^1.3 )至 O( n^1.5)之间。
空间复杂度：O(1)。
稳定性：不稳定。

        // 希尔排序
    public void shellSort(int[] array){
            int gap = array.length;
            while(gap > 1){
                gap /= 2;
                shell(array,gap);
            }
    }

    private void shell(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for (; j >= 0; j -= gap) {
                if(array[j] > tmp){
                    array[j+gap] = array[j];
                }else{
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

堆排序

实现思路：

  1. 根据排序需求（升序实现大根堆，降序实现小根堆），实现堆。
  2. 每次将堆顶元素放末尾，将剩余元素再变为堆。

实现堆的描述

时间复杂度：O(N*logN)。
空间复杂度：O(1)。
稳定性：不稳定。

// 堆排序
    public static void heapSort(int[] array) {
        createHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            siftDown(array,0,end);
            end--;
        }
    }
    //实现大根堆
    private static void createHeap(int[] array) {
        for (int parent = (array.length-1-1)/2; parent >= 0; parent--) {
            siftDown(array,parent,array.length);
        }

    }
    private static void siftDown(int[] array, int parent, int length) {
        int child = 2 * parent + 1;
        while (child < length) {
            if(child + 1 < length && array[child] < array[child+1]) {
                child++;
            }
            if(array[child] > array[parent]) {
                swap(array, parent, child);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }
    //交换函数
    private static void swap(int[] array, int x, int y) {
        int tmp = array[x];
        array[x] = array[y];
        array[y] = tmp;
    }

归并排序

实现思路：

  1. 分解逻辑：将递归结束条件变为左下标大于右下标达到每个子序列只有1个元素。
  2. 合并逻辑：因为两个子序列本身是有序的了，只要将两个序列从左到右的最小值依次放入临时数组，最后有一个数组剩余元素直接放入即可。（注意临时数组返回给目标数组时开头不是0下标开始）

时间复杂度：O(N*logN)。
空间复杂度：O(N)。
稳定性：稳定。

	//归并排序
     public void mergeSort(int[] nums) {
        mergeSortSplit(nums,0,nums.length - 1);
     }
     private void mergeSortSplit(int[] nums, int left, int right) {
        if(left >= right){
            return;
        }
        //分解
        int mid = (left + right) / 2;
        mergeSortSplit(nums,left,mid);
        mergeSortSplit(nums,mid+1,right);
        //合并
        merge(nums,left,mid,right);
     }
     private void merge(int[] nums, int left, int mid, int right) {
        int[] tmp = new int[right - left + 1];
        int tmpIndex = 0;
        int leftIndex = left;
        int rightIndex = mid + 1;
        while(leftIndex <= mid && rightIndex <= right){
            if(nums[leftIndex] < nums[rightIndex]){
                tmp[tmpIndex++] = nums[leftIndex++];
            }else {
                tmp[tmpIndex++] = nums[rightIndex++];
            }
        }

归并排序非递归实现

实现思路：

  1. 我们使用1个gap来代表每个待合并子序列的长度。
  2. 在通过gap计算出左右边界和中间值，要限制右边界和中间值不要越界。
  3. 再合并即可。
	//归并排序非递归实现
      private void mergeSortNor(int[] nums) {
        int gap = 1;
        while(gap < nums.length) {
            for(int i = 0; i < nums.length; i = i + gap * 2) {
                int left = i;
                int mid = left + gap - 1;
                int right = mid + gap;
                if(mid >= nums.length) {
                    mid = nums.length - 1;
                }
                if(right >= nums.length) {
                    right = nums.length - 1;
                }
                merge(nums,left,mid,right);
            }
            gap *= 2;
        }
      }

快速排序

还有一种解释：

按基准划分左右的3种方法

  1. Hoare法：选定序列第一个为基准，从后边往前找到比基准小的停下来，从前边找到比基准大的停下来，交换直到左右相遇，相遇下标的值与基准交换。
    代码实现如下：返回基准下标。
 private int partition(int[] nums, int left, int right){
        int tmp = nums[left];
        int start = left;
        while(left < right){
            while(left < right && nums[left] <= tmp){
                left++;
            }
            while(left < right && nums[right] >= tmp){
                right--;
            }
            swap(nums,left,right);
        }
        //先找左边就要判断该值是不是比基准大，先从右边找就不用。
        if(left > 0 && nums[left] >= nums[start]){
            swap(nums,left - 1,start);
            return left - 1;
        }
        swap(nums,left,start);
        return left;
    }
  1. 挖坑法：选定序列第一个为基准，先将基准值记录下来，再先从后面找到比基准小的，将其放入基准位置，再先从前面找到比基准大的，将其放入先前后面找到的比基准小的位置，在从后找放入前面比基准大的位置，循环往复直到左右相遇，将先前记录下来的基准位置放入相遇位置。
    代码实现如下：
private int partitionDig(int[] nums,int left, int right){
        int tmp = nums[left];
        while(left < right){
            while(left < right && nums[right] >= tmp){
                right--;
            }
            nums[left] = nums[right];
            while(left < right && nums[left] <= tmp){
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = tmp;
        return left;
    }
  1. 前后指针：选定序列第一个为基准，初始prev指针指向序列开头，cur指向prev下一个位置，
    然后判断cur指针指向的数据是否小于基准，
    若小于并且prev后一位不是cur则prev后移一位，并将cur与prev内容交换，然后cur后移一位，
    若大于，则只要cur后移一位。
private int partitionTwoPoint(int[] nums, int left, int right){
        int prev = left; 
        int cur = prev + 1;
        while(cur <= right){
            if(nums[cur] < nums[left] && nums[++prev] != nums[cur]){
                swap(nums,cur,prev);
            }
            cur++;
        }
        swap(nums,prev,left);
        return prev;
    }

快排实现

时间复杂度：O(N*logN)至O(n^2)。
空间复杂度：O(logN)至O(N)。
稳定性：不稳定。

	//快速排序
	public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }

    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        int pivot = partition(array,start,end);
        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }
    private int partitionDig(int[] nums,int left, int right){
        int tmp = nums[left];
        while(left < right){
            while(left < right && nums[right] >= tmp){
                right--;
            }
            nums[left] = nums[right];
            while(left < right && nums[left] <= tmp){
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = tmp;
        return left;
    }

快排优化

  1. 三数取中法优化：在选基准时我们不是都固定选的第一个为基准吗，而现在我们就是选择头尾和中间三个位置的中间数来放入第一位作为基准。如此可以保证每次都可以有两个分支不是单分支往下"递归"。
    以挖坑法代码举例：
	private int partitionDig(int[] nums,int left, int right){
		swap(nums,middle(nums,left,right),left);
        int tmp = nums[left];
        while(left < right){
            while(left < right && nums[right] >= tmp){
                right--;
            }
            nums[left] = nums[right];
            while(left < right && nums[left] <= tmp){
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = tmp;
        return left;
    }
    //返回中间值的下标
    private int middle(int[] nums, int left, int right){
    	int mid = (left + right) / 2;
    	if(nums[left] < nums[right]){
    		if(nums[mid] < nums[left]) return left;
    		if(nums[mid] > nums[right]) return right;
    		return mid;
    	} else{
    		if(nums[mid] < nums[right]) return right;
    		if(nums[mid] > nums[left]) return left;
    		return mid;
    	}
    }
  1. 递归到小的子区间时，使用直接插入排序，因为直接插入排序的特点就是越有序越快。
    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        if(end - statrt >= 10){
        	insertSortRange(array,start,end);
        	return;
        }
        int pivot = partition(array,start,end);
        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }
    public void insertSortRange(int[] array, int start, int end){
        for (int i = start + 1; i <= end; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

快排非递归实现

实现思路：

  1. 先求得基准下标。
  2. 将子序列左右边界依次入栈，注意当子序列只有一个元素时不入。
  3. 再出栈两个元素拿到子序列的边界在调用基准划分方法，再进行第二步。
	//快排非递归实现
    private void quickNor(int[] nums, int left, int right) {
        Stack<Integer> stack = new Stack<>();
        int pivot = partitionDig(nums,left,right);
        if(pivot > left + 1){
            stack.push(left);
            stack.push(pivot - 1);
        }
        if(pivot < right - 1){
            stack.push(pivot + 1);
            stack.push(right);
        }
        while(!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            
            pivot = partitionDig(nums,left,right);
            if(pivot > left + 1){
                stack.push(left);
                stack.push(pivot - 1);
            }
            if(pivot < right - 1){
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }

总结

对上面7种基于比较的排序算法进行总结：
稳定的排序只有3种：冒泡排序，直接插入排序，归并排序。
时间复杂度由大到小就是目录的顺序。


该图不是我总结的

基于非比较的排序

计数排序

实现原理：

  1. 先求的待排序数组的最大值和最小值，计数数组的长度就是二者差值加1。
  2. 将遇到待排序数组元素对应的计数数组下标元素（即待排序数组元素减去最小值作为计数数组下标）加1。
  3. 最后遍历计数数组返回下标加最小值存储到待排序数组中，直到计数数组元素全为0。

时间复杂度：O( Max(N，范围) )。
空间复杂度：O(范围)。
稳定性：稳定。
范围就是指计数数组长度。

	//计数排序
    private void countSort(int[] nums){
        int max = nums[0];
        int min = nums[0];
        //求得计数数组长度
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] > max) {
                max = nums[i];
            }
            if(nums[i] < min) {
                min = nums[i];
            }
        }
        //计数数组存储
        int[] countNums = new int[max - min + 1];
        for(int i = 0; i < nums.length; i++) {
            countNums[nums[i] - min]++;
        }
        int numsIndex = 0;
        //排序
        for(int i = 0; i < countNums.length; i++) {
            while(countNums[i] > 0) {
                nums[numsIndex++] = i + min;
                countNums[i]--;
            }
        }
    }
举报

相关推荐

Linux 内存 buffer 和 cache 的区别

cachebufferlinux存储聊天OpenStack云计算

Linux buffer/cache

swift开发语言ios

Linux 操作系统原理 — 内存 — Cache 和 Buffer

缓存数据linuxLinux系统/运维

cache和buffer

数据缓存字段Linux系统/运维

Cache与buffer的区别

数据物理内存应用程序虚拟化云计算

linux swap buffer cache

创建文件高并发访问量Linux系统/运维

Linux buffer/cache解读

内存数据缓存块设备编程语言

Linux page cache与buffer cache优化

内存缓存数据文件系统Java编程语言

【Linux】buffer cache free 理解

数据缓存字符串Linux系统/运维

缓存cache和缓冲buffer的区别

linuxjava
0 条评论
加载失败