数据结构--＞排序

最新推荐文章于 2024-06-11 15:32:47 发布
最新推荐文章于 2024-06-11 15:32:47 发布
阅读量45 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 排序算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74812898/article/details/134037798
版权

1.排序

1.1 稳定性

举例:

注:一个本身就稳定的排序,可以实现不稳定,但是一个不稳定的排序,不能实现稳定.

1.2 常见的排序算法

2.常见排序算法的实现

2.1 插入排序

2.1.1 基本思想

  • 把待排序的数据按其大小逐个插入到一个已经排好序的有序序列中，直到所有的数据插入完为止，得到 一个新的有序序列  (就像玩扑克牌一样,把接下来接的牌,插入到已经排好序的扑克牌中,直到所有的牌插入完为止)

2.1.2 直接插入排序

/**
     * 时间复杂度：
     *  最好情况下：O(n)  ->  数据有序的情况下  1 2 3 4 5
     *  最坏情况下：O(n^2) -> 数据逆序的情况下  5 4 3 2 1
     * 空间复杂度：O(1)
     * 稳定性：稳定的排序
     * 当数据越有序的时候  直接插入排序的效率越高
     */
    public static 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 {
                    //array[j+1] = tmp;
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

2.1.3 希尔排序(缩小增量排序) 

实际上是跳跃式分组:

    //每组进行直接插入排序
    private static 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 {
                    //array[j+gap] = tmp;
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

    /**
     * 时间复杂度：O(n^1.25 - n^1.5)  -> n^1.3
     * 空间复杂度：O(1)
     * 稳定性：不稳定排序
     */
    public static void shellSort(int[] array) {
        int gap = array.length;//7
        while (gap > 1) {
            gap /= 2;//1
            shell(array,gap);
        }
        //shell(array,1);
    }

2.2 选择排序

2.2.1 基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

2.2.2 直接选择排序

 /**
     * 选择排序
     * 时间复杂度：O(n^2) 不管你本身的数据 是有序还是无序  都是这个复杂度
     * 空间复杂度：O(1)
     * 稳定性：不稳定的排序
     * @param array
     */
    public static 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;
                }
            }
            swap(array,minIndex,i);
        }
    }

    private static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

 

public static void selectSort2(int[] array) {
        int left = 0;
        int right = array.length-1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = left;
            for (int i = left+1; i <= right; i++) {
                if(array[i] < array[minIndex]) {
                    minIndex = i;
                }
                if(array[i] > array[maxIndex]) {
                    maxIndex = i;
                }
            }
            swap(array,minIndex,left);
            if(maxIndex == left) {
                maxIndex = minIndex;
            }
            swap(array,maxIndex,right);
            left++;
            right--;
        }
    }
    private static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

2.2.3 堆排序

/**
     * 堆排序
     * 时间复杂度：O(n*logn)  对数据不敏感  不管有序无序都是这个表达式
     * 空间复杂度：O(1)
     * 稳定性：不稳定
     * @param array
     */
    public static void heapSort(int[] array) {
        createBigHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,end,0);
            siftDown(array,0,end);
            end--;
        }
    }

    private static void createBigHeap(int[] array) {
        for (int i = (array.length-1-1) / 2; i >= 0 ; i--) {
            siftDown(array,i,array.length);
        }
    }

    private static void siftDown(int[] array,int parent,int len) {
        int child = 2*parent+1;
        while (child < len) {
            if(child+1 < len && array[child] < array[child+1]) {
                child++;
            }
            if(array[child] > array[parent]) {
                swap(array,child,parent);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

    private static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

2.3 交换排序

2.3.1 基本思想

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置

交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

2.3.2 冒泡排序

/**
     * 冒泡排序
     * 时间复杂度：O(N^2) 对数据不敏感  有序 无序都是这个复杂度！
     * 空间负责度：O(1)
     * 稳定性：稳定的排序
     *     插入排序   冒泡排序
     *
     * 加了优化之后，时间复杂度可能会变成O(n)
     * @param array
     */
    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if(!flg) {
                break;
            }
        }
    }

2.3.3 快速排序

2.3.3.1 Hoare版

/**
     * hoare法
     */
    private static int parttion(int[] array,int left,int right) {
        int i = left;//记录这个位置
        int tmp = array[left];
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            //todo: 先检查前面的会不会有问题
            while (left < right && array[left] <= tmp) {
                left++;
            }
            swap(array,left,right);
        }
        swap(array,left,i);
        return left;
    }
    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }

        int pivot = parttion(array,start,end);

        quick(array,start,pivot-1);//左树

        quick(array,pivot+1,end);//右树
    }
    /**
     * 时间复杂度：
     * O(n*logN)[最好情况了]   O(N^2)[数据是有序的 或者是逆序的 ]
     * 空间复杂度：O(logN)[好的情况]  O(n) [不好的情况]
     * 稳定性：不稳定排序
     */
    public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }
2.3.3.2 挖坑法

 /**
     * 挖坑法
     */
    private static int parttion(int[] array,int left,int right) {
        int tmp = array[left];
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            array[left] = array[right];
            //todo: 先检查前面的会不会有问题
            while (left < right && array[left] <= tmp) {
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }

        int pivot = parttion(array,start,end);

        quick(array,start,pivot-1);//左树

        quick(array,pivot+1,end);//右树
    }

    /**
     * 时间复杂度：
     *     O(n*logN)[最好情况了]   O(N^2)[数据是有序的 或者是逆序的 ]
     *
     * 空间复杂度：O(logN)[好的情况]  O(n) [不好的情况]
     * 稳定性：不稳定排序
     * @param array
     */
    public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }
2.3.3.3 前后指针

看着代码理解即可

private static int partition(int[] array, int left, int right) {
    int prev = left ;
    int cur = left+1;
    while (cur <= right) {
        if(array[cur] < array[left] && array[++prev] != array[cur]) {
            swap(array,cur,prev);
        }
        cur++;
    }
    swap(array,prev,left);
    return prev;
}

2.3.4 快速排序优化

2.3.4.1 三数取中法选key


 /**
     * 三数取中法
     * @param array
     * @param left
     * @param right
     * @return 返回中间数字的下标
     */
    private static int threeNum(int[] array,int left,int right) {
        int mid = (left+right) / 2;
        if(array[left] < array[right]) {
            if(array[mid] < array[left]) {
                return left;
            }else if(array[mid] > array[right]) {
                return right;
            }else {
                return mid;
            }
        }else {
            if(array[mid] < array[right]) {
                return right;
            }else if(array[mid] > array[left]) {
                return left;
            }else {
                return mid;
            }
        }
    }


    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
    
        //三数取中
        int mid = threeNum(array,start,end);
        //交换
        swap(array,mid,start);

        int pivot = parttion(array,start,end);

        quick(array,start,pivot-1);//左树

        quick(array,pivot+1,end);//右树
    }
2.3.4.2 递归到小的子区间时，可以考虑使用插入排序

    private static void insertSort2(int[] array,int left,int right) {
        for (int i = left+1; i <= right; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= left; j--) {
                //这里加一个等号 就不是一个稳定的排序了
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    //array[j+1] = tmp;
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }

        if(end - start +1 <= 20) {
            //直接插入排序
            insertSort2(array,start,end);
            return;
        }

        //三数取中
        int mid = threeNum(array,start,end);
        //交换
        swap(array,mid,start);

        int pivot = parttion(array,start,end);

        quick(array,start,pivot-1);//左树

        quick(array,pivot+1,end);//右树
    }

2.3.5 快速排序非递归

/**
     * 非递归实现快速排序
     */
    public static void quickSort1(int[] array) {

        Stack<Integer> stack = new Stack<>();
        int start = 0;
        int end = array.length-1;

        if(end - start +1 <= 20) {
            //直接插入排序
            insertSort2(array,start,end);
            return;
        }

        //三数取中
        int mid = threeNum(array,start,end);
        //交换
        swap(array,mid,start);

        int pivot = parttion(array,start,end);
        if(pivot > start+1) {
            stack.push(start);
            stack.push(pivot-1);
        }

        if(pivot < end-1) {
            stack.push(pivot+1);
            stack.push(end);
        }

        while (!stack.empty()) {
            end = stack.pop();
            start = stack.pop();

            if(end - start +1 <= 20) {
                //直接插入排序
                insertSort2(array,start,end);

                //return; 这个地方不能return
                //只排了一个区间,剩下的还没排 
            }else {

                mid = threeNum(array,start,end);
                //交换
                swap(array,mid,start);

                pivot = parttion(array, start, end);
                if (pivot > start + 1) {
                    stack.push(start);
                    stack.push(pivot - 1);
                }
                if (pivot < end - 1) {
                    stack.push(pivot + 1);
                    stack.push(end);
                }
            }
        }
    }

    private static void insertSort2(int[] array,int left,int right) {
        for (int i = left+1; i <= right; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= left; j--) {
                //这里加一个等号 就不是一个稳定的排序了
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    //array[j+1] = tmp;
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

2.4 归并排序

2.4.1 基本思想

  • 归并排序是建立在归并操作上的一种有效的排序算法,采用分治法.
  • 将已有序的子序列合并，得到完全有序的序列.                                                                        (即先使每个子序列有序，再使子序列段间有序)
  • 若将两个有序表合并成一个有序表，称为二路归并。

2.4.2 归并排序

先分解再合并

 

  
 /**
     * 时间复杂度：O(N*logN)
     * 空间复杂度：O(N)
     * 稳定性：稳定的排序
     */
    public static void mergeSort1(int[] array) {
        mergeSortFunc(array,0,array.length-1);
    }


    private static void merge(int[] array,int left,int mid,int right) {

        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;

        int[] tmpArr = new int[right-left+1];
        int k = 0;//tmpArr数组的下标

        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]){
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
                //s2++;
                //k++;
            }
        }
        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= e2) {
            tmpArr[k++] = array[s2++];
        }
        for (int i = 0; i < k; i++) {
            array[i+left] = tmpArr[i];
        }

    }
    private static void mergeSortFunc(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        int mid = (left+right) / 2;
        mergeSortFunc(array,left,mid);
        mergeSortFunc(array,mid+1,right);
        merge(array,left,mid,right);//合并
    }

2.4.3 非递归实现归并排序

public static void mergeSort(int[] array) {
       int gap = 1;
       while (gap < array.length) {
           for (int i = 0; i < array.length; i = i + gap*2) {
               int left = i;
               int mid = left+gap-1;
               int right = mid+gap;
               //mid  和 right 有可能会越界
               if(mid >= array.length) {
                   //纠正
                   mid = array.length-1;
               }
               if(right >= array.length) {
                   right = array.length-1;
               }
               merge(array,left,mid,right);
           }
           gap *= 2;
       }
    }

2.4.3 海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序

前提：内存只有1G，需要排序的数据有100G

因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

1. 先把文件切分成 200 份，每个 512 M

2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以

3. 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

3.排序算法复杂度及稳定性分析

排序方法最好平均最坏空间复杂度空间复杂度
冒泡排序O(n)O(n^2)O(n^2)O(1)稳定
插入排序O(n)O(n^2)O(n^2)O(1)稳定
选择排序O(n^2)O(n^2)O(n^2)O(1)不稳定
希尔排序O(n)O(n^1.3)O(n^2)O(1)不稳定
堆排序O(n * log(n))O(n * log(n))O(n * log(n))O(1)不稳定
快速排序O(n * log(n))O(n * log(n))O(n^2)O(log(n)) ~ O(n)不稳定
归并排序O(n * log(n))O(n * log(n))O(n * log(n))O(1)稳定

4.其他非基于比较排序(了解)

4.1 计数排序

4.1.1 思想

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。

4.2.2 操作步骤

  • 统计相同元素出现次数
  • 根据统计的结果将序列回收到原来的序列中

4.3.3 特性总结

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
  2. 时间复杂度：O(MAX(N,范围)) 
  3. 空间复杂度：O(范围) 
  4. 稳定性：稳定

4.2 基数排序

4.3 桶排序

小笨猪-
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构-排序.ppt
12-03
"数据结构-排序.ppt" 在计算机科学中，排序算法是指将一组无序的记录序列调整为有序的记录序列的算法。排序算法的重要性在于，它可以将大量的数据按一定的规律顺次排列起来，使得数据更加有序和易于管理。 排序的...
数据结构-排序-PPT
02-04
数据结构-排序-PPT
数据结构-十大经典排序算法
qq_64010161的博客
12-09 3351
数据结构-十大经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序）
数据结构--排序之快速排序
qq_52363432的博客
02-08 7465
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。快排每一趟都会有一个元素回到它真正的位置。
数据结构-----二叉排序树
m0_73633088的博客
10-01 1万+
今天我们继续学习新的知识点----排序二叉树，在此之前我们学习了相关的排序算法，给你一个数组，然后对这个数组进行排序。那么同样的我们也可以去构建一个二叉排序树，在创建树的过程中进行排序，也能实现排序的效果，下面就一起来看看吧！二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。给定一个二叉树，如果满足以下条件，那就是二叉排序树。
数据结构-快速排序
m0_61433144的博客
08-24 2431
快速排序的基本思想是分治法，在待排序元素中任取一个元素作为基准，通过一定的操作使得一边的元素都小于该基准值，而另一边的元素都大于该基准值。通过这一趟排序划分被选为基准值的元素放在了最终正确的位置。然后对该基准值的左右两边元素分别递归地重复上述过程，直到左右两边的区间只有一个元素或者区间不存在，也就是待排序的所有元素都放在了其最终位置上。
数据结构-十大排序算法
weixin_46160781的博客
12-26 3493
十大排序算法分别是直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、外部排序。其中插入排序包括直接插入排序、折半插入排序、希尔排序；交换排序包括冒泡排序、快速排序；选择排序包括简单选择排序、堆排序。
数据结构--排序之希尔排序
qq_52363432的博客
02-03 3189
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
数据结构—八大排序
热门推荐
想要上进的coder的博客
01-09 3万+
一、直接插入排序 void InsertSort(int* a, int n) { assert(a); for (int i = 0; i < n - 1; ++i) { int end = i; int x=a[end+1];//将end后面的值保存到x里面了 //将x插入到[0，end]的有序区间 while (end >= 0) { if (a[end] > x) { a[end + 1] = a[end]; //往后挪动一位
Educoder头歌数据结构-十大经典排序算法
qq_50848214的博客
12-06 2万+
数据结构-十大经典排序算法 "不定时更新中" "还未写完，但可全部通关" "仅供参考" 第1关：冒泡排序 void sort_array(int *arr, int n) // 编程实现《冒泡排序算法》：将乱序序列arr转化为升序序列 // 函数参数：乱序整数数组arr 数组长度 // 要求输出：调用print_array(int *arr, int n)输出前三次冒泡操作后的序列，以及最终的升序序列 { // 请在这里补充代码，完成本关任务 /********** Begin **
数据结构--排序之冒泡排序
qq_52363432的博客
01-27 2126
冒泡排序也称气泡排序，是一种典型的交换排序方法，其基本思想是通过无序区中相邻元素关键字间的比较和位置的交换使关键字最小的元素如气泡一般逐渐往上"漂浮"直至"水面"。
数据结构-排序算法（c语言实现篇）
CHAKMING1的博客
08-08 8488
数据结构中最全的排序算法（C语言实现）
数据结构--排序--思维导图.pdf
08-29
"数据结构--排序--思维导图" 数据结构中排序是指将一组无序的记录序列按照一定的规则排列成有序的序列，排序的目的是为了提高数据的存储和检索效率。排序算法的稳定性是指在排序过程中，如果待排序表中有两个元素Ri...
数据结构学习---排序
06-25
实现直接插入排序、折半插入、冒泡、快速、直接选择、堆、归并排序算法。比较各种 算法的运行速度和时间复杂度，是否为稳定排序。分析每一趟排序结果。
数据结构-直接插入排序与希尔排序PPT
08-01
本资源是博文【数据结构】手撕排序NO.2----直接插入排序与希尔排序的配套演示资料，包含直接插入排序、希尔排序的动画演示以及两种插入排序的复杂度分析。可结合以下博文查看：http://t.csdn.cn/pljVV
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
最新发布
maniuT的博客
06-11 1039
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 314
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
数据结构--线性表和串
code袁的博客
06-08 815
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896线性表是一种常见的数据结构，它是具有相同数据类型的有限序列。线性表中的元素之间存在一种顺序关系，可以通过元素在表中的位置来访问和操作。串是由零个或多个字符组成的有限序列，也可以理解为字符串。串是计算机科学中最基本的数据类型之一，常用于表示文本信息。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构 -- 树状数组
gghhb12的博客
06-09 1243
树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。具体区别和联系如下：1.两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度也远小于线段树.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值