数据结构算法一.顺序表

一，顺序表（静态分配）

#define MaxSize 10				//定义最大长度
typedef struct{
	ElemType data[MaxSize];		//用静态的“数组”存放数据元素
	int length;					//顺序表的当前长度
}SqList;						//顺序表的类型定义（静态分配方式）

void InitList(SqList *l){
    for(int i=0;i<Maxsize;i++){
         l->data[i]=0;
       }
     length=0;
}

二，顺序表(动态分配）

#define Maxsize 1000

typedef struct {
    int *elem;
    int length;
}Sqlist;
int Initlist(Sqlist *L){
    L->elem=(int *)malloc(sizeof(int)*Maxsize);
    if(L->elem==NULL)return 0;
    L->length=0;
    return 1;
}

typedef struct List{
    int *array;//等价于int *array，指向顺序表的底层数组的指针
    int capacity;//表示底层数组的容量
    int size;//表中的元素数量
}List,*ArrayList;

int initList(ArrayList list1,int n){
     //使用malloc函数申请n个int大小的内存空间，作为底层数组使用
    list1->array=(int *)malloc(n*sizeof(int));
    if(list1 ->array==NULL){//判断内存申请是否成功
     return 0;
     exit(0);
    }
    list1->capacity=n;//容量同样设定为n
    list1->size=0;//元素数量默认为0
    return 1;
}

创建一个含有n个整型元素的顺序表，并输出该顺序表中的n个元素。

输入：

第一行是一个整数n，表示顺序表中的元素个数； 

第二行依次输入n个元素（以空格间隔）。

输出：

输出顺序表中的所有元素，用单个空格作为元素间的分隔符。

typedef struct {
        int *elem;
        int length;
        int listsize;
}SqList;
Status InitList_Sq(SqList *L)

void InputList_Sq(SqList *L, int n) {
        for(int i=0;i<n;i++){
            scanf("%d",&L->elem[i]);
            L->length++;
    
        }
}
void PrintList_Sq(SqList L,int n){
        for(int i=0;i<n;i++){
            printf("%d ",L.elem[i]);
        }
}

int main()
{
        int n;
        scanf("%d",&n);
        SqList SL;
        InitList_Sq(&SL);
        InputList_Sq(&SL, n);
        PrintList_Sq(SL,n);
        return 0;

}

三，基础算法

1.递增序列，插入数字，保持递增

void Inser(Sqlist *l,int e){
    int temp,pos;
    l->length++;
    if(l->length>Maxsize){
        int *newbase=(int*)realloc(l->elem,sizeof(int)*(Maxsize+Newsize));
        if(!newbase){
            exit(0);
        }
        l->elem=newbase;
        l->listsize+=Newsize;
    }
    for(int i=0;i<l->length;i++){
        if(l->elem[i-1]<=e &&l->elem[i]>=e){
            pos=i;
        }
    }
    for(int i=l->length-1;i>=pos;i--){
        l->elem[i]=l->elem[i-1];
    }
    l->elem[pos]=e;
    
}

二，插入

创建一个含有n个整型元素的顺序表，在顺序表的第i个元素前插入一个新元素，并输出插入元素后的顺序表。 

输入：

第一行输入元素个数n；

第二行依次输入n个元素（以空格间隔）；

第三行输入指定的位置i；

第四行输入待插入的元素x。 

Table* add(Table* ptable, int num, int pos) {
	// 判断参数是否可以执行(插入位置超出范围)
	// 插入范围: pos(0到ptable->length)
	if (pos < 0 || pos >ptable->length) {
		printf("插入位置错误\n");
		return 0;
	}
	// 能够插入
	// 判断是否有存储空间_如果存储空间不足则扩容
	if (ptable->length >= Maxsize) {
		// 扩容:(动态内存扩容具体内容见往期文章_指针(三)动态内存)
		// 1. 记录原来的内存
		int* pTemp = ptable->head; // 只有head涉及内存,无需Table*只需使用int*即可

		// 2. 申请新的内存
		ptable->head = (int*)calloc(sizeof(int), ptable->size *= 2); // 以2倍方式扩容并更改size值
		// 判断扩容是否成功(内容与Table.c_16行代码类似)
		if (!ptable->head) {
			printf("动态内存申请失败! 未成功扩容_未添加元素");
			// 未成功扩容则把原来的内存恢复(不能丢弃)
			ptable->head = pTemp;
			return ptable;
		}
		// 3. 拷贝新的内存
		for (size_t i = 0; i < ptable->length; i++)
		{
			ptable->head[i] = pTemp[i];
		}
		// 4. 释放原来的内存
		free(pTemp);
		// 5. 置空
		pTemp = NULL;   //防止变成野指针
	}
	// 插入:
	// 1.后移(先移动后面的元素)
	for (int i = ptable->length; i >= pos; i--)
	{
		ptable->head[i + 1] = ptable->head[i];
	}
	// 2.插入
	ptable->head[pos] = num;
	// 3.更改长度
	ptable->length++;
	return ptable;
}

三，从顺序表L中删除其值在给定值s与t之间(包含s和t,要求s<t)的所有元素,如果s或t不合理或顺序表为空,则显示出错信息并退出运行。

void Delete(Sqlist *L,int min,int max){
    if(min>=max ||L->length==0 ||L->elem[0]>max ||L->elem[L->length-1]<min){
        printf("-1");exit(0);
    }
    int t=0,k=0;
    while(t<L->length){
        if(L->elem[t]>=min && L->elem[t]<=max) k++;
        else L->elem[t-k]=L->elem[t];
        t++;
    }
    L->length-=k;
}

四，删除顺序表L中第i个元素起的k个元素。

#define N 100
typedef struct 
{
    int data[N];
    int last;
}Array;

void Delet(Array *L,int i,int k)
{
    int j;
    if((i < 1)||(i > L->last+1 ))
    {
        printf("删除位置不合理");
    }
    for(j = i;j <= L->last;j++)
    {
        L->data[j-1] = L->data[j + k-1];
    }
    L->last = L->last-k;
}

五，找最大值最小值

#include <stdio.h>
 
/*
题目：天勤40页思考题(3)
在一个有n个整数的顺序表L中，以不多于3n/2的平均比较次数，找出最大值和最小值
即
通过一次遍历顺序表找出顺序表的最大值和最小值，平均比较次数=n<3n/2
*/
 
#define maxlen 50
#define DATATYPE int
 
typedef struct{
    DATATYPE arr[maxlen];
    int length;
}Seqlist;
 
int main(void){
    Seqlist list = {{11,34,2,1,3},5};
 
    int max = list.arr[0];
    int min = max;
 
    for(int i=1;i<list.length;i++){
        if(list.arr[i] < min){
            min = list.arr[i];
        }
        if(list.arr[i] > max){
            max = list.arr[i];
        }
    }
 
    printf("the max,min values are %d,%d\n",max,min);
 
}

六，删除最小元素

#define maxSize 100
typedef struct SqList
{
	int data[maxSize];
	int len = 0;	//顺序表当前的长度 
}SqList;

/*遍历整个顺序表，找出最小的值的下标，并返回*/
void DeleteMin(SqList &l, int &min)
{
	min = l.data[0];	//先假设顺序表的0号位置为最小值 
	int pos = 0;	//pos表述最小值的下标
	for (int i=1; i<l.len; ++i)
	{
		if (l.data[i] < min)
		{
			min = l.data[i];
			pos = i;
		}	
	}
	cout << l.data[pos] << endl; 
	l.data[pos] = l.data[l.len-1];	//顺序表最后一个元素将最小元素的位置补上
	l.len--;	//顺序表当前长度减一 
}

七，合并：给定两个非递减的整数序列A和B，利用顺序存储表示序列A和B，将A和B合并为一个非递减的有序序列C，序列C允许有重复的数据元素。要求空间复杂度为O(1)。 

输入:

第一行为序列A的长度n； 

第二行为序列A的n个元素； 

第三行为序列B的长度m； 

第四行为序列B的m个元素（元素之间用空格分隔）。 

输出:

输出合并后的序列，每个数据之间用空格分隔。

#include <stdlib.h>

#include <stdio.h>

#define LIST_INIT_SIZE    20

#define LISTINCREMENT   10

#define OK                1

#define OVERFLOW        -2

typedef int ElemType;

typedef int Status;

typedef struct {

        ElemType *elem;

        int length;

        int listsize;

}SqList;

Status InitList_Sq(SqList *L,int n){
    L->elem=(int*)malloc(n*sizeof(int));
    if(!L->elem)exit(OVERFLOW);
    L->length=0;
    return 1;
}

void InputList_Sq(SqList *L, int n){
    for(int j=0;j<n;j++){
        scanf("%d",&L->elem[j]);
        L->length++;
    }
}

Status MergListe_Sq(SqList *La, SqList *Lb, SqList *Lc){
    int j=0,k=0,i=0;
    while(k!=La->length && j!=Lb->length){
        if(La->elem[k]>Lb->elem[j]){
            Lc->elem[i++]=Lb->elem[j++];
        }
        else{
            Lc->elem[i++]=La->elem[k++];
        }
        Lc->length++;
    }
    while(k<La->length){
        Lc->elem[i++]=La->elem[k++];
        Lc->length++;
    }
    while(j<Lb->length){
        Lc->elem[i++]=Lb->elem[j++];
        Lc->length++;
    }
    return 0;
}

void PrintList_Sq(SqList L){
    for(int j=0;j<L.length;j++){
        printf("%d ",L.elem[j]);
    }
}

int main()

{

        SqList La,Lb,Lc;
        int len1,len2;
        scanf("%d",&len1);
        InitList_Sq(&La,len1);
        InputList_Sq(&La,len1);
        scanf("%d",&len2);
        InitList_Sq(&Lb,len2);
        InputList_Sq(&Lb,len2);
        int n=len1+len2;
        InitList_Sq(&Lc,n);
        MergListe_Sq (&La, &Lb, &Lc);
        PrintList_Sq(Lc);
        return 0;

}

八，最小值由最后一个数代替

void swap(int *x,int *y){
    int t=*x;
    *x=*y;
    *y=t;
}

void Deletemin(Sqlist *L){
    int mindex=0,min=L->elem[0];
    for(int i=1;i<L->length;i++){
        printf("i=%d",i);
        if(min>L->elem[i]){
            mindex=i;min=L->elem[i];
        }
    }
    printf("%d    ",mindex);
    swap(&L->elem[mindex],&L->elem[L->length-1]);
    L->length--;
}