数据结构与算法-排序

交换排序

• 冒泡排序

void bubble_sort(int num[], int n) {
    bool flag;
    for (int i = 0; i < n-1; i++) {
        for (int j = n-1; j > i; j--) {
            flag = true;
            if (num[j-1] > num[j]) {
                swap(num[j-1], num[j]);
                flag = false;
            }
            if (flag) {
                break;
            }
        }
    }
}

• 快速排序

int position(int num[], int left, right) {
    int temp = num[left];
    while (left < right) {
        while (left < right && num[right] >= temp) {
            right--;
        }
        num[left] = num[right];
        while (left < right && num[left] <= temp) {
            left++;
        }
        num[right] = num[left];
    }
    num[left] = temp;
}
void quick_sort(int num[], int left, int right) {
    if (left < right) {
        int pos = position(num, left, right);
        quick_sort(num, left, pos-1);
        quick_sort(num, pos+1, right);
    }
}
https://blog.youkuaiyun.com/jlqCloud/article/details/46939703

插入排序

• 直接插入排序

void insert_sort(int num[], int n) {
    int temp;
    for (int i = 1; i < n; i++) {
        if (num[i-1] > num[i]) {
            temp = num[i];
            int j;
            for (j = i-1; j >= 0 && num[j] > temp; j--) {
                num[j+1] = num[j];
            }
            num[j+1] = temp;
        }
    }
}

• 折半插入排序

void half_insert_sort(int num[], int n) {
    int temp, low, high, mid;
    for (int i = 1; i < n; i++) {
        if (num[i-1] > num[i]) {
            temp = num[i];
            low = 0; high = i-1;
            while (low <= high) {
                mid = (low+high)/2;
                if (num[mid] > temp) {
                    high = mid-1;
                } else {
                    low = mid+1;
                }
            }
            int j;
            for (j = i-1; j >= high+1; j--) {
                num[j+1] = num[j];
            }
            num[high+1] = temp;
        }
    }
}

• 希尔排序

void shell_sort(int num[], int n) {
    for (int d = n/2; d >= 1; d /= 2) {
        for (int i = d; i <n; i++) {
            int inserted = num[i];
            if (num[i-d] > inserted) {
                int j;
                for (j = i-d; j >=0 && num[j] > inserted; j -= d) {
                    num[j+d] = num[j];
                }
                num[j+d] = inserted;
            }
        }
    }
}

选择排序

• 简单选择排序

void select_sort(int num[100], int n) {
    int minn;
    for (int i = 0; i < n-1; i++) {
        minn = i;
        for (int j = i+1; j < n; j++) {
            if (num[minn] > num[j]) {
                minn = j;
            }
        }
        if (minn != i) {
            swap(num[minn], num[i]);
        }
    }
}

• 堆排序

void heapAdjust(int num[100], int start, int end) {
    int child;
    while (start*2+1 <= end) {
        child = start*2+1;
        if (child+1 <= end && num[child] < num[child+1]) {
            child++;
        }
        if (num[start] < num[child]) {
            swap(num[start], num[child]);
        } else {
            break;
        }
        start = child;
    }
}
void heapSort(int num[100], int n) {
    // 先将堆调整为大根堆
    for (int i = n/2-1; i >= 0; i--) {
        heapAdjust(num, i, n-1);
    }
    for (int i = n-1; i > 0; i--) {
        swap(num[0], num[i]);
        heapAdjust(num, 0, i-1);
    }
}

合并排序

int* b = new int[N];
void merge(int a[], int begin, int mid, int end)
{
    int i = begin, j = mid+1, k = begin;
    while(i <= mid && j <= end)
    {
        if(a[i] < a[j])
            b[k++] = a[i++];
        else
            b[k++] = a[j++];
    }
    while(i <= mid) b[k++] = a[i++];
    while(j <= end) b[k++] = a[j++];
    for(i = begin; i <= end; i++)
        a[i] = b[i];
}
void mergeSort(int a[], int begin, int end)
{
    if(begin < end)
    {
        mergeSort(a, begin, (begin+end)/2);
        mergeSort(a, (begin+end)/2+1, end);
        merge(a, begin, (begin+end)/2, end);
    }
}

计数排序

void count_sort(int num[], int n, int res[]) {
    int minn = num[0], maxx = num[0];
    // 找出数组中最大值和最小值
    for (int i = 1; i < n; i++) {
        if (minn > num[i]) {
            minn = num[i];
        }
        if (maxx < num[i]) {
            maxx = num[i];
        }
    }
    // 计算一共需要多少计数空间
    int d = maxx - minn;
    int* countArray = new int[d + 1];
    // 计数
    for (int i = 0; i < d+1; i++) {
        countArray[i] = 0;
    }
    for (int i = 0; i < n; i++) {
        countArray[num[i] - minn]++;
    }
    // 累加，数组中的值为对应的元素在结果排列中的位置
    for (int i = 1; i < n; i++) {
        countArray[i] += countArray[i-1];
    }
    for (int i = n-1; i >= 0; i--) {
        res[countArray[num[i]-minn]-1] = num[i];
        countArray[num[i]-minn]--;
    }
}