剑指 Offer 61. 扑克牌中的顺子

从若干副扑克牌中随机抽 5 张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。

示例 1:

输入: [1,2,3,4,5]
输出: True

示例 2:

输入: [0,0,1,2,5]
输出: True

着急下班，看到这个简单题，懵了一下，后面想到了先进行排序在进行判断上代码

class Solution {
public:
    bool isStraight(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int n = 0;
        for (int i = 0; i < 4; i++) {
            if (nums[i] == 0)
                n++;
            else if (nums[i] >= nums[i + 1])
                return false;
            else if (nums[i] + 1 != nums[i + 1])
                n = n + nums[i] - nums[i + 1] + 1;
        }
        if (n >= 0)
            return true;
        return false;
    }
};

c++sort（）函数太好用了，但是这样感觉就不知道怎么自己写排序算法了，自己整理了一下排序算法

class Solution {
public:
    bool isStraight(vector<int>& nums) {
        //sort(nums.begin(),nums.end());
        //KuaiPai(nums,0, nums.size()-1);
        //MaoPao(nums);
        //XuanZe(nums);
        //ChaRu(nums);
        heapSort(nums,nums.size());
        int n = 0;
        for (int i = 0; i < 4; i++) {
            if (nums[i] == 0)
                n++;
            else if (nums[i] >= nums[i + 1])
                return false;
            else if (nums[i] + 1 != nums[i + 1])
                n = n + nums[i] - nums[i + 1] + 1;
        }
        if (n >= 0)
            return true;
        return false;
    }
    //快速排序
    void KuaiPai(vector<int>& nums,int low,int high) {
        int left = low;
        int right = high;
        if (low > high)
            return;
        int k = nums[left];
        while (left < right) {
            while (nums[right] >= k&&left<right)
            {
                right--;
            }
            nums[left] = nums[right];
            while (nums[left] < k&&left<right)
                left++;
            nums[right] = nums[left];
        }
        nums[left] = k;
        KuaiPai(nums, low, left-1);
        KuaiPai(nums, left+1, high);
    }
    //冒泡排序
    void MaoPao(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            for (int j = 0; j < nums.size()-i-1; j++) {
                if (nums[j] > nums[j+1])
                    swap(nums[j], nums[j+1]);
            }
        }
    }
    //选择排序
    void XuanZe(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            int min =i;
            for (int j = i+1; j < nums.size(); j++) {
                if (nums[min] > nums[j])
                    min = j;
            }
            swap(nums[i], nums[min]);
        }
    }
    //插入排序
    void ChaRu(vector<int>& nums) {
        for (int i = 1; i < nums.size(); i++) {
            int value = nums[i];
            int postion = i;
            while (postion > 0 && nums[postion - 1] > value) {
                swap(nums[postion], nums[postion-1]);
                postion--;
            }
        }
    }
    //大顶堆排序
    // 递归方式构建大根堆(len是arr的长度，index是第一个非叶子节点的下标)
    void adjust(vector<int> &arr, int len, int index)
    {
        int left = 2 * index + 1; // index的左子节点
        int right = 2 * index + 2;// index的右子节点

        int maxIdx = index;
        if (left<len && arr[left] > arr[maxIdx])     maxIdx = left;
        if (right<len && arr[right] > arr[maxIdx])     maxIdx = right;

        if (maxIdx != index)
        {
            swap(arr[maxIdx], arr[index]);
            adjust(arr, len, maxIdx);
        }
    }
    // 堆排序
    void heapSort(vector<int> &arr, int size)
    {
        // 构建大根堆（从最后一个非叶子节点向上）
        for (int i = size / 2 - 1; i >= 0; i--)
        {
            adjust(arr, size, i);
        }

        // 调整大根堆
        for (int i = size - 1; i >= 1; i--)
        {
            swap(arr[0], arr[i]);           // 将当前最大的放置到数组末尾
            adjust(arr, i, 0);              // 将未完成排序的部分继续进行堆排序
        }
    }
};