线性表

1，顺序表

线性表的顺序储存结构

//线性表的顺序储存结构
#define MaxSize   100
typedef int ElemType;		   //定义ElemType为int类型

typedef struct{
	ElemType data[MaxSize];		//存放顺序表中的元素
	int 	 length;					//存放顺序表当前的长度
}SqList;						//声明顺序表的类型

顺序表的初始化

//初始化当前顺序表长度为0
void InitList(SqList &L){      //L回传给实参，用引用类型
	L.length = 0;			   
}

取顺序表中的第i个元素

//返回L中第i个元素的值
int GetElem(Sqlist L, int i, ElemType &e){
	if(i<1 || i>L.length)
		return 0;
	else{
		e = L.data[i-1];
		return 1;
	}
}

顺序表的查找

//从顺序表中找到与给定的元素x相等的元素，若找到则返回序号，否则返回0
int Locate(SqList L, ElemType x){
	int i=0;
	for(i=0;i<L.length, ++i){
		if(L.data[i] = x)
			return i+1;
	}
	return 0;
		

顺序表的插入

//在顺序表中的第i-1个数据和第i个元素之间插入一个新的元素
//在顺序表L中第i个元素之前插入新的元素x
int ListInsert(SqList &L, int i, ElemType x){
	int j=0;
	if(i<1||i>L.length)
		return 0;
	for(j=L.length; j>i; j--)
		L.data[j] = L.data[j-1];   //将i后面的元素向后移动一位
	L.data[i-1] = x;  //加入元素x
	L.length++;   //长度加一
}

顺序表的删除

//将顺序表的第i个元素ai删除，顺序表的长度减一
//参数L需要回代，用引用的方式&，i为要删除元素的额位置
int ListDelete(Sqlist &L, int i){
	int j=0;
	if(i<1||i>L.length)
		return 0;
	for(j=i; j<L.length; j++)
		L.data[j-1] = L.data[j];
	L.length--;
	return 1;
}

顺序表的合并

//顺序表A和B按照非递减有序排列，将A和B合并到新的顺序表C中，且为非递减有序排列
void merge(Sqlist A, Sqlist B, Sqlist &C){
	int i,j,k=0;   //K记录c中元素的个数,i为A，j为B
	while(i<A.length && j<B.length){		//是否有其中一个加入完成
		if(A.data[i]<B.data[i]){
			C.data[k] = A.data[i];
			i++; k++;
		}
		else if(A.data[i]>B.data[j]){
			C.data[k] = B.data[j];
			j++; k++;
		}
		else{							//A.data[i] = B.data[i]
			C.data[k] = A.data[i];
			i++; k++;
			C.data[k] = B.data[j];
			j++; k++;
		}	
	}
	while(i<A.length){				//B全部加入到C了，剩余的A中元素全部往C后面加入即可
		C.data[k] = A.data[i];
		i++;k++;
	}
	while(j<B.length){				//A全部加入到C了，同上
		C.data[k] = B.data[i];
		j++;k++;
	}
	C.length = k;		//C的长度
}	

2，单链表

单链表的结构

typedef int ElemType;		//定义数据类型
typedef struct node{
	ElemType data;
	struct node *next;
}SLink,*linkedlist;		   //把struct Node *定义为新类型LinkList，是一个结构体的指针。

单链表的初始化

//C语言
void InitList(){             
	SLink *L;  //定义一个头结点
	L = (SLink *)malloc(sizeof(SLink));//头结点申请地址
	if (L == NULL)
		printf("申请空间失败");
	L->next = NULL;
}

单链表的销毁

void DestroyList(SLink* &L){		
	SLink * pre = L, *p=pre->next;		//pre指向头结点，p指向第一个数据节点
	while(p!=NULL){
		free(pre);
		pre = p;                //pre和p同步后移
		p = p->next;
	}
	free(pre);		//释放尾节点
}

单链表的查找

//按值查找
int Locate(SLink *L, ElemType e){
	SLink *p = L->next;
	int j=0;
	
	while(p!=NULL && p->data!=e){
		p = p->next;
		j++;
	}
	if(p == NULL)
		return 0;
	else
		return j;
}

单链表插入元素

//在单链表的第i个元素之前插入元素x
linkedlist InsElem(linkedlist L, ElemType x, int i){
	int j=0;
	SLink *p = L, *s;
	if(i<=0)  return 0;
	while(p!=NULL && j<i-1){         //查找第i-1个结点*p
		j++;
		p = p->next;
	}
	if(p == NULL)  return -1;        //未找到结点返回-1
	else{
		s = (SLink *)malloc(sizeof(SLink));   //创建新结点
		s->data = x;                          //存放元素x
		s->next = p->next;                    //s指向i的元素位置，即p->next的指向
		p->next = s;                          //插入s后，那么p指向s
		return L;                             //成功返回L
	}
}

单链表删除元素

linkedlist DelElem(SLink *&L, int i){
	int j=0;
	SLink *p = L, *q;                //q是要被删除的元素
	if(i<=0)  return 0;
	while(p!=NULL && j<i-1){         //查找第i-1个结点*p
		j++;
		p = p->next;
	}
	if(p == NULL)  return 0;        //未找到结点返回0
	else{
		 q = p->next;
		if(q == NULL)  return 0;
		else{
			p->next = q->next;     //i-1指针指向i的指针
			free(q);               //释放q
			return L;              //成功返回1
		}			
	}
}

创建单链表

//输入元素 创建为单链表
//采用尾插法，将新的结点插到当前链表的表尾
linkedlist CreateList(){
	SLink *s,*tc;
	ElemType x;
	int i=0;
	
	L = (SLink *)malloc(sizeof(SLink));     //创建头结点
	tc = L;                                 //tc始终指向尾节点
	while(scanf("%d",&x) != EOF){
		s = (SLink *)malloc(sizeof(SLink));
		s->data = x;						  //创建存放数组a的新结点 s
		tc->next = s;                         //将*s插入到tc之后
		tc = s;                               //tc指向插入新的元素
	}
	tc->next = NULL;						  //尾结点next域置为NULL
	return L;
}

单链表的合并

//将ha和hb两个递增有序的单链表合并成一个递增有序的hc
void merge(SLink *ha, SLink *hb, SLink *hc){
	SLink *pa=ha->next,*pb=hb->next,*tc;
	hc = ha;              //将ha的头结点用作hc的头结点
	tc = hc;              //tc为尾结点
	free(hb);							//释放hb的头结点
	while(pa!=NULL && pb!=NULL){
		if(pa->data < pb->data){          //将*pa链接到*tc之后
			tc->next = pa;
			tc = pa;
			pa = pa->next;
		}
		else if(pa->data > pb->data){     //将*pb链接到*tc之后
			tc->next = pb;
			tc = pb;
			pb = pb->next;
		}
		else{                             //两个相等，则都链接到*tc之后
			tc->next = pa;                  
			tc = pa;
			pa = pa->next;
			tc->next = pb;
			tc = pb;
			pb = pb->next;
		}
	}
	tc->next = NULL;                    //将尾结点为空
	/* 如果其中一个链接完成，那么另一个直接链接到hc后面 */
	if(pa!=NULL)                        
		tc->next = pa;
	if(pb!=NULL)
		tc->next = pb;
}

顺序表的逆置

//将线性表反转
#define MAXSIZE 100
typedef int ElemType; 
typedef struct{
	ElemType data[MAXSIZE];
	int length;
}Sqlist;

//创建顺序表
void creat_sqlist(Sqlist *L,int n){
	int i=0;
	L->length = n;
	printf("\n input %d data: ", n);
	while(i<n){
		scanf("%d", &L->data[i]);
		i++;
	}
}

//反转顺序表
void reverse_sqlist(Sqlist *L){
	int i=0,j=0,n=0,t=0;
	n = L->length;
	if(n==0 && n==1)		return;
	j = n-1;
	while(i<j){
		t = L->data[i];
		L->data[i] = L->data[j];
		L->data[j] = t;
		i++;
		j--;
	}
}

//打印顺序表
void print_sqlist(Sqlist *L){
	int i=0, n=0;
	n = L->length;
	printf("\n output %d data: ", n);
	while(i<n){
		printf("%d", L->data[i]);
		i++;
	}
}

int main(){
	Sqlist L;
	int n;
	printf("\n input n: ");
	scanf("%d", &n);
	creat_sqlist(&L,n);
	reverse_sqlist(&L);
	print_sqlist(&L);	
}

约瑟夫环

//单链表的使用
#include 
typedef int ElemType;
typedef struct node{
	ElemType data;
	struct node *next;
}SLink, *linkedList;

//初始化单链表
void initList() {
	SLink  *L;
	L = (SLink *)malloc(sizeof(SLink));
	L->next = NULL;
}

//创建一个单链表---头插法
linkedList creatLink(ElemType n) {
	linkedList L;
	L = (SLink *)malloc(sizeof(SLink));
	L->next = NULL;

	for (int i = 1; i <= n; ++i) {
		linkedList p;
		p = (SLink *)malloc(sizeof(SLink));
		p->data = i;
		p->next = L->next;		//将L的位置给了新的 P
		L->next = p;		//L在p的后面
	}
	return L;
}

//删除某个元素
linkedList delElem(linkedList L, ElemType i) {
	int j = 0;
	linkedList p, q;		//p为要查找的结点前一个结点，q为要删除的结点
	
	p = L;
	while (p!=NULL && j<i-1) {
		j++;
		p = p->next;
	}
	q = p->next;  //q指向i的结点
	p->next = q->next;

	return L;
}

int main() {
	linkedList L;
	int n, k, num = 0;
	printf("\n input n: ");
	scanf("%d", &n);
	L = creatLink(n);
	printf("\n input k: ");
	scanf("%d", &k);
	while (true)
	{
		if (num > n - 1)		break;
		if (n - num < k)		break;
		L = delElem(L, k);  //删除成功
		num++;
		L = creatLink(n-num);
		
	}
	printf("\n 次数：%d", num);
	return 1;
}