leetcode刷题总结之数组类算法

初始化定义

思路：双指针，其中一个快指针来判断所在的元素是否为0，慢指针来实现非零元素的复制，当快指针到达数组的末尾，算法就结束。

快慢指针，算法思想类似于移动零

源代码：

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length==0){
            return 0;
        }
        if(nums.length<=2){
            return nums.length;
        }
        int result_index=1;
        for(int i=2;i<nums.length;i++){
            if(nums[i]!=nums[result_index-1]){
                result_index++;
                nums[result_index]=nums[i];
            }
        }
        return result_index+1;
    }
}
 
package elementary;
public class SortColorsTest {
	 public void swap(int [] nums,int a,int b){
	        int temp =nums[a];
	        nums[a]=nums[b];
	        nums[b]=temp;
	    }
    public void sortColors(int[] nums) {
        int zeros=-1;
        int len = nums.length;
        int twos=len;
        int i=0;
        while(i<twos){
            if(nums[i]==0){
                zeros++;
                swap(nums,zeros,i);
                i++;
            }
            else if(nums[i]==2){
                twos--;
                swap(nums,twos,i);
            }
            else{
                i++;
            }
        }
    }
    
    public static void main(String argc[]) {	
		int [] nums = {2,2,1,1,1,0,0};
		SortColorsTest test  = new SortColorsTest();
		test.sortColors(nums);
		for(int i=0;i<nums.length;i++) {
			System.out.println(nums[i]);
		}
}
}

方法一：堆排序

package elementary;
import java.util.PriorityQueue;

public class Heapsort {
	public int findKthlargest(int []nums,int k) {//堆排序实现第K个最大值
		PriorityQueue<Integer> minHeap = new PriorityQueue<>(k,(a,b)->a-b);
		for(int i=0;i<nums.length;i++) {
			if(i<k) {
				minHeap.add(nums[i]);
			}
			else {
				Integer topnum = minHeap.peek();
				if(nums[i]>topnum) {
					minHeap.poll();
					minHeap.add(nums[i]);
				}
			}
		}
		return minHeap.peek();
	}
	 public static void main(String argc[]) {	
		 int [] nums = {3,54,7,9,10,88};
		 int k=3;
		 Heapsort test = new Heapsort();
		 System.out.println(test.findKthlargest(nums, k));
	 }
}
在这里插入代码片

方法二：快速选择（基于快速排序）

package elementary;

import java.util.Random;

public class Quicksort {
	int [] nums;
	public void swap(int a,int b) {
		int temp = this.nums[a];
		this.nums[a] = this.nums[b];
		this.nums[b] = temp;
	}
	
	public int partition(int left,int right,int pivot_index) {
		int pivot = this.nums[pivot_index];
		swap(pivot_index, right);//将轴值放到最右边
		int store_index = left;
		for(int i=left;i<=right;i++) {//遍历按照轴值进行划分两部分
			if(nums[i]<pivot) {
				swap(store_index, i);
				store_index++;
			}
		}
		swap(store_index,right);//恢复轴值对应的位置，为了下一次的递归调用
		return store_index;
	}
	
	public int quickselet(int left,int right,int k_smallest) {
		if(left == right) {
			return this.nums[left];
		}
		Random randNum = new Random();
		int pivot_index = left + randNum.nextInt(right-left);
		pivot_index = partition(left,right,pivot_index);
		if(pivot_index == k_smallest) {
			return this.nums[pivot_index];
		}
		else if(pivot_index > k_smallest){
			return quickselet(left,pivot_index-1,k_smallest);
		}
		else {
			return quickselet(pivot_index+1,right,k_smallest);
		}
	}
	
	public int findKthlargest(int []nums,int k) {
		this.nums=nums;
		int len = nums.length;
		return quickselet(0,len-1,len-k);
	}
	
	public static void main(String argc[]) {	
		 int [] nums = {2,3,4,5,6,7,8};
		 int k=5;
		 Quicksort test = new Quicksort();
		 test.nums = nums;
		 System.out.println(test.findKthlargest(nums, k));
	}

}
在这里插入代码片