顺序表学习

结构

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

初始化

void SeqListInit(SeqList* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

头插

void SeqListPushFront(SeqList* ps, SLDateType x)
{
	CheckCacpity(ps);
	for (int i = ps->size; i >= 0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	++ps->size;
}

尾插

void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	CheckCacpity(ps);

	ps->a[ps->size] = x;
	ps->size++;
}

头删

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	int start = 0;
	while (start < ps->size - 1)
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}
	start = 1;
	while (start < ps->size)
	{
		ps->a[start - 1] = ps->a[start];
		++start;
	}

	--ps->size;
}

尾删

void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size);
	if (ps->a == NULL)
		exit(-1);
	ps->a[ps->size - 1] = 0;
	ps->size--;
}

在pos位置插入x

void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	if (pos < 0 || pos > ps->size)
	{
		printf("插入位置不合法\n");
		exit(-1);
	}
	CheckCacpity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos] = x;
	ps->size++;
}

删除pos位置的值

void SeqListErase(SeqList* ps, int pos)
{
	assert(ps && pos < ps->size);

	ps->a[pos] = 0;
	for (int i = pos; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

查找

int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
}

销毁

void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
	free(ps->a);
}

练习题

1.原地移除数组中所有的元素val，要求时间复杂度为O(N)，空间复杂度为O(1)

int removeElement(int* nums, int numsSize, int val){
//方法一
    if(nums==NULL)
        return NULL;
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]==val)
        {
            for(int j=i+1;j<numsSize;j++)
            {
                nums[j-1]=nums[j];   
            }
            numsSize--;
            i--;
        }
    }
    return numsSize;
//方法二
    // if(nums==NULL)
    //     return NULL;
    // int fast=0;
    // int slow=0;
    // while(fast<numsSize)
    // {
    //     if(nums[fast]!=val)
    //     {
    //         nums[slow]=nums[fast];
    //         slow++;
    //     }
    //     fast++;
    // }
    // return slow;
}

2.删除排序数组中的重复项

int removeDuplicates(int* nums, int numsSize){
    // int slow=0;
    // int fast=0;
    // while(fast<numsSize)
    // {
    //     if(nums[slow]!=nums[fast])
    //     {
    //         slow++;
    //         nums[slow]=nums[fast]; 
    //     }
    //     fast++;
    // }
    // return slow+1;
    int count=0;
    int i=0;
    while(i<numsSize-1)
    {
        if(nums[i]==nums[i+1])
        {
            count++;      
        } 
        nums[i+1-count]=nums[i+1];
        i++;
    }
    return numsSize-count;
}

3.合并两个有序数组

int removeDuplicates(int* nums, int numsSize){
    // int slow=0;
    // int fast=0;
    // while(fast<numsSize)
    // {
    //     if(nums[slow]!=nums[fast])
    //     {
    //         slow++;
    //         nums[slow]=nums[fast]; 
    //     }
    //     fast++;
    // }
    // return slow+1;
    int count=0;
    int i=0;
    while(i<numsSize-1)
    {
        if(nums[i]==nums[i+1])
        {
            count++;      
        } 
        nums[i+1-count]=nums[i+1];
        i++;
    }
    return numsSize-count;
}

4.旋转数组

void reversearray(int*nums,int left,int right)
{
    while(left<right)
    {
        int tmp=nums[left];
        nums[left]=nums[right];
        nums[right]=tmp;
        left++;
        right--;
    }
}
void rotate(int* nums, int numsSize, int k){
    k=k%numsSize;
    reversearray(nums,0,numsSize-1-k);
    reversearray(nums,numsSize-k,numsSize-1);
    reversearray(nums,0,numsSize-1);
    return nums;
}

5.数组形式的整数加法

int* addToArrayForm(int* num, int numSize, int k, int* returnSize){
    int maxSize = fmax(numSize, 10);  
    int* arr = (int*)malloc(sizeof(int) * (maxSize + 1)); 
    int carry = 0; 
    int i = numSize - 1;
    int count = 0; 
    while (i >= 0 || k != 0 || carry != 0) {
        int digit = 0;
        if (i >= 0) 
        {
            digit += num[i];  
        }
        digit += k % 10;  
        digit += carry;  
        arr[count++] = digit % 10;  
        carry = digit / 10;  
        i--;  
        k /= 10;  
    }
    int left=0;
    int right=count-1;
    while(left<right)
    {
        int n=arr[left];
        arr[left]=arr[right];
        arr[right]=n;
        left++;
        right--;
    }
    *returnSize=count;
    return arr;
}