顺序表C语言实现附加力扣题

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物
理上存储时，通常以数组和链式结构的形式存储。

2.顺序表

2.1概念及结构
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组
上完成数据的增删查改。
顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储。
   

2. 动态顺序表：使用动态开辟的数组存储。
   

顺序表缺陷：

1、动态增容有性能消耗（频繁地malloc是会有内存消耗的）
2、需要头部插入数据，需要挪动数据

顺序表的实现

接口声明

//初始化
void SeqListInit(SeqList *ps);
//头插
void SeqListPushFront(SeqList *ps, int x);
//尾插
void SeqListPushBack(SeqList *ps,int x);
//头删
void SeqListPopFront(SeqList *ps);
//尾删
void SeqListPopBack(SeqList *ps);
//销毁
void SeqListDestroy(SeqList *ps);
//扩容
void SeqListCreate(SeqList *ps);
//打印
void SeqListprint(SeqList * ps);
//查找
int SeqListFind(SeqList * ps, int x);
//删除
void SeqListErase(SeqList *ps, int pos);
//插入
void SeqListInsert(SeqList *ps, int pos,int x);
//修改
void SeqListmodif(SeqList *ps, int pos, int x);

实现的接口

//初始化
void SeqListInit(SeqList *ps) 
{
    
    
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
//扩容
void SeqListCreate(SeqList *ps) 
{
    
    
	assert(ps);
	
	if (ps->capacity == ps->size) 
	{
    
    
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		int *newA = (int *)realloc(ps->arr, sizeof(int) * newcapacity);
		if (newA == NULL) 
		{
    
    
			perror("SeqListCreate:");
			exit(1);
		}

		ps->arr = newA;
		ps->capacity = newcapacity;
	}
}
//头插
void SeqListPushFront(SeqList *ps,int x) 
{
    
    
	assert(ps);
	SeqListCreate(ps);
	int end = ps->size - 1;
	while (end >= 0) 
	{
    
    
		 ps->arr[end + 1] = ps->arr[end];
		 end--;
	}
	ps->arr[0] = x;
	ps->size++;
}
//尾插
void SeqListPushBack(SeqList *ps,int x) 
{
    
    
	assert(ps);
	SeqListCreate(ps);
	ps->arr[ps->size++] = x;
}
//头删
void SeqListPopFront(SeqList *ps) 
{
    
    
	assert(ps);
	assert(ps->size > 0);
	int begin = 0;
	while (begin  < ps->size) 
	{
    
    
		ps->arr[begin] = ps->arr[begin + 1];
		begin++;
	}
	ps->size--;
}
//尾删
void SeqListPopBack(SeqList *ps) 
{
    
    
	assert(ps);
	assert(ps->size > 0);
	ps->size--;
}
//销毁
void SeqListDestroy(SeqList *ps)
{
    
    
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

//打印
void SeqListprint(SeqList * ps) 
{
    
    
	assert(ps);
	for (int i = 0; i < ps->size; i++) 
	{
    
    
		printf("%d ",ps->arr[i]);
	}
	printf("\n");
}
//查找
int SeqListFind(SeqList * ps, int x)
{
    
    
	assert(ps);
	for (int i = 0; i < ps->size; i++) 
	{
    
    
		if (ps->arr[i] == x) 
		{
    
    
			return i;
		}
	}
	return -1;
}

//删除
void SeqListErase(SeqList *ps, int pos) 
{
    
    
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	while (begin < ps->size) 
	{
    
    
		 ps->arr[begin] = ps->arr[begin + 1];
		 ++begin;
	}
	ps->size--;

}
//插入
void SeqListInsert(SeqList *ps, int pos, int x) 
{
    
    
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	SeqListCreate(ps);
	int end = ps->size - 1;
	while (end >= pos) 
	{
    
    
		ps->arr[end + 1] = ps->arr[end];
		end--;
	}
	
	ps->arr[pos] = x;
	ps->size++;
}

//修改
void SeqListmodif(SeqList *ps, int pos, int x) 
{
    
    
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->arr[pos] = x;
}

顺序表的初始化

初始化表结构的成员

扫描二维码关注公众号，回复： 13149540 查看本文章

//初始化
void SeqListInit(SeqList *ps) 
{
    
    
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

顺序表的销毁

释放在堆上开辟的空间

//销毁
void SeqListDestroy(SeqList *ps)
{
    
    
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

顺序表扩容

面对空间已满，没法再插入数据的情况，需要增容

//扩容
void SeqListCreate(SeqList *ps) 
{
    
    
	assert(ps);
	//空间满了开辟一块新的空间
	if (ps->capacity == ps->size) 
	{
    
    
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		int *newA = (int *)realloc(ps->arr, sizeof(int) * newcapacity);
		if (newA == NULL) 
		{
    
    
			perror("SeqListCreate:");
			exit(1);
		}

		ps->arr = newA;
		ps->capacity = newcapacity;
	}
}

顺序表的头插

头插数据需要考虑是从前往后挪动数据还是从后往前挪动数据，很明显如果是从前往后挪动数据的话，会将原有的数据给覆盖掉，所以只能从后往前，头插的时间复杂度是o(n)

//头插
void SeqListPushFront(SeqList *ps,int x) 
{
    
    
	assert(ps);
	SeqListCreate(ps);
	int end = ps->size - 1;
	//从后往前挪动数据
	while (end >= 0) 
	{
    
    
		 ps->arr[end + 1] = ps->arr[end];
		 end--;
	}
	//头插数据
	ps->arr[0] = x;
	ps->size++;
}

顺序表的尾插

其实顺序表的尾插，时间复杂度o(1)

//尾插
void SeqListPushBack(SeqList *ps,int x) 
{
    
    
	assert(ps);
	SeqListCreate(ps);
	ps->arr[ps->size++] = x;
}

顺序表的遍历打印

遍历顺序表，o(n)的时间复杂度

//打印
void SeqListprint(SeqList * ps) 
{
    
    
	assert(ps);
	for (int i = 0; i < ps->size; i++) 
	{
    
    
		printf("%d ",ps->arr[i]);
	}
}

顺序表的尾删

这里要考虑的是需要判断表中有没有数据，如果没有数据就不需要删除

//尾删
void SeqListPopBack(SeqList *ps) 
{
    
    
	assert(ps);
	assert(ps->size > 0);
	ps->size--;
}

顺序表的头删

将后一个数据覆盖掉前一个数据，最后- -size，因为需要挪动数据所以时间复杂度是o(n)

//头删
void SeqListPopFront(SeqList *ps) 
{
    
    
	assert(ps);
	assert(ps->size > 0);
	int begin = 0;
	while (begin  < ps->size) 
	{
    
    
		ps->arr[begin] = ps->arr[begin + 1];
		begin++;
	}
	ps->size--;
}

顺序表的查找

找到返回该位置的下标，O(N)时间复杂度

//查找
int SeqListFind(SeqList * ps, int x)
{
    
    
	assert(ps);
	for (int i = 0; i < ps->size; i++) 
	{
    
    
		if (ps->arr[i] == x) 
		{
    
    
			return i;
		}
	}
	return -1;
}

删除

删除指定pos位置的元素，可以挪动数据将其覆盖，从前往后的覆盖法，挪动数据时间复杂度O(N)

//删除
void SeqListErase(SeqList *ps, int pos) 
{
    
    
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	while (begin < ps->size) 
	{
    
    
		 ps->arr[begin] = ps->arr[begin + 1];
		 ++begin;
	}
	ps->size--;
}

插入

将pos位置和pos后的数据整体往后一挪动，再将x插入到指定pos位置，注意选择的位置不能超出顺序表的大小
时间复杂度O(N)

void SeqListInsert(SeqList *ps, int pos, int x) 
{
    
    
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	SeqListCreate(ps);
	int end = ps->size - 1;
	while (end >= pos) 
	{
    
    
		ps->arr[end + 1] = ps->arr[end];
		end--;
	}
	
	ps->arr[pos] = x;
	ps->size++;
}

修改

修改该位置的值

void SeqListmodif(SeqList *ps, int pos, int x) 
{
    
    
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->arr[pos] = x;
}

顺序表的问题及思考：

1、顺序表的指定插入和删除都需要挪动数据，时间复杂度为O(N)
2、增容需要申请空间，拷贝数据，释放就空间，会有不小的消耗，一定程度上也会影响效率，增容会存在空间浪费，开大了浪费，开小了又不够

力扣题

27. 移除元素:

点我.

思路一：
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入，找出值为val的位置挪动后面的数据覆盖掉val的值，
时间复杂度是0（N*N）,考虑最坏的情况如果数组中的值全是val的话，每次找出一个值为val的时间复杂度是o(N)，挪动数据又是o(N)，整体就是O(N * N)

思路二：
开辟一个空间足够大的数组，遍历一遍找出原数组将值不为val的，拷贝到新数组中去，时间复杂度是O(N)，空间复杂度是O(N)。空间换时间

思路三：
双指针解法，在原数组的基础上创建一个虚拟数组，src和dest都从0开始，src去找值不为val的，找到后将src位置的值覆盖掉dest位置的值，他们都自增，如果src的值等于val，src就继续找，最后返回dest，时间复杂度是O(N)，空间复杂度是O(1)，

int removeElement(int* nums, int numsSize, int val){
    
    
    if(numsSize == 0)
        return 0;
    int dest = 0;
    int src = 0;
   while(src < numsSize)
   {
    
    
       if(nums[src] != val)
       {
    
    
           nums[dest++] = nums[src++];
       } 
       else
       {
    
    
           src++;
       }
   }

    return dest;
}

26. 删除有序数组中的重复项:

点我.

解题思路：
src和next一前一后，如果src的值不等于dst，就将src的值覆盖在dst的位置上，dst++，next的位置赋值给src，next++找下一个数，在回来判断next位置的值是否与src相等，如果相等继续执行，直到条件为假循环终止
时间复杂度是O(N)，空间复杂度是O(1)

考虑这种情况，如果next已经 > numsize了，循环终止，但是末尾的那个元素还没有拷贝过来

int removeDuplicates(int* nums, int numsSize){
    
    
    if(numsSize == 0)
    {
    
    
        return 0;
    }
    int cur = 0;
    int next = 1;
    int count = 0;
    int dest = 0;
    while(next < numsSize)
    {
    
    
  	   //cur和next将重复的值给过滤掉，只留下一个值给dst
        if(nums[cur] != nums[next])
        {
    
    
        nums[dest++] = nums[cur];
        cur = next;
        ++next;
        }
        else
        {
    
    
          ++next;
        }
    }
    //防止循环终止后，最后一个数据丢失
    if(cur < numsSize)
    nums[dest++] = nums[cur];
    return dest;
}

27. 数组形式的整数加法:

28. 点我.
    .
    测试用例
    

解题思路：
计算出val的十进制位数，取val或数组长度大的那一个作为新数组的大小(存在进位问题)，继续将val的每一位取下来对应的个位、十位、百位…看成与数组元素的一种关联关系，通过不断拆分相加它们之间的和，和值大于10就考虑进位，小于10不进位，最后将这两个值相加得到的和存放到对应的位置上，由于是从低位开始计算的，存在数组的顺序也是倒过来的，所以再最后需要整体一逆转

int* addToArrayForm(int* A, int numSize, int k, int* returnSize){
    
    
    int ksize = 0;
    int num = k;
    //记录num的十进制位数
    while(num)
    {
    
    
        num /= 10;
        ++ksize;
    }

    int reti = 0;
    //扩容一位提供进位
    int len = numSize > ksize ? numSize + 1 : ksize + 1;
    int Ai = numSize - 1;
    int ki = 0;
    int next = 0;//进位
    int *retArr = (int *)malloc(sizeof(int) * len);
    while(Ai >= 0 || ki < ksize)
    {
    
    
    
        int aval = 0;
        if(Ai >= 0)
        aval = A[Ai--];

        int kval = k % 10;
        k /= 10;
       
        ki++;
        int ret = kval + aval + next;
        if(ret >= 10)
        {
    
       
            next = 1;
            ret -= 10;
        }
        else
        {
    
    
            next = 0;
        }
        retArr[reti++] = ret;
    }
    //存放最高位
    if(next == 1)
    {
    
    
        retArr[reti++] = 1;
    }
	//逆置数组
    int begin = 0;
    int end = reti - 1;
    while(begin < end)
    {
    
    
        int tmp = retArr[begin];
        retArr[begin] = retArr[end];
        retArr[end] = tmp;

        begin++;
        end--;
    }
    *returnSize = reti;
    return retArr;
}

旋转数组:

点我.

解题思路：
将数组整体旋转一次，以k为划分左旋转0 ~ k - 1这个区间，
右旋转k ~ numsize - 1区间，整体就是旋转k次的数组，有点类似于左旋转字符串，时间复杂度是O(N + N)，还是O(N）

//逆置数组
void reverse(int* nums1,int *nums2)
{
    
    
   while(nums1 < nums2)
   {
    
    
       int tmp = *nums1;
       *nums1 = *nums2;
       *nums2 = tmp;

       ++nums1;
       --nums2;
   }
   
}

void rotate(int* nums, int numsSize, int k){
    
    
    if(k >= numsSize)
    k %= numsSize;
    //整体旋转
    reverse(nums, nums + numsSize - 1);
    //左旋转
    reverse(nums,nums + k - 1);
    //右旋转
    reverse(nums + k,nums + numsSize - 1);
   
}

合并数组数组:

点我.

解题思路：
从后往前处理，因为两个数组都是有序的，从nums1和nums2中先将最大的数挑出来插入到目标数组，这样目标数组的后index就已经可以确定是有序的了，已经是最大了，最后判断哪个数组还剩元素就继续插入在目标数组中
时间复杂度是O(N)

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    
    
        int i = m - 1, j = n - 1, index = m + n - 1;
        while(i >= 0 && j >= 0)
         nums1[index--] = nums1[i] > nums2[j] ? nums1[i--] : nums2[j--];
        
       
         while(j >= 0)
         nums1[index--] = nums2[j--];
         
}