算法与数据结构-排序 讲解与java代码实现

最新推荐文章于 2024-01-31 16:07:50 发布
最新推荐文章于 2024-01-31 16:07:50 发布
阅读量212 收藏 1
点赞数
分类专栏： 算法 文章标签： 牛客网 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bury_/article/details/79085701
版权

1. 时间复杂度为O（N^2）的排序算法

冒泡，选择，插入排序
- 冒泡排序:时间复杂度O(n^2) 与数组元素原始顺序无关

import java.util.*;
public class BubbleSort {
    public int[] bubbleSort(int[] A, int n) {
        // 一共需要循环n-1次
        for(int i=1,index=n;i<=n-1;i++,index--){
            //从索引1到索引index，依次比较其与前一个数的大小，大的调换在后面，直到第index个数
            //初始时最后一个比较的数为索引n-1，每次大循环时递减
            for(int j=1;j<index;j++){
                if(A[j]<A[j-1]){
                    int temp=A[j];
                    A[j]=A[j-1];
                    A[j-1]=temp;
                }
            }
        }
        return A;
    }
}
  • 选择排序:时间复杂度O(n^2) 与数组元素原始顺序无关
import java.util.*;
public class SelectionSort {
    public int[] selectionSort(int[] A, int n) {
        //一共循环n-1次
        //每次假定比较序列中第一个数index-1为当前最小值，依次将最小值索引上的数与序列中后面的数进行比较，如果有更小的则更新最小值索引
        //内部循环结束则调换当前比较序列的第一个数和最小值索引的数
        for(int i=1,index=1;i<=n-1;i++,index++){
            int minIndex=index-1;
            for(int j=index;j<=n-1;j++){
                if(A[j]<A[minIndex]){
                    minIndex=j;
                }
            }
            int temp=A[index-1];
            A[index-1]=A[minIndex];
            A[minIndex]=temp;
        }
        return A;
    }
}
  • 插入排序：时间复杂度O(n2) 跟原始元素顺序有关，如果移动距离不超过k，那么时间复杂度为O(N*K)
import java.util.*;
//插入排序
public class InsertionSort {
    public int[] insertionSort(int[] A, int n) {
        //循环n-1次，从第1个数一直到第n-1个数，
        //循环index-1次，依次比较第index个数与前面的数的大小，若index上的数小于等于前面的数，则调换位置，index与index-1到0上的数依次比较
        for(int i=1,index=1;i<=n-1;i++,index++){
            int tempIndex=index;//当前的数A[index]，由于调换过程中会发生位置改变
            for(int j=index-1;j>=0;j--){
                if(A[tempIndex]<=A[j]){
                    int temp=A[j];
                    A[j]=A[tempIndex];
                    A[tempIndex]=temp;
                    tempIndex=j;
                }
            }

        }
        return A;
    }
}

2. 时间复杂度为O（N*logN）的排序算法

这里写图片描述

  • 归并排序：递归地分解为两半并按大小顺序合并为一个有序数组 与数组元素原始顺序无关
import java.util.*;
//归并排序 递归解决 分解和合并
public class MergeSort {
    public int[] mergeSort(int[] A, int n) {
        if(A==null||n<2){
            return A;
        }
        process(A,0,n-1);
        return A;
    }
    //子序列left到right，先对分为两半，再将两部分按从小到大顺序合并
    public void process(int[] A,int left,int right){
        //left小于right索引才可以继续分
        if(left<right){
            int mid=(left+right)/2;
            process(A,left,mid);
            process(A,mid+1,right);
            merge(A,left,mid,right);  
        }
    }
    //将两部分根据从小到大的顺序进行排序合并，利用指针分别遍历两部分来比较大小，加入缓存数组
    public void merge(int[] A,int left,int mid,int right){
        int leftIndex=left;
        int rightIndex=mid+1;
        int tempIndex=0;
        int[] temp=new int[right-left+1];//保存排序后结果
        //分别遍历两部分，比较大小并存入缓存数组
        while(leftIndex<=mid&&rightIndex<=right){
            if(A[leftIndex]<=A[rightIndex]){
                temp[tempIndex++]=A[leftIndex++];
            }else{
                temp[tempIndex++]=A[rightIndex++];
            }
        }
        //将两部分中其中一半的剩余部分加入
        while(leftIndex<=mid){
            temp[tempIndex++]=A[leftIndex++];
        }
        while(rightIndex<=right){
            temp[tempIndex++]=A[rightIndex++];
        }

        //用排序合并后的数组替换原来的数组
        tempIndex=0;
        while((left+tempIndex)<=right){
            A[left+tempIndex]=temp[tempIndex++];
        }


    }
}
  • 快速排序：划分过程时间复杂度为O(n) 与数组元素原始顺序无关
    这里写图片描述
import java.util.*;
//快速排序
public class QuickSort {
    public int[] quickSort(int[] A, int n) {
        if(A==null||n<2){
            return A;
        }
        process(A,0,n-1);
        return A;
    }

    public void process(int[] A,int left,int right){
        if(left<right){
            //在[left,right]随机选取一个数并放到最后以便比较
            int randomIndex=left+(int)(Math.random()*(right-left+1));
            swap(A,randomIndex,right);
            //进行划分
            int mid=partition(A,left,right);

            process(A,left,mid-1);
            process(A,mid+1,right);
        }

    }
    //遍历整个数组，与随机数做比较进行一次划分，小于随机数的放到mid索引前面，大于随机数的放到mid索引后面，返回小于等于随机数的个数即mid
    public int partition(int[] A,int left,int right){
        int pivot=left-1;
        int index=left;
        //要加上等号，因为还要把random数从最后放回有序序列的最后
        while(index<=right){
            if(A[index]<=A[right]){
                swap(A,index,++pivot);
            }
            index++;
        }

        return pivot;
    }
    //交换元素
    public void swap(int[] A,int index1,int index2){
       int temp=A[index1];
        A[index1]=A[index2];
        A[index2]=temp;
    }
}

  • 堆排序
    这里写图片描述

    堆排序讲解
    堆实际上是一棵完全二叉树，其任何一非叶节点满足性质： Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]（i表示在数组中非叶节点的索引，其左右孩子在数组中的索引分别为2i+1,2i+2，数组存储时按照宽度优先遍历存储这棵完全二叉树的每个节点），即任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。

import java.util.*;
//堆排序 大根堆 任何一非叶节点的关键字不小于其左右孩子节点的值
public class HeapSort {
    public int[] heapSort(int[] A, int n) {
        buildHeap(A,n);
        for(int i=n-1;i>=0;i--){
            swap(A,0,i);//交换大根堆的头结点到数组的最后
            adjustHeap(A,0,i);//调整以0号元素为头结点的前i个值为大根堆
        }
        return A;
    }
    //调换元素位置
    public void swap(int[] A,int index1,int index2){
        int temp=A[index1];
        A[index1]=A[index2];
        A[index2]=temp;
    }
    //建立初始大根堆，只执行一次
    //整个序列，length/2到0均为非叶节点，以非叶节点为头的子树需要调整为大根堆 i*2+1为i的左孩子，i*2+2为i的右孩子
    //从下到上开始建立
    public void buildHeap(int[] A,int length){
        for(int i=length/2;i>=0;i--){
            adjustHeap(A,i,length);
        }
    }
    //调整以father为头节点的子树，所有父节点的值大于等于其孩子节点的值
    public void adjustHeap(int[] A,int father,int length){
        //保存最开始父节点的值 father总是指向该值在数组中的索引
        int tempMax=A[father];
        for(int child=father*2+1;child<length;child=child*2+1){
            //child指向左孩子和右孩子中最大值
            if(child<(length-1)&&A[child]<A[child+1])
            {
                child++;
            }
            //比较父节点和最大的孩子节点的值，如果父节点小于孩子值，则用最大孩子值覆盖父节点的值
            if(tempMax>A[child]){
                break;
            }
            A[father]=A[child];
            father=child;
        }
        A[father]=tempMax;
    }


}
  • 希尔排序：插入排序的变种，步长是递减的，当步长为1时为插入排序，关键是步长选择
    这里写图片描述这里写图片描述
import java.util.*;
//希尔排序
public class ShellSort {
    public int[] shellSort(int[] A, int n) {
        //步长递减，从n/2到1
        for(int step=n/2;step>=1;step=step/2){
            //遍历一遍以step为间隔的各个元素与它前面每隔step上的元素大小
            for(int index=step;index<=n-1;index++){
                //tempIndex是index每隔step上的元素索引
                for(int tempIndex=index-step;tempIndex>=0;tempIndex-=step){
                    if(A[index]<A[tempIndex]){
                        swap(A,index,tempIndex);
                        index=tempIndex;
                    }else{
                        //停止比较，因为前面每隔step
                        break;
                    }
                }

            }
        }
        return A;
    }

    public void swap(int[] A,int index1,int index2){
        int temp=A[index1];
        A[index1]=A[index2];
        A[index2]=temp;
    }
}

3.时间复杂度为O（N）的排序算法

这里写图片描述
- 计数排序：根据最小值最大值间隔确定桶的个数，把每个数依次放到对应的桶上，最后遍历桶，即为有序的序列。三个循环。需要知道最大最小值。时间复杂度为O(n)

import java.util.*;
//计数排序
public class CountingSort {
    public int[] countingSort(int[] A, int n) {
       int min=A[0];
       int max=A[0];
        //确定桶的个数，即最大值减去最小值
       for(int i=1;i<n;i++){
           if(A[i]<min){
               min=A[i];
               continue;
           }
           if(A[i]>max){
               max=A[i];
           }
       }
        //建立桶数组
        int bucketSize=max-min+1;
        int[] bucket=new int[bucketSize];
        for(int i=0;i<n;i++){
            bucket[A[i]-min]+=1;
        }
        int[] result=new int[n];
        for(int i=0,index=0;i<bucketSize;i++){
            while(bucket[i]>0){
                result[index++]=min+i;
                bucket[i]--;
            }
        }

        return result;
    }
}
  • 基数排序：如果是整数，从小的位数到大的位数，每个位数上都根据位数上的值进行依次排序，最后得到一个有序序列。位数决定了需要排序的次数。需要知道排序的元素的取值范围。时间复杂度为O(n)
    这里写图片描述这里写图片描述这里写图片描述
import java.util.*;
//基数排序
public class RadixSort {
    public int[] radixSort(int[] A, int n) {
        //位数决定了排序的总次数，由于题目中说明元素小于等于2000，所以需要排4次
        int[][] bucket=new int[10][n];
        int[] size=new int[10];//记录每一个桶上元素的个数

        for(int Bi=0;Bi<4;Bi++){
            //对数组元素根据其倒数第Bi上的数的大小放到对应的桶上
            for(int Ai=0;Ai<n;Ai++){
                //倒数Bi位上的数字
                int num=A[Ai]/(int)Math.pow(10,Bi)%10;
                bucket[num][size[num]]=A[Ai];
                size[num]++;
            }
            //遍历桶，取出元素组成新的序列，同时清空桶

            for(int i=0,Aindex=0;i<10;i++){
                for(int Bj=0;Bj<size[i];Bj++){
                    A[Aindex++]=bucket[i][Bj];
                    bucket[i][Bj]=0;
                }
                size[i]=0;
            }

        }

        return A;

    }
}

4. 排序算法的空间复杂度

这里写图片描述

5. 排序算法的稳定性

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
函数栈的大小是递归的层数

6.排序算法例题

  • 重复值判断：
import java.util.*;
//高效指空间复杂度和时间复杂度均小，非递归的堆排序空间复杂度为O(1)，时间复杂度为N*log(N)
public class Checker {
    public boolean checkDuplicate(int[] A, int n) {
        //非有序的部分长度从n缩减到2,建立小根堆，即数组上元素从小到大
        //数组上n/2到0索引前的数，即非叶节点上的数，都小于等于其左右孩子上的数
        if(A==null||n==1){
            return false;
        }
        //初始调整建立小根堆 从子树的第一个非叶节点到整棵树数的根节点 保证可以遍历所有的子树
         for(int father=n/2;father>=0;father--){
             heapAdjust(A,father,n);
         }

        //交换大根堆的头结点到数组的最后 数组长度依次从右边缩减
        for(int index=n-1;index>=0;index--){
            swap(A,index,0);
            heapAdjust(A,0,index);
        }


        //如果后面一个值与前面一个值相同，则表示有重复的值
        for(int i=1;i<n;i++){
            if(A[i]==A[i-1]){
                return true;
            }
        }
        return false;
    }

    public void swap(int[] A,int index1,int index2){
        int temp=A[index1];
        A[index1]=A[index2];
        A[index2]=temp;
    }

    public void heapAdjust(int[] A,int father,int n){
             //以father为头结点的子树为小根堆
             int tempMax=A[father];
             for(int child=2*father+1;child<n;child=child*2+1){
                if(child<(n-1)&&A[child]<A[child+1]){
                    child++;
                }
                if(tempMax>=A[child]){
                    break;
                }
                A[father]=A[child];
                father=child;
            }
             A[father]=tempMax;
    }
}
  • 有序数组合并：
    有两个从小到大排序以后的数组A和B，其中A的末端有足够的缓冲空容纳B。请编写一个方法，将B合并入A并排序。
    给定两个有序int数组A和B，A中的缓冲空用0填充，同时给定A和B的真实大小int n和int m，请返回合并后的数组。
import java.util.*;
//合并有序数组
public class Merge {
    public int[] mergeAB(int[] A, int[] B, int n, int m) {
        //为了使得有序数组元素移动最少，要从后往前对A数组遍历，同时比较A当前元素与B元素的大小，大的调换到后面
        //B遍历完即完成
        if(A==null||B==null){
            return A!=null?A:B;
        }

        int Ai=n-1,Bi=m-1,index=n+m-1;
        while(Bi>=0&&Ai>=0){
            if(A[Ai]>=B[Bi]){
                A[index--]=A[Ai--];
            }else{
                A[index--]=B[Bi--];
            }
        }

        while(Bi>=0){
            A[index--]=B[Bi--];
        }


        return A;

    }
}
  • 荷兰国旗问题：
    有一个只由0，1，2三种元素构成的整数数组，请使用交换、原地排序而不是使用计数进行排序。
    给定一个只含0，1，2的整数数组A及它的大小，请返回排序后的数组。保证数组大小小于等于500。
    测试样例：[0,1,1,0,2,2],6
    返回：[0,0,1,1,2,2]
import java.util.*;
//荷兰国旗问题 三值排序
public class ThreeColor {
    public int[] sortThreeColor(int[] A, int n) {
        //0值区域和2值区域的索引值
        int index0=-1,index2=n,index=0;
        //当前索引遍历到2值区域时停止，否则遇到0值则交换其到0值区域，遇到2则交换到2值区域
        while(index!=index2){
           if(A[index]==2){
                swap(A,index,--index2);
               //注意交换过来的--index2上的值没有被遍历过，因此不增加index的值
                   continue;
            }else if(A[index]==0){
                 swap(A,index,++index0);
            }
                 index++;
        }

        return A;
    }

    public void swap(int[] A,int index1,int index2){
        int temp=A[index1];
        A[index1]=A[index2];
        A[index2]=temp;
    }
}
  • 在行和列方向上均有序的矩阵中寻找是否包含某个数：
    现在有一个行和列都排好序的矩阵，请设计一个高效算法，快速查找矩阵中是否含有值x。
    给定一个int矩阵mat，同时给定矩阵大小nxm及待查找的数x，请返回一个bool值，代表矩阵中是否存在x。所有矩阵中数字及x均为int范围内整数。保证n和m均小于等于1000。
    测试样例：[[1,2,3],[4,5,6],[7,8,9]],3,3,10
    返回：false
import java.util.*;
//在一个行列有序的矩阵中，寻找是否包含某个数
public class Finder {
    public boolean findX(int[][] mat, int n, int m, int x) {
        //初始位置可以从左下角或者右上角开始，因为这两个角上沿X轴，Y轴上的数分别是增大和减小的，有利于确定下一个搜索方向是按行还是按列
        for(int row=0,column=m-1;row<=n-1&&column>=0;){
            if(x==mat[row][column]){
                return true;
            }
            else if(x<mat[row][column]){
                column--;
            }else{
                row++;
            }
        }

        return false;
    }
}
  • 寻找无序的最短子序列的长度：左右两边分别确定，同选择排序的变种
    对于一个数组，请设计一个高效算法计算需要排序的最短子数组的长度。
    给定一个int数组A和数组的大小n，请返回一个二元组，代表所求序列的长度。(原序列位置从0开始标号,若原序列有序，返回0)。保证A中元素均为正整数。
    测试样例：[1,4,6,5,9,10],6
    返回：2
import java.util.*;
//求需要排序的最短子数组
public class Subsequence {
    public int shortestSubsequence(int[] A, int n) {
        if(A==null||n<2){
            return 0;
        }

        int left=0,right=n-1;
        int max,min;
        boolean hasLeft=false,hasRight=false;//是否确立了无序子序列左右边界
        while((!hasLeft||!hasRight)&&left<right){
            //从left+1遍历到n-1,寻找最小值，若当前left的值小于最小值，则继续向右，否则开始从右边向左遍历
            if(!hasLeft){
                min=A[left+1];
                for(int j=left+2;j<n;j++){
                    if(A[j]<min){
                        min=A[j];
                    }
                }
                if(A[left]>min){
                    hasLeft=true;
                }else{
                    left++;
                }
            }
            //从right-1遍历到0，寻找最大值，若当前right的值大于最大值，则继续向左，否则跳出循环
            if(!hasRight){
                max=A[right-1];
                for(int k=right-2;k>=0;k--){
                    if(A[k]>max){
                        max=A[k];
                    }
                }
                if(A[right]<max){
                    hasRight=true;
                }else{
                    right--;
                }
            }

        }

        if(hasLeft&&hasRight){
            return right-left+1;
        }else{
            return 0;
        }

    }
}
  • 相邻两数最大差值
    有一个整形数组A，请设计一个复杂度为O(n)的算法，算出排序后相邻两数的最大差值。
    给定一个int数组A和A的大小n，请返回最大的差值。保证数组元素多于1个。
    测试样例：[1,2,5,4,6],5
    返回：2
import java.util.*;
//寻找排序后相邻两个数的最大差距，时间复杂度O(n)，因为没有要求空间复杂度，使用桶排序中的计数排序
public class Gap {
    public int maxGap(int[] A, int n) {
        //寻找数组最大最小值

        int min=A[0],max=A[0];
        for(int i=1;i<n;i++){
            if(A[i]<min){
                min=A[i];
            }else if(A[i]>max){
                max=A[i];
            }
        }

        int bNum=max-min+1;
        int[] size=new int[bNum];//每个桶上的元素个数
        //桶号和数的对应关系为 数-min size每个元素对应min+索引 这个数出现在A中的次数
        for(int i=0;i<n;i++){
            size[A[i]-min]+=1;
        }
        int maxGap=0,next=0;
        //遍历计数数组，找出间隔最大的两个桶
        for(int i=0;i<bNum;){
            next=i+1;
            while(next<bNum&&size[next]==0){
                next++;
            }
            if((next-i)>maxGap){
                maxGap=next-i;
            }
            i=next;
        }

        return maxGap;
    }
}
慕森
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法—常见的几种排序算法及实现（java）
zeng_ll的博客
02-25 1936
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。 以下我们将介绍几种常见的排序，几种排序算法的时间复杂度及稳定性如下： 1、冒泡排序 冒泡排序的效率很低，但是算法实现起来很简单，因此很适合作为研究排序的入门算法。 基本思想 对当前还未排好序的...
Java 数据结构篇-深入了解排序算法（动态图 + 实现七种基本排序算法）
小扳手
01-28 7846
1.0 冒泡排序的实现 + 动态演示图 2.0 选择排序的实现 + 动态演示图 3.0 堆排序的实现 + 动态演示图 4.0 插入排序的实现 + 动态演示图 5.0 希尔排序的实现 + 动态演示图 6.0 归并排序的实现 + 动态演示图 7.0 快速排序的实现 + 动态演示图
Java实现数据结构与算法（内含源码图文解析，语言清晰易懂）
最新发布
chang_mao的博客
01-31 2073
本篇文章主要帮助有计算机基础的同学了解一下各类数据结构的基本概念，优劣分析及使用场景，并附带了大牛文章的详解链接，可供读者学习。数据结构主要是表示数据在计算机中的存储形式，主要表示元素之间的位置及关联关系，用现实的话来说就是用桶装，管道装，手链的串链等等，数据结构只是一种存储方式，只要实现了它的概念，不管是Java还是C++或是Python实现，都大同小异。按照笔者个人的理解，计算机所做的事情主要是对数据的存储、传输、和计算。
【数据结构与算法】 合并排序
小鳴人的博客
05-16 8660
【包含了：合并排序(Sequencing By Merging)百科、算法思想、合并过程、合并方法、算法描述、算法分析、构造实例、代码实现、Java、C/C++】
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
热门推荐
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
【数据结构与算法】Java实现八大排序
woodwhale的博客
03-12 3981
排序合集 文章目录排序合集前言1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、堆排序7、快速排序8、桶排序后话 前言 排序在算法中有很重要的作用，写下这篇文章来进一步加深自己对目前主流的排序算法的认识。下面我将从时间复杂度、空间复杂度和稳定性三个方面来介绍不同的排序算法。 以下是八种主流算法的时间复杂度、空间复杂度和稳定性的汇总。 排序方法 时间复杂度（平均） 时间复杂度（最坏） 时间复杂度（最好） 空间复杂度 稳定性 冒泡排序 O(n²) O(n²) O(n) O(1) 稳
Java数据结构第一讲-排序算法
Jet_qi的博客
12-19 1373
常见数据结构和算法实现(排序/查找/数组/链表/栈/队列/树/递归/海量数据处理/图/位图/Java版数据结构) 数据结构和算法作为程序员的基本功，一定得稳扎稳打的学习，我们常见的框架底层就是各类数据结构，例如跳表之于redis、B+树之于mysql、倒排索引之于ES，熟悉了底层数据结构，对框架有了更深层次的理解，在后续程序设计过程中就更能得心应手。掌握常见数据结构和算法的重要性显而易见，本文主要讲解了几种常见的数据结构及基础的排序和查找算法，最后对高频算法笔试面试题做了总结。本文会持续补充，希望对大家日
数据结构与算法详解（含算法分析、动图图解、Java代码实现、注释解析）
努力让自己发光，对的人才能迎着光而来
09-13 1万+
数据结构和算法的重要性 算法是程序的灵魂，优秀的程序可以在海量数据计算时，依然保持高速计算 数据结构和算法的关系： 程序 = 数据结构 + 算法 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位。 面试常考！！！ 常用数据结构与算法实现 以下博客根据B站罗召勇老师视频：数据结构与算法基础-Java版（罗召勇）写的详细笔记 数据结构与算法基础： 数据结构与算法之基础概述 数据结构： （一）数据结构与算法之数组 （二）数组结构与算法之栈 （三）数据结构与算法之队列 （四）数据结构与算
【数据结构】常见排序算法详细分析（内含java与c++代码）
码农研究僧的博客
12-12 1984
目录前言1. 定义2. 插入排序2.1 直接插入排序2.2 折半插入排序2.3 希尔排序3. 交换排序3.1 冒泡排序3.2 快速排序 前言 排序是计算机程序设计中的一种重要操作， 在很多领域中都有广泛的应用 在考研复试和企业面试都会有很强的考察需求 1. 定义 排序(Sorting) ：是按关键字的非递减或非递增顺序对一组记录重新进行排列的操作 关于排序的稳定性标准 定义如下： 假设 Ki=kj (i与j 都是从1到n，但两者不能同时相等），且在排序前的序列中 Ri领先于 Rj （即 i<j）。若在
Java实现十大排序算法
qq_56517253的博客
12-27 1059
马士兵教育十大排序算法讲解和记忆
数据结构与排序算法------通过代码示例，讲解：数据结构和9种排序算法。.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
JAVA---算法与数据结构
04-08
在"JAVA---算法与数据结构"这个主题中，我们将深入探讨Java中常用的数据结构，如数组、链表、栈、队列、集合、映射、树（二叉树、红黑树）和图等。每种数据结构都有其独特的优势和适用场景，例如，数组适合随机访问...
尚硅谷老韩java版算法和数据结构讲解代码笔记整理.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
随手笔记--数据结构与算法（Java）排序
09-15
内容概要：这是本人在复习数据结构排序算法所写的markdown文档，对各个算法进行了比较，分析其稳定性。通过对六种排序算法的介绍，了解其中的核心原理，手写源码过程中对其代码进行注释讲解。 适用人群：本人文档是...
java基础算法与数据结构面试题
09-04
本文将从选择排序、插入排序和冒泡排序三个方面对 Java 基础算法与数据结构进行讲解。 选择排序是一种简单的排序算法，它的思想是每次选择一个数，然后遍历其后的每一个数，和这个数比较。时间复杂度为 O(N^2)，...
字符串匹配-KMP算法 讲解与java代码实现
bury_的博客
01-29 3966
如何高效地查找字符串a是否包含字符串s？ 可以使用KMP算法，首先计算字符串s的模式偏移数组next，然后在遍历a查找s的时候可以利用next偏移数组对s进行偏移，以求更快地进行匹配检测。 假设要计算字符串a=”bcbcbacbcbcbc”是否包含字符串s=”bcbcbc”。 1.算法思想 第一步：计算字符串”bcbcbc”的next偏移数组： next[0]=-1,next[1
算法与数据结构-字符串 讲解与java代码实现
bury_的博客
02-01 487
1.基础 2.例题 1. 拓扑结构相同子树练习题 KMP算法及示例讲解：http://blog.csdn.net/bury_/article/details/79199228 import java.util.*; //拓扑结构相同的子树判断，要求时间复杂度为O(n) /* public class TreeNode { int val = 0; Tre
算法与数据结构-链表 讲解与java代码实现
bury_的博客
01-31 441
1.链表基础 从左到右，使用两个指针进行性翻转 空间复杂度最优解可以做到O（1） 2.例题 1. 有序环形链表插入节点 import java.util.*; /* public class ListNode { int val; ListNode next = null; ListNode(int val) {
算法与数据结构-二叉树 讲解与java代码实现
bury_的博客
01-06 376
1. 三种遍历方式和宽度优先遍历 递归实现先序，中序，后序遍历 import java.util.*; /* public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.v
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值