数据结构（一）之顺序表与链表

• 顺序表

运用数组结构来构建的线性表就是顺序表。
本例实现了顺序表的打印、清空、判断是否为空、求表长、获得指定下标的元素、获得指定元素的下标、插入和删除操作。

#include<iostream>
const int MAXSIZE=100;
using namespace std;
struct L{
    int a[MAXSIZE+1];	
    int n;
}sqlist;
void PrintList(L sqlist);
void ClearList(L &sqlist); 
bool ListEmpty(L sqlist);
int Listlength(L sqlist);
int GetElem(L sqlist,int i);
int Locate(L sqlist,int e);
void ListInsert(L &sqlist,int i,int e);
int ListDelete(L &sqlist,int i);
int main(){
	for(int i=0;i<10;i++){
		sqlist.a[i]=i+1;
		sqlist.n++;
	}
	/*以下是测试代码
	ListInsert(sqlist,3,5);
	cout<<ListDelete(sqlist,4)<<endl;
	*/
	PrintList(sqlist);
	return 0;
} 
void PrintList(L sqlist){
	for(int i=0;i<sqlist.n;i++){
		cout<<sqlist.a[i]<<ends;
	}
}
void ClearList(L &sqlist){
	for(int i=0;i<sqlist.n;i++){
		sqlist.a[i]=0;
	}
	sqlist.n=0;
}
bool ListEmpty(L sqlist){
	if(sqlist.n==0) return true;
	else return false;
}
int Listlength(L sqlist){
	return sqlist.n;
}
int GetElem(L sqlist,int i){
	return sqlist.a[i-1];
}
int Locate(L sqlist,int e){
	for(int i=0;i<sqlist.n;i++){
		if(sqlist.a[i]==e) return i+1;
	}
}
void ListInsert(L &sqlist,int i,int e){
	for(int j=sqlist.n-1;j>=i-1;j--){
		sqlist.a[j+1]=sqlist.a[j];
	}
	sqlist.a[i-1]=e;
	sqlist.n++;
}
int ListDelete(L &sqlist,int i){
	int e;
	e=sqlist.a[i-1];
	for(int j=i-1;j<sqlist.n;j++){
		sqlist.a[j]=sqlist.a[j+1];
	}
	sqlist.n--;
	return e;
}

• 链表

运用链式结构来构建的线性表就是链表。
本例实现了链表的插入、删除、打印、清空、判断是否为空、求表长、获得指定下标的元素、获得指定元素的下标和翻转等操作。（注释中还包括了双向链表的定义，有序链表的合并，单循环链表的删除指定元素结点、链接、删除第i个结点，单链表改双向链表，静态链表的声明、初始化、插入、删除和链表多项式的相加）

#include<iostream>
#include<cstdlib> 
using namespace std;
typedef struct node{
        int data;                                           //数据域
        struct node *next;                          //指针域（后） 
        //struct node *prior;                         双向链表前指针域 
}NODE_t;
NODE_t *CreatNodeList(int n);
int InsertNode(NODE_t *head,int data);
int DeleteNodeOfList(NODE_t *head,int i);
void PrintList(NODE_t *head);
void ClearList(NODE_t *head); 
bool ListEmpty(NODE_t *head);
int Listlength(NODE_t *head);
int GetElem(NODE_t *head,int i);
int Locate(NODE_t *head,int e);
void Reverse(NODE_t *head); 
int main(){
	NODE_t *p;
	/*以下是测试代码
        p=CreatNodeList(4);
	InsertNode(p,3);
	PrintList(p);
	cout<<GetElem(p,2)<<endl;
	cout<<Locate(p,3)<<endl;
	Reverse(p);
	PrintList(p);
	ClearList(p);
	PrintList(p);
	cout<<ListEmpty(p)<<endl;
	cout<<Listlength(p)<<endl;
	*/
	return 0;
} 
NODE_t *CreatNodeList(int n){
    NODE_t *head,*rear,*p;
    head=(NODE_t *)malloc(sizeof(NODE_t));
    rear=head;
    for(int i=1;i<=n;i++){
    	p=(NODE_t *)malloc(sizeof(NODE_t));
    	scanf("%d",&p->data);
    	rear->next=p;
    	rear=p;
	}
    rear->next=NULL;
    return head;
}
int InsertNode(NODE_t *head,int data){
    NODE_t *cur = NULL;
    if(!head)
        exit(-1);
    cur = (NODE_t *)malloc(sizeof(NODE_t));
    if(!cur)
        exit(-1);
    cur->data = data;//cur 插入到 head 和 head->next 之间
    cur->next = head->next;
    head->next = cur;
    return 0;
}
int DeleteNodeOfList(NODE_t *head,int i,int e){
    NODE_t *p=head;
    int j=0;
    while(p->next!=NULL&&j<i-1){
    	p=p->next;
    	j++;
	}
	if(p->next!=NULL&&j==i-1){
		NODE_t *q=p->next;
		p->next=q->next;
		e=q->data;
		free(q);
	}
    return 0;
}
void PrintList(NODE_t *head){
	NODE_t *p=head->next;
	while(p!=NULL){
		cout<<p->data<<endl;
	    p=p->next;
	}
}

void ClearList(NODE_t *head){   
	head->next=NULL;
}

bool ListEmpty(NODE_t *head){ 
    if(head->next==NULL) return true;
    else return false;
}
int Listlength(NODE_t *head){
	int i=0;
	if(head->next==NULL) return 0;
	else{
		while(head->next!=NULL){
			i++;
			head=head->next;
		}
	}
	return i;
}
int GetElem(NODE_t *head,int i){
	int j=1;
	for(j=1;j<=i;j++) head=head->next;
	return head->data; 
}
int Locate(NODE_t *head,int e){
	int i=1;
	if(head!=NULL){
	    while(head->data!=e){
	    	head=head->next;
	    	i++;
		}
		return i;
	}
	else return -1;
}
void Reverse(NODE_t *head){
	NODE_t *s,*p=head->next;
	head->next=NULL;
	while(p!=NULL){
		s=p;
	    p=p->next;
    	s->next=head->next;
    	head->next=s;
	}
}
/*链表有序合并
if(pa->data<=pb->data)  //只要有一个表不为空的循环过程a,b为旧表，c为新表 
{rc->next=pa;rc=pa;pa=pa->next;} 
else{rc->next=pb;rc=pb;pb=pb->next;}
if(pa!=NULL) rc->next=pa; //若某一链表空，将另一链表放在表c之后 
else rc->next=pb; 
单向循环链表的删除 删除p结点 
void del_pre(NODE_t *p){
    NODE_t *rear=p;
	while(rear->next->next!=p) rear=rear->next;
	free(rear->next);
	rear->next=p;
}
循环单链表的链接
    head1=rear1->next;
	rear1->next=rear2->next;
	rear2->next=head1;
删除第i个结点（结点p） 
p->prior->next=p->next;
p->next->prior=p->prior;
free(p);
单链表改双向链表
void cre_dulink(NODE_t *ha){
    NODE_t *p=ha;
    while(p->next->prior==NULL){
        p->next->prior=p;
        p=p->next;
    }
}
静态链表的声明
#define n0 100
#define datatype char
struct element{
    datatype data;
	int next;
};
struct staticlist{
    element s[n0+1];
    int head,avail;
};
struct staticlist L;
静态链表初始化
L.head=0;
L.avail=1;
for(i=1;i<n0;i++) L.s[i].next=i+1;
L.s[n0].next=0;
静态链表插入
void insert(staticlist &L,int p,datatype x){  //插入p之后
    int q; 
    if(L.avail==0) printf("存储空间不够");
    else{
        q=L.avail;
        L.avail=L.s[q].next;
        L.s[q].data=x;
        L.s[q].next=L.s[p].next;
        L.s[p].next=q;
    }
}
静态链表的删除
q=L.s[p].next;
L.s[p].next=L.s[q].next;
L.s[q].next=L.avail;
L.avail=q;
多项式相加
struct pnode{
    int expn; //指数
	float coef; //系数
	struct pnode *next;
};
typedef struct pnode* pointer;
void addpoly(pointer pa,pointer pb,pointer &pc){
    //pa,pb,pc三个多项式链表的头结点。pc=pa+pb
	p=pa->next;
	q=pb->next;
	pc=pa;
	rc=pc;   //pc,rc新链表的头指针和尾指针
	while(p&&q){
	    //两多项式均未结束时，比较指数；将较小指数的结点链入新多项式链表
		if(p->exp<q->exp){
		    rc->next=p;
			rc=p;
			p=p->next;
		}
		if(p->exp==q->exp){
		    x=p->coef+q->coef;
			if(x!=0){
			    p->coef=x;
				rc->next=p;
				rc=p;
				p=p->next;
			}
			else{
			    u=p;
			    p=p->next;
			    delete u;
			}
			u=q;
			q=q->next;
			delete u;
		}
		if(p->exp>q->exp){
		    rc->next=q;
		    rc=q;
		    q=q->next;
		}
	}
	if(p){
	    rc->next=p;
	}
	else{
	    rc->next=q;
	}
}
*/