算法篇----顺序表，链表

1. 已知一个线性表顺序存储递增有序排列，实现删除表中值相同的元素算法

typedef struct{
		elemtype *elem;
		int length;
		int listsize;
	}Sqlist;

	void delete(Sqlist &L){
		int i=0，j=1;
		while(j<L.listsize){
			if(L.elem[i]!=L.elem[j])
				L.elem[++i]=L.elem[j];
			j++;
		}
		L.length=i;
	}
           

2. 设计在带头结点的单链表 L 中第 i 个位置之前插入元素 e的算法

typedef struct Lnode{
		elemtype data;
		struct Lnode *next;
	}Lnode,*Linklist;

	Status ListInsert(Linklist &L,int i,elemtype e){
		p=L;j=0;
		while(p && (j<i-1)){ 
			p=p->next;
			j++;
		}
		if (!p) 
			return error;
		s=(LinkList)malloc(sizeof(LNode));
		s->date=e;
		s->next=p->next;
		p->next=s;
		return Ok;
	}
           

3. 实现对一个不带头结点的单链表 L 进行就地逆置。

typedef int DataType;
	typedef struct {
		Datatype data;
		struct Lnode *next;
	}Node;
	typedef Node *Linklist;

	Linklist Reverse(Linklist L){
		Linklist p,q;
		if(!L)
			return ;
		p=L->next;
		q=L->next;
		L->next=null;
		while(q) {
			q=q->next;
			p->next=L->next;
			L->next=p;
		}
	}
           

4. 已知线性表中的元素按值递增有序，并以带头结点单链表存储，删除值为x到y的元素（15年）

void Process(Linklist &L,int x,int y){
		Linklist p=L,q,s;
		if(p->next!=null && (x<=y)){
			while(p->next!=null && p->next->data<=x)
				p=p->next;
			if(p->next=null)
				return error;
			q=p->next;
			while(q->next!=null && p->next->data>y){
				s=q;
				q=q->next;
				free(s);
			}
			p->next=q->next;
			free(q);
		}
	}
           

5. 设计将两个有序链表合并为一个有序链表的算法，假设元素非递减排列（14年）

void MergeList(Linklist &La,Linklist &Lb,Linklist &Lc){
		pa=La->next;
		pb=Lb->next;
		Lc=pc=La;
		while(pa && pb){
			if(pa->data<=pb->data){
				pc->next=pa;
				pc=pa;
				pa=pa->next;
			}
			else(
				pc->next=pb;
				pc=pb;
				pb->next;
			}
		}
		pc->next=pa?pa:pb;
		free(Lb);
	}
           

6. 设有一个由正整数组成的无序单链表，试编写算法

（1）找出最小值结点，并输出该数值

（2）若该最小值是奇数，则将其与后继结点的数值交换，若为偶数，则将其后继结点删除 （19年）

Linklist Delete_change(Linklist &L){
		LNode *pre=L;
		LNode *p=pre->next;
		LNode *minpre=pre,*minp=p;
		while(p!=null){
			if(p->data<minp->data){
				minp=p;
				minpre=pre;
			}
			pre=p;
			p=p->next;
		}
		printf("%d",minp->data);
		int k=minp->data;
		if(k%2==0){
			minpre->next=minp->next;
			free(minp);
		}
		else{
			int temp=minp->next->data;
			minp->next->data=minp->data;
			minp->data=temp;
		}
	}
           

7. 试编写一个判别表达式中左右小括号是否配对出现的算法（18年）

bool Parent_match(Sqstack *s,char *str){
		int i=0,flag=0;
		Elemtype e;
		while(str[i]!='\0'){
			switch(str[i]){
				case '(':push(s,str[i]);
				break;
				case ')':{
					pop(s,&e);
					if(e!='(') flag=1;
				}
				break;
				default:break;
			}
			if(flag) break;
			i++;
		}
		if(!flag && StackEmpty(s)){
			printf(“括号匹配成功”）;
			return true;
		}
		else{
			print("括号匹配失败”);
			return false;
		}
	}
           

8. 插入元素e到队列Q中（15年）

status EnQueue &Q,QElemType e){
		p=(QueuePtr)malloc(sizeof(Qnode));
		if(!p)  
		   exit(overflow);
		p->data=e;
		p->next=null;
		Q.rear->next=p;
		Q.rear=p;
		return ok;
	}