基本查找与排序算法总结

最新推荐文章于 2022-07-06 12:16:32 发布

原创最新推荐文章于 2022-07-06 12:16:32 发布 · 543 阅读

0 ·

CC 4.0 BY-SA版权

算法与数据结构专栏收录该内容

2 篇文章

订阅专栏

1. 查找

1.1 二分查找

int BinarySearch (int a[], int n, int key) {
    if (!a) {
        return -1;
    }
    int low=0, high=n-1, mid;
    while (low<=high) {
        mid=(low+high)/2;
        if (a[mid]==key) {
            return mid;
        }
        else if (a[mid]<key) {
            low=mid+1;
        }
        else {
            high=mid-1;
        }
    }
    return -1;
}

2.1 二叉排序树查找

typedef struct BiTNode{
    int data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

//二叉排序树查找
int search_bst (BiTree T, int key, BiTree f, BiTree *p) {
    if (!T) {
        *p=f;
        return 0;
    }
    else if (key == T->data) {
        *p=T;
        return 1;
    }
    else if (key<T->data) {
        return search_bst(T->lchild, key, T, p);
    }
    else {
        return search_bst(T->rchild, key, T, p);
    }
}

2. 排序

2.1 冒泡排序

void BubbleSort (int a[], int n) {
    int i, j, k;
    for (i=0; i<n-1; i++) {
        for (j=n-2; j>=i; j--) {
            if (a[j]>a[j+1]) {
                k=a[j];
                a[j]=a[j+1];
                a[j+1]=k;
            }
        }
    }
}

2.2 选择排序

void SelectSort (int a[], int n) {
    int i, j, min, k;
    for (i=0; i<n-1; i++) {
        min=i;
        for (j=i+1; j<=n-1; j++) {
            if (a[min]>a[j]) {
                min=j;
            }
        }
        if (min!=i) {
            k=a[i];
            a[i]=a[min];
            a[min]=k;
        }
    }
}

2.3 插入排序

void InsertSort (int a[], int n) {
    int i, j, k;
    for (i=1; i<n; i++) {
        if (a[i]<a[i-1]) {
            k=a[i];
            for (j=i-1; a[j]>k && j>=0; j--) {
                a[j+1]=a[j];
            }
            a[j+1]=k;
        }
    }
}

2.4 希尔排序

void ShellSort (int a[], int n) {
    int i, j, k, increment;
    for (increment=(n-1)/3+1; increment>0; increment=increment/3+1) {
        for (i=increment; i<n; i++) {
            if (a[i]<a[i-increment]) {
                k=a[i];
                for (j=i-increment; a[j]>k && j>=0; j-=increment) {
                    a[j+increment]=a[j];
                }
                a[j+increment]=k;
            }
        }
    }
}

2.5 堆排序

void HeapAdjust (int a[], int n, int s, int m) {
    int i, k=a[s];
    for (i=2*(s+1)-1; i<=m; i=2*(i+1)-1) {
        if (i<m && a[i]<a[i+1]) {
            i++;
        }
        if (k>a[i]) {
            break;
        }
        a[s]=a[i];
        s=i;
    }
    a[s]=k;
}

void HeapSort(int a[], int n) {
    int i, k;
    for (i = n/2-1; i>=0; i--) {
        HeapAdjust (a, n, i, n-1);
    }
    for (i=n-1; i>0; i--) {
        k=a[0];
        a[0]=a[i];
        a[i]=k;
        HeapAdjust (a, n, 0, i-1);
    }
    
}

2.6 归并排序

2.6.1 递归实现

void Merge (int temp[], int result[], int first1, int last1, int last2) {
    int first2=last1+1, resultIndex, i;
    for (resultIndex=first1; first1<=last1 && first2<=last2; resultIndex++) {
        if (temp[first1]<temp[first2]) {
            result[resultIndex]=temp[first1++];
        }
        else {
            result[resultIndex]=temp[first2++];
        }
    }
    if (first1<=last1) {
        for (i=0; i<=last1-first1; i++) {
            result[resultIndex+i]=temp[first1+i];
        }
    }
    if (first2<=last2) {
        for (i=0; i<=last2-first2; i++) {
            result[resultIndex+i]=temp[first2+i];
        }
    }
}

void MergeSort (int init[], int result[], int first,int last) {
    int middle, temp[MAXSIZE];
    if (first==last) {
        result[first]=init[first];
    }
    else {
        middle=(first+last)/2;
        MergeSort(init, temp, first, middle);
        MergeSort(init, temp, middle+1, last);
        Merge(temp, result, first, middle, last);
    }
}

2.6.2 非递归实现

void MergePass (int a[],int b[], int s, int n) {
    int i=0, j;
    while (i<=n-2*s) {
        Merge(a, b, i, i+s-1, i+2*s-1);
        i=i+2*s;
    }
    if (i<n-s) {
        Merge(a, b, i, i+s-1, n-1);//最后剩下的个数大于一个s，小于2s
    }
    else {
        for (j=i; j<n; j++) {
            b[j]=a[j];
        }
    }
}

void MergeSort (int a[], int n) {
    int temp[n], k=1;
    while (k<n) {
        MergePass (a, temp, k, n);
        k=2*k;
        MergePass (temp, a, k, n);
        k=2*k;
    }
}

2.7 快速排序

int Partition (int a[], int low, int high) {
    int pivotkey=a[low], k;
    while (low<high) {
        while (low<high && a[high]>=pivotkey) {
            high--;
        }
        k=a[low];
        a[low]=a[high];
        a[high]=k;
        while (low<high && a[low]<=pivotkey) {
            low++;
        }
        k=a[low];
        a[low]=a[high];
        a[high]=k;
    }
    return low;
}

void QuickSort (int a[], int low, int high) {
    int pivot;
    if (low<high) {
        pivot=Partition(a, low, high);
        QuickSort(a, low, pivot-1);
        QuickSort(a, pivot+1, high);
    }
}

2.8 排序算法比较

排序算法比较
排序算法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
插入排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
希尔排序	O(nlgn)~O(n^2)	O(n^1.3)	O(n^2)	O(1)	不稳定
堆排序	O(nlgn)	O(nlgn)	O(nlgn)	O(1)	不稳定
归并排序	O(nlgn)	O(nlgn)	O(nlgn)	O(n)	稳定
快速排序	O(nlgn)	O(nlgn)	O(n^2)	O(lgn)~O(n)	不稳定
桶排序	O(n+c)	O(n)	O(nlgn)	O(n+m)	稳定
计数排序	O(n+k)	O(n+k)	O(n+k)	O(n+k)	稳定
基数排序	O(n)	O(n)	O(n)	O(n+k)	稳定