笔试常用函数

1.partition（快速排序的关键步骤）

int mypartition1(vector<int>&arr, int low, int high)
{
    int pivot = arr[low];//选第一个元素作为枢纽元
    while(low < high)
    {
        while(low < high && arr[high] >= pivot)high--;
        arr[low] = arr[high];//从后面开始找到第一个小于pivot的元素，放到low位置
        while(low < high && arr[low] <= pivot)low++;
        arr[high] = arr[low];//从前面开始找到第一个大于pivot的元素，放到high位置
    }
    arr[low] = pivot;//最后枢纽元放到low的位置
    return low;
}

int mypartition2(vector<int>&arr, int low, int high)
{
    int pivot = arr[high];//选最后一个元素作为枢纽元
    int location = low-1;//location指向比pivot小的元素段的尾部
    for(int i = low; i < high; i++)//比枢纽元小的元素依次放在前半部分
       if(arr[i] < pivot)
           swap(arr[i], arr[++location]);
    swap(arr[high], arr[location+1]);
    return location+1;
}

void quicksort(vector<int>&arr, int low, int high)//快排
{
    if(low < high)
    {
        int middle = mypartition(arr, low, high);
        quicksort(arr, low, middle-1);
        quicksort(arr, middle+1, high);
    }
}

2.最大堆排序

package sortdemo;

import java.util.Arrays;

/**
 * Created by chengxiao on 2016/12/17.
 * 堆排序demo
 */
public class HeapSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }

    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }

    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

3.归并排序

package com.servlet;

public class MyMergeSort {
    public static void main(String[] args) {
        int[] array={2,4,7,5,8,1,3,6};
        printArray(array);
        
        devide(array,0,array.length-1);
        
        System.out.println("排序后:");
        printArray(array);
    }
    /*分解数据*/
    public static void devide(int[] array,int left,int right){
        
        if(left<right){
            /*寻找到中间下标*/
            int mid=(right+left)/2;
            /*从中间下标隔断，将前后两段分别分解*/
            devide(array,left,mid);
            /*继续分割第二段*/
            devide(array,mid+1,right);
            /*分割完了，调用归并*/
            merge(array,left,mid,mid+1,right);    
        }
    }
    /*归并，包含排序*/
    public static void merge(int[] array,int leftStart,int leftEnd,int rightStart,int rightEnd){
        /*新建临时数组，存放该次归并后的数据*/
        int[] temp=new int[array.length];
        /*记录归并的左组和右组开始结束下标*/
        int ls=leftStart,le=leftEnd,
            rs=rightStart,re=rightEnd;
        /*记录临时数组的存放位置*/
        int index=ls;
        /*第一次比较归并，左组合右组中较小的入temp*/
        while(ls<=le&&rs<=re){
            if(array[ls]<=array[rs]){
                temp[index]=array[ls];
                index++;ls++;
            }else{
                temp[index]=array[rs];
                index++;rs++;
            }    
        }
        /*第二次选择归并，将array中剩余的未加入temp的数加入到temp中*/
        while(ls<=le){
            temp[index]=array[ls];
            ls++;index++;
        }
        while(rs<=re){
            temp[index]=array[rs];
            rs++;index++;
        }
        /*temp是经过调整后的array，此时一次归并完毕，返回数据进行下一次归并*/
        while(leftStart<=rightEnd){
            array[leftStart]=temp[leftStart];
            leftStart+=1;
        }
        /*打印本次归并结果*/
        printArray(array);
    }
    public static void printArray(int[] array){
        for(int i=0;i<array.length;i++)
            System.out.print(array[i]+"  ");
        System.out.println();
    }
    
    
}

4.约瑟夫环

https://blog.csdn.net/hj7jay/article/details/79956867