您当前的位置:首页 > 生活百科 > 职场

面试官:手撕十大排序算法,你会几种?

时间:2020-07-26 11:23:51  来源:  作者:

 

今天我们就来讨论面试官最喜欢问到的排序算法吧,从冒泡排序、选择排序、插入排序等十大排序算法的排序步骤、代码实现两个方面入手,彻底搞清实现原理,保证面试道路一路畅通。

01 排序算法的概述

所谓排序算法,就是通过特定的算法因式将一组或多组数据按照一定模式进行重新排序。

这种新序列遵循着一定的规则,体现出一定的规律,因此,经处理后的数据便于筛选和计算,大大提高了计算效率。

02 排序算法的分类

面试官:手撕十大排序算法,你会几种?

 

03评价标准

(1)时间复杂度:即从序列的初始状态到经过排序算法的变换移位等操作变到最终排序好的结果状态的过程所花费的时间度量。

(2)空间复杂度:就是从序列的初始状态经过排序移位变换的过程一直到最终的状态所花费的空间开销。

(3)稳定性:稳定性是不管考虑时间和空间必须要考虑的问题,往往也是非常重要的影响选择的因素。

04 实现步骤与代码

冒泡排序(Bubble Sort)

冒泡排序是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换的数据,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

(1)算法步骤

步骤1:比较相邻的元素。如果第一个比第二个大,就交换他们两个;步骤2:对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数;步骤3:针对所有的元素重复以上的步骤,除了最后一个;步骤4:重复步骤1~3,直到排序完成;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class BubbleSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记,若为true,则表示此次循环没有进行交换,也就是待排序列已经有序,排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
        return arr;
    }
}

选择排序(Selection Sort)

选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候,数据规模越小越好。

(1)算法步骤

步骤1:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置;步骤2:再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾;步骤3:重复步骤2,直到所有元素均排序完毕;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class SelectionSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 总共要经过 N-1 轮比较
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }
}

插入排序(Insertion Sort)

插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

(1)算法步骤

步骤1:从第一个元素开始,该元素可以认为已经被排序;步骤2:取出下一个元素,在已经排序的元素序列中从后向前扫描;步骤3:如果该元素(已排序)大于新元素,将该元素移到下一位置;步骤4:重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;步骤5:将新元素插入到该位置后;步骤6:重复步骤2~5;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class InsertSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 从下标为1的元素开始选择合适的位置插入,因为下标为0的只有一个元素,默认是有序的
        for (int i = 1; i < arr.length; i++) {

            // 记录要插入的数据
            int tmp = arr[i];

            // 从已经排序的序列最右边的开始比较,找到比其小的数
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }

            // 存在比其小的数,插入
            if (j != i) {
                arr[j] = tmp;
            }

        }
        return arr;
    }
}

希尔排序(Shell Sort)

希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的:

  • 插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;
  • 但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位;

希尔排序的基本思想是:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录"基本有序"时,再对全体记录进行依次直接插入排序。

(1)算法步骤

步骤1:选择一个增量序列 t1,t2,……,tk,其中 ti > tj, tk = 1;步骤2:按增量序列个数 k,对序列进行 k趟排序;步骤3:每趟排序,根据对应的增量 ti,将待排序列分割成若干长度为 m 的子序列,分别对各子表进行直接插入排序。仅增量因子为 1时,整个序列作为一个表来处理,表长度即为整个序列的长度;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class ShellSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int gap = 1;
        while (gap < arr.length) {
            gap = gap * 3 + 1;
        }

        while (gap > 0) {
            for (int i = gap; i < arr.length; i++) {
                int tmp = arr[i];
                int j = i - gap;
                while (j >= 0 && arr[j] > tmp) {
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                arr[j + gap] = tmp;
            }
            gap = (int) Math.floor(gap / 3);
        }

        return arr;
    }
}

归并排序(Merge Sort)

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。

和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。

(1)算法步骤

步骤1:把长度为n的输入序列分成两个长度为n/2的子序列;步骤2:对这两个子序列分别采用归并排序;步骤3:将两个排序好的子序列合并成一个最终的排序序列;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class MergeSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        if (arr.length < 2) {
            return arr;
        }
        int middle = (int) Math.floor(arr.length / 2);

        int[] left = Arrays.copyOfRange(arr, 0, middle);
        int[] right = Arrays.copyOfRange(arr, middle, arr.length);

        return merge(sort(left), sort(right));
    }

    protected int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            } else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }

        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }

        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }

        return result;
    }

}

快速排序(Quick Sort)

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序n个项目要 Ο(n log n) 次比较。在最坏状况下则需要 Ο(n^2) 次比较,但这种状况并不常见。事实上,快速排序通常明显比其他 Ο(nlogn) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)。

(1)算法步骤

步骤1:从数列中挑出一个元素,称为 "基准"(pivot);步骤2:重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;步骤3:递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class QuickSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return quickSort(arr, 0, arr.length - 1);
    }

    private int[] 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;
    }

    private int partition(int[] arr, int left, int right) {
        // 设定基准值(pivot)
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

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

}

堆排序(Heap Sort)

堆排序是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法:

  • 大顶堆:每个节点的值都大于或等于其子节点的值,在堆排序算法中用于升序排列;
  • 小顶堆:每个节点的值都小于或等于其子节点的值,在堆排序算法中用于降序排列;

堆排序的平均时间复杂度为 O(n log n)。

(1)算法步骤

步骤1:将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆,此堆为初始的无序区;步骤2:将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n];步骤3:由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class HeapSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int len = arr.length;

        buildMaxHeap(arr, len);

        for (int i = len - 1; i > 0; i--) {
            swap(arr, 0, i);
            len--;
            heapify(arr, 0, len);
        }
        return arr;
    }

    private void buildMaxHeap(int[] arr, int len) {
        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
            heapify(arr, i, len);
        }
    }

    private void heapify(int[] arr, int i, int len) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        if (left < len && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < len && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, largest, len);
        }
    }

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

}

计数排序(Counting Sort)

计数排序 的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

     计数排序是一种稳定的排序算法。计数排序使用一个额外的数组C,其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

(1)算法步骤

步骤1:找出待排序的数组中最大和最小的元素;步骤2:统计数组中每个值为i的元素出现的次数,存入数组C的第i项;步骤3:对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);步骤4:反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

public class CountingSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxValue = getMaxValue(arr);

        return countingSort(arr, maxValue);
    }

    private int[] countingSort(int[] arr, int maxValue) {
        int bucketLen = maxValue + 1;
        int[] bucket = new int[bucketLen];

        for (int value : arr) {
            bucket[value]++;
        }

        int sortedIndex = 0;
        for (int j = 0; j < bucketLen; j++) {
            while (bucket[j] > 0) {
                arr[sortedIndex++] = j;
                bucket[j]--;
            }
        }
        return arr;
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

}

桶排序(Bucket Sort)

桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:

  • 在额外空间充足的情况下,尽量增大桶的数量
  • 使用的映射函数能够将输入的N个数据均匀的分配到K个桶中

同时,对于桶中元素的排序,选择何种比较排序算法对于性能的影响至关重要。

(1)算法步骤

步骤1:人为设置一个BucketSize,作为每个桶所能放置多少个不同数值(例如当BucketSize==5时,该桶可以存放{1,2,3,4,5}这几种数字,但是容量不限,即可以存放100个3);步骤2:遍历输入数据,并且把数据一个一个放到对应的桶里去;步骤3:对每个不是空的桶进行排序,可以使用其它排序方法,也可以递归使用桶排序;步骤4:从不是空的桶里把排好序的数据拼接起来;

注意,如果递归使用桶排序为各个桶排序,则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量,否则会陷入死循环,导致内存溢出;

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

 /**
     * 桶排序
     *
     * @param array
     * @param bucketSize
     * @return
     */
    public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) {
        if (array == null || array.size() < 2)
            return array;
        int max = array.get(0), min = array.get(0);
        // 找到最大值最小值
        for (int i = 0; i < array.size(); i++) {
            if (array.get(i) > max)
                max = array.get(i);
            if (array.get(i) < min)
                min = array.get(i);
        }
        int bucketCount = (max - min) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
        ArrayList<Integer> resultArr = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketArr.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < array.size(); i++) {
            bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
        }
        for (int i = 0; i < bucketCount; i++) {
            if (bucketSize == 1) { // 如果待排序数组中有重复数字时
                for (int j = 0; j < bucketArr.get(i).size(); j++)
                    resultArr.add(bucketArr.get(i).get(j));
            } else {
                if (bucketCount == 1)
                    bucketSize--;
                ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
                for (int j = 0; j < temp.size(); j++)
                    resultArr.add(temp.get(j));
            }
        }
        return resultArr;
    }

基数排序(Radix Sort)

基数排序也是非比较的排序算法,对每一位进行排序,从最低位开始排序,复杂度为O(kn),为数组长度,k为数组中的数的最大的位数;

基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以是稳定的。

(1)算法步骤

步骤1:取得数组中的最大数,并取得位数;步骤2:arr为原始数组,从最低位开始取每个位组成radix数组;步骤3:对radix进行计数排序(利用计数排序适用于小范围数的特点);

(2)过程演示

面试官:手撕十大排序算法,你会几种?

 

(3)代码实现

/**
 * 基数排序
 */
public class RadixSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxDigit = getMaxDigit(arr);
        return radixSort(arr, maxDigit);
    }

    /**
     * 获取最高位数
     */
    private int getMaxDigit(int[] arr) {
        int maxValue = getMaxValue(arr);
        return getNumLenght(maxValue);
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

    protected int getNumLenght(long num) {
        if (num == 0) {
            return 1;
        }
        int lenght = 0;
        for (long temp = num; temp != 0; temp /= 10) {
            lenght++;
        }
        return lenght;
    }

    private int[] radixSort(int[] arr, int maxDigit) {
        int mod = 10;
        int dev = 1;

        for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
            // 考虑负数的情况,这里扩展一倍队列数,其中 [0-9]对应负数,[10-19]对应正数 (bucket + 10)
            int[][] counter = new int[mod * 2][0];

            for (int j = 0; j < arr.length; j++) {
                int bucket = ((arr[j] % mod) / dev) + mod;
                counter[bucket] = arrayAppend(counter[bucket], arr[j]);
            }

            int pos = 0;
            for (int[] bucket : counter) {
                for (int value : bucket) {
                    arr[pos++] = value;
                }
            }
        }

        return arr;
    }

    /**
     * 自动扩容,并保存数据
     *
     * @param arr
     * @param value
     */
    private int[] arrayAppend(int[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }
}


05 总结

面试官:手撕十大排序算法,你会几种?

 



Tags:面试官   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除,谢谢。
▌相关推荐
你知道名校毕业生和普通大学毕业生究竟差在哪里吗?现实真的很残酷。在大部分人眼中,985大学生和普通大学生最大的区别就是学校的层次不同,未来的就业机会也不同。但其实,这些只...【详细内容】
2021-12-27  Tags: 面试官  点击:(2)  评论:(0)  加入收藏
前面文章在谈论分布式唯一ID生成的时候,有提到雪花算法,这一次,我们详细点讲解,只讲它。SnowFlake算法据国家大气研究中心的查尔斯&middot;奈特称,一般的雪花大约由10^19个水分子...【详细内容】
2021-11-17  Tags: 面试官  点击:(24)  评论:(0)  加入收藏
这段时间毕竟也是 “金九银十” 的面试的黄金季节,阿粉当然也想去面试,但是因为自身受限,所以只能采访一下出去面试的同学们都问了什么内容,其中有一个,阿粉觉得有必要给大家分享...【详细内容】
2021-11-05  Tags: 面试官  点击:(45)  评论:(0)  加入收藏
大家先思考一个问题,这也是在面试过程中经常遇到的问题。如果你们公司现在的产品能够支持10W用户访问,你们老板突然和你说,融到钱了,会大量投放广告,预计在1个月后用户量会达到10...【详细内容】
2021-10-19  Tags: 面试官  点击:(47)  评论:(0)  加入收藏
关注社招,面试环节必会被问到的问题肯定有:为什么从上家公司离职?离职原因是什么?作为应聘者,我们该如何真诚而又巧妙的回答呢?哪些离职原因是面试官不想听的?面试中被问及离职原因...【详细内容】
2021-08-06  Tags: 面试官  点击:(92)  评论:(0)  加入收藏
面试官:小明呀,redis 有几种数据结构呀?小明:8 种面试官:那你说一下分别是什么?小明:raw,int,ht,zipmap,linkedlist,ziplist,intset,skiplist,embstr面试官:额,你在说什么?小明:在回答...【详细内容】
2021-06-18  Tags: 面试官  点击:(89)  评论:(0)  加入收藏
01 前言哈喽,好久没更新啦。因为最近在面试。用了两周时间准备,在 3 天之内拿了 5 个 offer,最后选择了广州某互联网行业独角兽 offer,昨天刚入职。这几天刚好整理下在面试中被...【详细内容】
2021-06-17  Tags: 面试官  点击:(115)  评论:(0)  加入收藏
又到了一年一度的毕业季了,小朋友们是否都找到了心仪的工作呢?说起找工作最重要的环节,那就非面试莫属了。特别是面试中直击灵魂的死亡发问,真是多到可以出一本书。要说面试中最...【详细内容】
2021-06-16  Tags: 面试官  点击:(171)  评论:(0)  加入收藏
由于工作的原因,这3年以来接待的面试者没有一千也有八百;而其中关于运营岗的面试,我从面试官的角度来总结几个能轻松通过面试的技巧。大部分的企业考察面试官,会从多个角度来衡...【详细内容】
2021-04-09  Tags: 面试官  点击:(165)  评论:(0)  加入收藏
现在社会人才流动很快。很多人都会选择换工作,而且不止一次两次的换工作,换工作的理由也是千奇百怪。因为恋爱,所以换工作。因为离家太远,所以换工作。因为感觉和同事处不在一块...【详细内容】
2021-03-16  Tags: 面试官  点击:(126)  评论:(0)  加入收藏
▌简易百科推荐
毕业后不重视自己的档案,等到考研、考编、考公务员、单位入职等需要用到档案时,才想起来查询自己的档案。但是,很多人查询档案没有经验,不知道该从何查起。下面给大家介绍查询个...【详细内容】
2021-12-23  帮帮团人力资源    Tags:个人档案   点击:(14)  评论:(0)  加入收藏
评职称可谓是工程人事业发展中的一件大事了,可以说一般想要在行业中持续地、更好地发展的人都会选择评个中级职称! 怎么评广东省建筑中级职称? 在评审时工程业绩最为重要。那...【详细内容】
2021-12-23  资深职称老师—小丽    Tags:职称   点击:(4)  评论:(0)  加入收藏
职场中,事情做得漂亮,不一定结局漂亮;但是善于谋人,把人打通了,出手一般就是巅峰。人情社会尤其如此,说到底工作是人定的,好不好也是人说的,有人为你说话,你就是能力强。没人看到你,工...【详细内容】
2021-12-22  胖子说职场经验    Tags:职场   点击:(4)  评论:(0)  加入收藏
一、在国企,能改变命运的只有你自己。你想改变,就总有办法。你认命,就不要埋怨命运不公。多少领导一样是从基层爬上去的。也许你会说,他们背后有人。我也不反对,但总有那么20%左...【详细内容】
2021-12-21  职场真谛    Tags:国企   点击:(4)  评论:(0)  加入收藏
又到年底了,有更好的工作选择?想跳槽?社保咋处理?以及社保需要注意的小问题是什么?一文全理清!一、打工人离职手册之社保全指南 二、需要注意的社保小问题 ...【详细内容】
2021-12-17  恒企会计网校    Tags:离职指南   点击:(4)  评论:(0)  加入收藏
在个案辅导中,也经常遇到公务员面试前的准备和辅导。首先,我其实挺想吐槽公考的笔试和考试机制的,让我先一吐为快。公务员考察的面非常多,从表达能力这种表面的,到价值观这种底层...【详细内容】
2021-12-14  为好优姐姐    Tags:公务员面试   点击:(12)  评论:(0)  加入收藏
公务员面试形式进行了创新,增加了结构化小组面试这一形式,在结构化的基础上增加了考试互评和回应的环节,这一改变增加了考试难度,也给许多考试造成了困惑,那今天就结构化小组的点...【详细内容】
2021-12-14  红河华图教育    Tags:公务员面试   点击:(14)  评论:(0)  加入收藏
在各级党政机构之中,我们经常会听到一个称呼&mdash;&mdash;“常务副职”,例如县政府有常务副县长,组织部有常务副部长等等。其实,常务副职只是一个约定俗成的简称,其准确名称叫做...【详细内容】
2021-12-14  瑛杰小猪  今日头条  Tags:常务副职   点击:(19)  评论:(0)  加入收藏
在职场,什么都可以没有,就是不能没有情商。没有情商的人,在职场注定难成大器。人际关系搞不定,说话口无遮拦,为人处世更是不够圆滑,处处受限,处处是破绽。尤其是和领导相处,连对方的...【详细内容】
2021-12-14  第一桶金学派    Tags:领导   点击:(8)  评论:(0)  加入收藏
在职场,除了个人的工作能力以外,还要学会去不断的积累自己的人际关系。因为有了关系,就有了渠道,有了机会,有了方法,有了财富&hellip;&hellip;越是和厉害的人交往,你自己也会变得越...【详细内容】
2021-12-10  第一桶金学派    Tags:职场   点击:(10)  评论:(0)  加入收藏
最新更新
栏目热门
栏目头条