学习笔记--

#include <stdio.h>

//顺序表的定义---静态分配

#define MaxSize 10		//定义最大长度

typedef struct {
	int data[MaxSize];	//用静态的“数组”存放数据元素
	int length;			//顺序表的当前长度
}SqList;				//顺序表的类型定义

//初始化一个顺序表
void InitList(SqList & L) {
	for(int i = 0; i < MaxSize; i++)
		L.data[i] = 0;	 //将所有数据元素设置为默认初始值
	L.length = 0;		 //顺序表初始长度为0
}

int main() {
	SqList L;			//声明一个顺序表
	InitList(L);		//初始化顺序表

	return 0;
}

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

//顺序表的定义---动态分配

#define InitSize 10		//顺序表的初始长度

typedef struct {
	int	*data;			//指示动态分配数组的指针
	int MaxSize;		//顺序表的最大容量
	int length;			//顺序表的当前长度
}SeqList;

//初始化一个顺序表
void InitList(SeqList &L) {
	L.data = (int*)malloc(InitSize * sizeof(int));	//用 malloc 函数申请一片连续的存储空间
	L.length = 0;
	L.MaxSize = InitSize;
}

//增加动态数组的长度
void IncreaseSize(SeqList& L, int len) {
	int	*p = L.data;
	L.data = (int*)malloc((L.MaxSize + len) * sizeof(int));

	for (int i = 0; i < L.length; i++) {
		L.data[i] = p[i];					//将数据复制到新区域
	}

	L.MaxSize = L.MaxSize + len;			//顺序表最大长度增加 len
	free(p);								//释放原来的内存空间
}

int main() {
	SeqList L;		//声明一个顺序表
	InitList(L);	//初始化顺序表
	//... 往顺序表中随便插入几个元素...
	IncreaseSize(L, 5);
	return 0;
}

#include<stdio.h>

//顺序表的基本操作---插入
#define MaxSize 10		//定义最大长度
typedef struct {
	int data[MaxSize];	//用静态的"数组"存放数据元素
	int length;			//顺序表的当前长度
}SqList;				//顺序表的类型定义

bool ListInsert(SqList& L, int i, int e) {		//在顺序表L的位序i处 插入元素e
	if (i<1 || i>L.length + 1)		//判断i的范围是否有效
		return false;
	if (L.length > MaxSize)			//当前存储空间已满,不能插入
		return false;

	for (int j = L.length; j >= i; j--)	 //将第i个元素及之后的元素后移
		L.data[j] = L.data[j - 1];		 //让数组中6的位置  =   6-1=5		(从后往前说: 把5位置的数据放到 6上,即后移了)
	
	L.data[i - 1] = e;		//在位置i处放入e
	L.length++;				//长度加1
	return true;
}

int main() {
	SqList L;		//声明一个顺序表
	InitList(L);	//初始化顺序表
	//.........
	ListInsert(L, 3, 3);
	return 0;
}

#include<stdio.h>

//顺序表的基本操作---删除
#define MaxSize 10		//定义最大长度
typedef struct {
	int data[MaxSize];	//用静态的"数组"存放数据元素
	int length;			//顺序表的当前长度
}SqList;				//顺序表的类型定义

bool ListDelete(SqList &L, int i, int &e) {		//删除 顺序表L的 位序i处 元素 , 然后把此次删除的那个元素用 e这个变量返回
	if (i<1 || i>L.length)				//判断i的范围是否有效
		return false;
	e = L.data[i - 1];		//将被删除的元素赋值给e
	
	for (int j = i; j < L.length; j++)	//将第i个位置后的元素 依次前移
		L.data[j - 1] = L.data[j];		//让数组中6-1=5的位置  =  6	(从后往前说: 把6位置的数据放到 5上,即前移了)
	
	L.length--;			//线性表长度减1
	return true;
}

int main() {
	SqList L;		//声明一个顺序表
	InitList(L);	//初始化顺序表
	//.........
	int e = -1;		//用变量e把删除的元素"带回来"		先定义一个和本顺序表中存储的这些元素同类型的一个变量,所以定义一个int型变量 e , 并设置初始值-1
	
	if (ListDelete(L, 3, e))	//
		printf("已删除第3个元素,删除元素值为=%d\n", e);
	else
		printf("位序i不合法,删除失败\n");
	return 0;
}

#include<stdio.h>

//顺序表的基本操作---按位查找		GetElem(L,i)	获取表L中第i个位置的元素的值
/*
#define MaxSize 10		//定义最大长度  
typedef struct {
	int data[MaxSize];	//用静态的"数组"存放数据元素 (静态分配)
	int length;				//顺序表的当前长度
} SeqList;					//顺序表的类型定义(静态分配方式)

int GetElem(SeqList L, int i) {		//和访问普通数组的方法一样
	return L.data[i - 1];
}
*/

#define InitSize 10		//顺序表的初始长度
typedef struct {
	int *data;		//指示 动态分配 数组的指针
	int MaxSize;	//顺序表的最大容量
	int length;		//顺序表的当前长度
} SeqList;			//顺序表的类型定义(动态分配方式)

int GetElem(SeqList L, int i) {		//和访问普通数组的方法一样
	return L.data[i - 1];

#include<stdio.h>

//顺序表的基本操作---按值查找		LocateElem(L,e)		  在表L中查找具有给定关键字值的元素
							

#define InitSize 10		//顺序表的初始长度

typedef struct {
	int *data;		//指示动态分配数组的指针
	int MaxSize;		//顺序表的最大容量
	int length;			//顺序表的当前长度
} SeqList;				//顺序表的类型定义(动态分配方式)

//在顺序表L中查找第一个元素值等于e的元素,并返回其位序
int LocateElem(SeqList L, int e) {
	for (int i = 0; i < L.length; i++)
		if (L.data[i] == e)
			return  i + 1;	//数组下标为i的元素值等于e,返回其位序i+1
	return 0;				//退出循环,说明查找失败
}

/*
从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。
空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行
*/
#include<bits/stdc++.h>
using namespace std;
#define Max 50
struct SqList{
    int a[Max]={};
    int length=0;
};
bool listdelete(SqList &s,int &ele)
{
    if(s.length==0)
        return false;
    int minn=s.a[0];
    int flag=0;
    for(int i=1;i<s.length;i++)
    {
        if(s.a[i]<minn)
        {
            minn=s.a[i];flag=i;
        }
    }
    ele=s.a[flag];
    s.a[flag]=s.a[s.length-1];
    return true;
}
int main()
{
   SqList s;
   cout<<"原先数组为:"<<endl;
   for(int i=0;i<s.length;i++) cout<<s.a[i]<<" ";
   cout<<endl;
   int k=0;
   if(listdelete(s,k))
   {
       cout<<"最小元素k="<<k<<endl;
       cout<<"修改之后的线性表为:"<<endl;
       for(int i=0;i<s.length;i++)
       {
           cout<<s.a[i]<<" ";
       }
       cout<<endl;
   }
   else{
       cout<<"错误"<<endl;
   }
    return 0;
}

//逆置线性表
#include<bits/stdc++.h>
using namespace std;
#define Max 50
struct SqList{
    int a[Max]={1,4,6,3,2,8,7};
    int length=7;
};
void reverse(SqList &L)
{
    for(int i=0;i<L.length/2;i++)
    {
        int v=L.a[i];
        L.a[i]=L.a[L.length-i-1];
        L.a[L.length-i-1]=v;
    }
}
int main()
{
    SqList L;
    for(int i=0;i<L.length;i++) cout<<L.a[i]<<" ";
    cout<<endl;
    reverse(L);
    for(int i=0;i<L.length;i++) cout<<L.a[i]<<" ";
    return 0;
}

链表