归并排序、快排模板

线段树模板

// 构建线段树
public void build(int node,int start,int end,int[] nums) {
        if(start == end) {
            segmentTree[node] = nums[start];
            return;
        }
        int mid = (start + end) / 2;
        build(2 * node + 1,start,mid,nums);
        build(2 * node + 2,mid + 1,end,nums);
        segmentTree[node] = segmentTree[2 * node + 1] + segmentTree[2 * node + 2];
}

// 改变数组值
public void change(int index, int val, int node, int start, int end) {
		 if(start == end) {
		      segmentTree[node] = val;
		      return;
		  }
		  int mid = (start + end) / 2;
		  if(index <= mid) {
		      change(index,val,node * 2 + 1,start,mid);
		  } else {
		      change(index,val,node * 2 + 2,mid + 1,end);
		  }
		  segmentTree[node] = segmentTree[2 * node + 1] + segmentTree[2 * node + 2]; 
}

//查询区间[L,R]的和
public int range(int left,int right,int node,int start,int end) {
		   if(left == start && right == end) {
		       return segmentTree[node];
		   }
		   int mid = (start + end) / 2;
		   if(right <= mid) {
		       return range(left,right,node * 2 + 1,start,mid);
		   } else if(left > mid) {
		       return range(left,right,node * 2 + 2,mid + 1,end);
		   } else {
		       return range(left,mid,node * 2 + 1,start,mid) + range(mid + 1,right,node * 2 + 2,mid + 1,end);
}

归并排序

class Solution {
    public int[] sortArray(int[] nums) {
        sort(nums);
        return nums;
    }
    
    public void sort(int[] arr) {
        int[] temp = new int[arr.length];
        sort(arr,0,arr.length - 1,temp);
    }

    public void sort(int[] arr,int left,int right,int[] temp) {
        if(left < right) {
            int mid = (left + right) / 2;
            sort(arr,left,mid,temp);
            sort(arr,mid + 1,right,temp);
            merge(arr,left,right,temp);
        }
    }

    public void merge(int[] arr,int left,int right,int[] temp) {
        int i = left;
        int count = 0;
        int mid = (left + right) / 2;
        int j = mid + 1;
        while(i <= mid && j <= right) {
            if(arr[i] > arr[j]) {
                temp[count++] = arr[j++];
            } else {
                temp[count++] = arr[i++];
            }
        }
        while(i <= mid) {
            temp[count++] = arr[i++];
        }
        while(j <= right) {
            temp[count++] = arr[j++];
        }
        count = 0;
        while(left <= right) {
            arr[left++] = temp[count++];
        }
    }
}

快速排序

quickSort(int[] arr,int left,int right) {
    if(left < right) {
        int partitionIndex = partition(arr,left,right);
        quickSort(arr,left,partitionIndex - 1);
        quickSort(arr,partitionIndex + 1,right);
    }
    return arr;
}

int partition(int[] arr,int left,int right) {
    int privot = left;
    int index = privot + 1;
    for(int i = index;i <= right;i ++) {
        if(arr[i] < arr[privot]) {
            swap(arr,i,index);
            index ++;
        }
    }
    swap(arr,privot,index - 1);
    return index - 1;
}

void swap(int[] arr,int i,int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}