排序算法总结以及刷题总结

https://blog.csdn.net/CSL201816080304/article/details/109837914

平均时间复杂度：快排=堆排=归并>冒泡=选择=插入
空间复杂度：

冒泡排序

public int[] MySort (int[] arr) {
        // write code here
        int temp;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return arr;
    }

选择排序

• 把最小值与第一个值交换
• 然后在n-1中继续把最小值与第二个值交换

二分查找

看到有序就二分

对半查找

牛客：数字在升序数组中出现的次数

分别用二分法找到第一次出现和最后一次出现的位置。

插入排序

先记住当前值，然后往前面遍历，遇到比现在值大的就往后挪，直到没有就把当前值放在那（因为是从第一个数字就开始，所以前面的都是排过序的）

图解插入排序
牛客：使基数位于偶数前面

void StraightSort(int []arr,int len)
{
	int tmp;
	int i;
	int j;
	for (i = 1;i < len;i++)
	{
		tmp = arr[i];//记住当前值
		for (j = i - 1;j >= 0 && arr[j] > tmp;j--)//如果当前值的前面那个比该值大
		{
			arr[j + 1] = arr[j];//把前面那个值放在当前位置这，循环继续往前比较
		}
		arr[j + 1] = tmp;//直到遇到比当前值小的，把当前值放在那个值后面一个
	}
}

快速排序

先找一个基准数，然后i，j分别从头和尾部开始判断，把比基准数小的放基准数左边，把比基准数大的放基准数右边（arr[j]比index小则和arr[i]交换，arr[i]比基准数大和arr[j]交换，否则不变）

public int[] MySort (int[] arr) {
        // write code here
        QuickSort(arr,0,arr.length-1);
        return arr;
    }
    public void QuickSort(int[] arr,int begin,int end){
        if(begin<end){
            int i=begin;
            int j=end;
            int index=arr[i];
            while(i<j){
                while(arr[j]>index&&i<j){
                    j--;
                }
                arr[i]=arr[j];
                while(arr[i]<=index && i<j){
                    i++;
                }
                arr[j]=arr[i];
            }
            arr[i]=index;
            QuickSort(arr,begin,i-1);
            QuickSort(arr,i+1,end);
        }else
            return ;
    }

归并排序

• 将n个元素的序列划分成n/2个元素的子序列
• 对子序列递归排序
• 合并排序后的子序列

图解归并排序
牛客：数组中的逆序对

  public static int[] MergeSort(int[] arr){
        if(arr.length < 2)return arr;
        int mid = arr.length/2;
        int[] left = Arrays.copyOfRange(arr,0,mid);
        int[] right = Arrays.copyOfRange(arr,mid,arr.length);
        return merge(MergeSort(left),MergeSort(right));
    }
    public static int[] merge(int[] left,int[] right){
        int[] ans = new int[left.length+right.length];
        for(int index = 0,i = 0,j = 0;index < ans.length;index++){
            if(i >= left.length){
                ans[index] = right[j++];
            }else if(j >= right.length){
                ans[index] = left[i++];
            }else if(left[i] >right[j]){
                ans[index] = right[j++];
            }else{
                ans[index] = left[i++];
            }
        }
        return ans;
    }

堆排序

DFS和BFS

DFS：深度优先搜索

BFS：广度优先搜索

刷题

牛客：排序