力扣数据结构学习攻坚day1

2022-05-05 15:31:42 阅读：132 来源： 互联网

标签：high 排序 nums int day1 力扣 num low 数据结构

暴力解：

bool containsDuplicate(int* nums, int numsSize){
for(int i=0;i<numsSize-1;i++){
    for(int j=i+1;j<numsSize;j++){
        if(nums[i]==nums[j]){
            return true;
        }else{
            continue;
        }
    }
    
}
return false;
}

算法复杂度为O(n²)

超时是预料之中的，为了解决问题力扣官方推荐有两种方法：1，排序 2，哈希表

1，排序

1.1 快速排序

int Partition(int num[], int low, int high) { //一趟划分
    int pivot = num[low]; 
    while (low < high) {   
        while (low < high && num[high] >= pivot) {
            --high;
        }
        num[low] = num[high];
        while (low < high && num[low] <= pivot) {
            ++low;
        }
        num[high] = num[low];
    }
    num[low] = pivot;
    return low;
}
void QuickSort(int num[], int low, int high) {
    if (low < high) {  //递归调出条件
        int pivotpos = Partition(num, low, high);   //Partition划分为满足上述条件的两个子表//划分
        QuickSort(num, low, pivotpos - 1);        //进行递归
        QuickSort(num, pivotpos + 1, high); 
    }
}

bool containsDuplicate(int* nums, int numsSize){
 QuickSort(nums,0,numsSize-1);
     for (int i = 0; i < numsSize-1; i++) {
         if (nums[i] == nums[i + 1]) {
             
             return true;
         }        
     }
      return false;
}

这里采用最基本的快速排序，我这里让第一个元素作为基准。这是有极大问题的，在最糟糕情况下数组为逆序变为顺序。其算法复杂度为O(n²)，我在408学习中有提出过取三个值的中值作为基准，极端情况基本可以无视。

最后放入leetcode中还是超时。

这说明我们的快速排序还需要优化，因为java中Arrays.sort方法的底层源码使用的是双pivot-快速排序所以使用sort方法的快速排序可以通过，

优化方案可以看这篇文章(55条消息) 快速排序的4种优化_Tyler_Zx的博客-CSDN博客_快速排序优化

1.2 归并排序

void MergeSort(int num[], int low, int high) {
    if (low < high) {
        int mid = (low + high) >> 1;
        MergeSort(num, low, mid);
        MergeSort(num, mid + 1, high);
        Merge(num, low, mid, high);

    }
}
void Merge(int num[], int low, int mid, int high) {
    int* num2 = (int*)malloc((high + 1) * sizeof(int));
    
    for (int k = low; k <= high; k++) {
        num2[k] = num[k];
    }
    int j = 0;
    int i = 0;
    int k = 0;
    for (i = low, j = mid + 1, k = i; i <= mid && j <= high; k++) {
        if (num2[i] <= num2[j]) {
            num[k] = num2[i++];
        }
        else {
            num[k] = num2[j++];
        }
    }
    while (i <= mid)    num[k++] = num2[i++];
    while (j <= high)    num[k++] = num2[j++];
    
}

最后还是超时。。。。。。。

以上两种排序在一般情况下都是O(nlog2n)超时也是意料之中的。因为写这边文章目的是为了408复习，我并没有深入学习排序的优化。

我还是老老实实的用第三方库吧。

int Cmp (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}
bool containsDuplicate(int* nums, int numsSize){
    qsort(nums, numsSize, sizeof(int), Cmp);
     
     
     for (int i = 0; i < numsSize-1; i++) {
         if (nums[i] == nums[i + 1]) {
             
             return true;
         }        
     }

      return false;
      
}

2,哈希表

class Solution {
    public boolean containsDuplicate(int[] nums) {
Set<Integer> set = new HashSet<Integer>();
for (int x :nums){
  if(set.contains(x)){
      return true;
  }else{
      set.add(x);
  }
        }
return false;
    }
}

标签：high,排序,nums,int,day1,力扣,num,low,数据结构
来源： https://www.cnblogs.com/cocogod/p/16222266.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

力扣数据结构学习攻坚day1