数据结构2（2022/10/22）

Insisted_G

已于 2022-10-25 13:53:17 修改

阅读量438

点赞数

分类专栏：数据结构文章标签：数据结构 c语言

于 2022-10-23 01:21:55 首次发布

本文链接：https://blog.csdn.net/weixin_66130235/article/details/127469612

版权

数据结构专栏收录该内容

14 篇文章 0 订阅

订阅专栏

顺序表的定义：

顺序表就是数组，只是在数组的基础上，它的要求是从头开始，并且数据是连续存储的。

关于数组的下标：n-1就是最后一个，n-k是倒数第K个

倒数第k个的前一个是n-k-1

旋转数组奇妙方法：（旋转K次）

先把前面N-k个逆序再把倒数k个逆序

最后再整体逆序

需要了解逆序函数：

void reverse(int *arr,int left ,int right)
    
{             //数组名 ，左下标     右下标

        while(left<right)

        {

                int temp=left;

                left=right;

                right=temp;

        }

}



调用的时候
reverse(arr,0,n-k-1);
reverse(arr,n-k,n-1);
reverse(arr.n-1);
三次即可
然后循环输出就行

完整代码

#include<stdio.h>
void reverse(int* nums, int left, int right)
{
	while (left < right)
	{
		int temp = nums[left];
		nums[left] = nums[right];
		nums[right] = temp;
		++left;
		--right;
	}
}

int main()
{
	int i;
	//旋转数组的算法
	int k;
	scanf("%d", &k);
	int arr[10] = {1,2,3,4,5,6,7,8,9,10 };
	//8 9 10 1 2 3 4 5 6 7 
	int n = sizeof(arr) / sizeof(int);
	reverse(arr,n-k,n-1);
	reverse(arr, 0, n - k - 1);
	reverse(arr, 0, n - 1);


		for (i = 0; i <10; i++)
		printf("%d ", arr[i]);
}

动态顺序表的结构体定义:

#pragma once
#include<stdio.h>
#include<stdlib.h>
#define N 100//定义顺序表容量capacity
typedef int SLDataType;
//重命名int，这一步并非无意义，如果输入的类型改了只改int即可 函数内不用变
//接下来定义顺序表结构体
typedef struct SqeList
{
    int capacity; //顺序表的容量
    int size;  //现在顺序表中的元素个数
    SLDataType*a;
}SL;

顺序表的初始化函数

void SeqListInit(SL*ps);
//声明
void SeqListInit(SL*ps)
{
    ps->a=NULL;
    ps->capacity=ps->size=0;
}

初始化就是把顺序表结构体成员访问一遍，指针赋为NULL，其他size 当前大小 capacity 容量

赋值为0

顺序表的尾插法

void SqeListPushBack(SL*ps,SLDataType x)
{
    if(ps->size==ps->capacity)//可能为空或者满
    {
        int newcapacity=capacity*2=0?4:capacity*2;
        SLDataType*temp=realloc(ps->a,sizeof(SLDataType)*newcapacity);
        if(temp==NULL)
        {
            printf("ralloc fail");
            exit(-1);
        }
        ps->capacity=newcapacity;
        ps->a=temp;
    }
    
    
    //正常情况
    ps->a[ps->size]=x;
    ps->size++;
}

if(ps->size==ps->capacity)//可能为空或者满
    {
        int newcapacity=capacity*2=0?4:capacity*2;
        SLDataType*temp=realloc(ps->a,sizeof(SLDataType)*newcapacity);
        if(temp==NULL)
        {
            printf("ralloc fail");
            exit(-1);
        }
        ps->capacity=newcapacity;
        ps->a=temp;
    }
这一段可以单独写一个函数，检查是否需要扩容
void SqeListCheckCapacity(SL*ps)
{
if(ps->size==ps->capacity)//可能为空或者满
    {
        int newcapacity=capacity*2=0?4:capacity*2;
        SLDataType*temp=realloc(ps->a,sizeof(SLDataType)*newcapacity);
        if(temp==NULL)
        {
            printf("ralloc fail");
            exit(-1);
        }
        ps->capacity=newcapacity;
        ps->a=temp;
    }

}
然后上一个的代码就可以简化为
void SqeListPushBack(Sl*p)
{
void SqeListCheckCapacity(SL*ps);//检查是否需要扩容
ps->a[ps->size]=x;
ps->size++;
}

顺序表打印函数

void SeqListPrint(SL*ps)
{    
        int i=0;
        for(i=0;i<p->size;i++)
        {
            printf("%d ",ps->a[i]);
        }
        printf("\n");
}
//把顺序表当成一个数组即可

顺序表的销毁


顺序表的销毁
思想和创建一样的
创建多少小会多少
void SeqListDestory(SL*qs)
{
    free(ps->a);//释放数组
    ps->a=NULL;//指针置空
   ps->capacity=ps->size=0;//值置零
    
}

顺序表尾弹法


void SeqListPushFront(SL*ps)
{
    if(ps->size>0)
        ps->size--;
    //温柔执行
}
或者

void SeqListPushFront(SL*ps)
{
    assert(ps->size>0);
        ps->size--;
//比较暴力，如果 弹出太多程序会提醒你，并且程序不执行
    
}

顺序表的头插法

思想是把后面的依次向后面挪动

void SeqListPushFront(SL*ps,SLDataType x)
{   //首先检查增容
    SeqListCheckCapacity(ps);//检查增容
    int end=ps->size-1;
    while(end>=0)
    {
        ps->a[end]=ps->a[end+1];
        end--;
    }
   ps->a[0]=x; 
   ps->size++;
}

顺序表的头Pop（头弹出）

思想是把后面的依次向前挪动


顺序表的头Pop（头弹出）
void SeqListPopFront(SL*ps)
{   if(qs->size>0)
    
    {
      
    int front=0;
    //从front开始后面的覆盖前面的
    while(front<ps->size-1)
    {
        ps->a[front]=ps->a[front+1];
        front++;
    }
    ps->size--;
    }
}

注意每次增删查改对结构体变量的影响

赠的话ps->size++

ps[ 某个下标]=x;

删的话ps->size--;