力扣数据结构学习攻坚day1

 

 

暴力解：

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;
    }
}