顺序表相关题目实现(C)

主体框架

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 50
typedef int ElemType;

typedef struct
{
    ElemType data[MAX_SIZE];
    int length;
} Sqlist;

int is_empty(Sqlist *l)
{
    if (l->length == 0)
        return 1;
    return 0;
}

void display(Sqlist *l)
{
    if (is_empty(l))
    {
        printf("NULL\n");
        return;
    }

    for (int i = 0; i < l->length; i++)
        printf("%d ", l->data[i]);

    printf("\n");
}

int main()
{

    return 0;
}

Q1

 先遍历一遍顺序表，找到最小元素并记录其下标，然后将顺序表最后的元素放在其下标位置，顺序表长度-1

// 1.删除最小元素(唯一),把最小值返回,空出的位置由最后一个元素填补
ElemType Del_min(Sqlist *l)
{
    if (is_empty(l))
    {
        printf("NULL\n");
        return -1;
    }
    int idx = 0;
    ElemType min = l->data[0];
    for (int i = 1; i < l->length; i++)
    {
        if (l->data[i] < min)
        {
            min = l->data[i];
            idx = i;
        }
    }
    l->data[idx] = l->data[l->length - 1];
    l->length--;
}

Sqlist L = {{0,1,2,3,4,5},6};
printf("raw list: ");
display(&L);
Del_min(&L);
printf("delete min and alter to end: ");
display(&L);

 

Q2

 空间复杂度为1，也就是inplace。

对称交换，a[0] <--> a[n]   a[1] <--> a[n-1]    a[i]  <--> a[n-i]，因为是对称交换，所以循环n/2次即可

// 2.逆置,空间复杂度O(1)(inplace)
void Reverse(Sqlist *l)
{
    ElemType temp;
    for (int i = 0; i < l->length / 2; i++)
    {
        temp = l->data[i];
        l->data[i] = l->data[l->length - 1 - i];
        l->data[l->length - 1 - i] = temp;
    }
}

Sqlist L = {{0, 1, 2, 3, 4, 5}, 6};
printf("raw list: ");
display(&L);
Reverse(&L);
printf("Reverse: ");
display(&L);

Q3

依然是inplace，时间复杂度O(n)，允许单层总循环。

设置一个下标k，遇到不为x的元素保存到[k++]，不为x的不执行任何操作，最后表长即为k

// 3.时间O(n),空间O(1),删除所有x
void Del_all_x(Sqlist *l, ElemType x)
{
    int k = 0;
    for (int i = 0; i < l->length; i++)
    {
        if (l->data[i] != x)
            l->data[k++] = l->data[i];
    }
    l->length = k;
}

Sqlist L = {{0, 1, 2, 2, 2, 5}, 6};
printf("raw list: ");
display(&L);
Del_all_x(&L, 2);
printf("Del all x: ");
display(&L);
return 0;

Q4

表为有序表，可以设置两个下标框出s~t，后面的前移，修改表长

// 4.有序顺序表中删除s~t的数,s<t
int Del_order_st(Sqlist *l, ElemType s, ElemType t)
{
    if (is_empty(l))
        return 0;
    if (s >= t)
    {
        printf("s t not fit!!!\n");
        return 0;
    }
    // 表在s左与在t右的情况
    if (l->data[0] >= t || l->data[l->length - 1] <= s)
        return 0;
    int a = 0, b = 0; // 两个框定下标
    for (a; l->data[a] <= s; a++)
        ;
    b = a - 1;
    for (a; l->data[a] <= t; a++)
        ;
    for (int i = b; i < a; i++)
    {
        l->data[i] = l->data[l->length - (a - b) + i];
    }
    l->length = l->length - 1 - (a - b - 1);
    return 1;
}

Sqlist L = {{3, 4, 5, 6, 7, 8}, 6};
printf("raw list: ");
display(&L);
Del_order_st(&L, 4, 6);
printf("Del s t: ");
display(&L);
return 0;

Q5 

 设置下标k，遍历一遍，不在s t内的[k++]

// 5.顺序表中删除s~t的数,s<t
int Del_st(Sqlist *l, ElemType s, ElemType t)
{
    if (is_empty(l))
        return 0;
    if (s >= t)
    {
        printf("s t not fit!!!\n");
        return 0;
    }
    int k = 0;
    for (int i = 0; i < l->length; i++)
    {
        if (l->data[i] < s || l->data[i] > t)
            l->data[k++] = l->data[i];
    }
    l->length = k;
    return 1;
}

Sqlist L = {{3, 4, 5, 6, 7, 8}, 6};
printf("raw list: ");
display(&L);
Del_st(&L, 4, 6);
printf("Del s t: ");
display(&L);
return 0;

Q6 

 设置下标k，遍历原表，如果此时arr[k]<arr[i]，则[++k]，最后表长即为k

// 6.有序表删除所有重复元素
void Del_common(Sqlist *l)
{
    int k = 0;
    for (int i = 1; i < l->length; i++)
    {
        if (l->data[k] < l->data[i])
            l->data[++k] = l->data[i];
    }
    l->length = ++k;
}

Sqlist L = {{1, 2, 2, 3, 3, 6}, 6};
printf("raw list: ");
display(&L);
Del_common(&L);
printf("Del common: ");
display(&L);
return 0;

Q7 

两表都为有序表， 设置两下标一一对比，小的加入新表，下标+1，完成后判断哪个表还有剩余元素，把剩余元素放入新表

// 7.合并两个有序表
Sqlist *Cat(Sqlist *l_1, Sqlist *l_2)
{
    int i = 0, j = 0, k = 0;
    if (is_empty(l_1) && is_empty(l_2))
        return NULL;
    Sqlist *lst = (Sqlist *)malloc(sizeof(Sqlist));
    ElemType min;
    while (j < l_1->length && k < l_2->length)
    {
        if (l_1->data[j] < l_2->data[k])
            min = l_1->data[j++];
        else if (l_1->data[j] == l_2->data[k])
        {
            min = l_1->data[j++];
            k++;
        }
        else
            min = l_2->data[k++];
        lst->data[i++] = min;
    }
    // 判断哪个没弄完，再弄完
    if (j == l_1->length)
    {
        for (k; k < l_2->length; k++)
            lst->data[i++] = l_2->data[k];
    }
    else
    {
        for (j; j < l_1->length; j++)
            lst->data[i++] = l_1->data[j];
    }
    lst->length = i;
    return lst;
}

Sqlist L1 = {{1, 3, 5}, 3};
Sqlist L2 = {{2, 3, 4, 6, 7}, 5};
printf("list1: ");
display(&L1);
printf("list2: ");
display(&L2);
Sqlist *lst = Cat(&L1, &L2);
if (lst) // 判不为NULL
{
    printf("Cated: ");
    display(lst);
}
return 0;

Q8 

原地操作，后面元素与前面元素交换，前m个元素整体后移1位，进行m次

// 8.[m+n] 调换成 [n+m] n m 为位序号
void exchange(int *arr, int m, int n)
{
    if (m + n == 0)
        return;
    int temp;
    for (int i = m; i < m + n - m; i++) // 用n即可,n是最后位序
    {
        temp = arr[i];
        for (int j = i; j > i - m; j--)
            arr[j] = arr[j - 1];
        arr[i - m] = temp;
    }
}

int arr[] = {1, 3, 5, 2, 4, 6};
printf("raw: ");
for (int i = 0; i < 6; i++)
    printf("%d ", arr[i]);
exchange(arr, 3, 6);
printf("\nexchanged: ");
for (int i = 0; i < 6; i++)
    printf("%d ", arr[i]);
return 0;

Q9 

 要求最少时间，又是有序递增，采用二分查找(二分查找找不到时high为x前一元素的下标)

void bin_oprt(int *arr, int x)
{
    int len = 0, flag = 0;
    while (arr[len] != 0)
        len++;
    if (len == 0)
        return;
    int low = 0, high = len - 1, mid;
    while (low <= high)
    {
        mid = (low + high) / 2;
        if (arr[mid] < x)
            low = mid + 1;
        else if (arr[mid] == x)
        {
            flag = 1;
            break;
        }
        else
            high = mid - 1;
    }
    if (flag)
    { // 假设必有后继
        arr[mid] = arr[mid + 1];
        arr[mid + 1] = x;
    }
    else
    { // 假设空间足够
        for (int i = len; i > high; i--)
            arr[i] = arr[i - 1];
        arr[high + 1] = x; // 找不到的情况是high为x的前一元素
    }
}

int arr[10] = {1, 2, 3, 4, 6, 7};
printf("raw:");
for (int i = 0; arr[i] != 0; i++)
    printf("%d ", arr[i]);
printf("\n");

printf("finded case x=3:  ");
bin_oprt(arr, 3);
for (int i = 0; arr[i] != 0; i++)
    printf("%d ", arr[i]);
printf("\n");

int ar[10] = {1, 2, 3, 4, 6, 7};
printf("not find case x=5:  ");
bin_oprt(ar, 5);
for (int i = 0; ar[i] != 0; i++)
    printf("%d ", ar[i]);
printf("\n");
return 0;