数据结构线性表

//差集a,b，单链表

#include<iostream>

typedef struct LNode{
	int data;			//元素 
	struct list *next;	//指向后继结点的指针 
}LNode;

int creatList(LNode *&C,int a[],int n) // 创建链表
{
	LNode *s,*r;    //s指向新申请的节点，r指向c的终端节点
	int i;
	C=(LNode *)malloc(sizeof (LNode));
	C-next = NULL;
	r=C;
	for(i=0;i<n;++i){
		s=(LNode *)malloc(sizeof (LNode));
		s-data=a[i]; 	//用申请的新节点接受A中的一个元素 
		r-next = s;		//用r来接纳新节点 
		r = r-next;		//r指向终端节点，以便接纳下一个到来的节点 
	} 
	r-next = null;
 } 

void difference(LNode *A,LNode *B){
	LNode *p = A->next,*q = B->next;
	LNode *pre = A;    //前驱结点
	LNode *r;   //中间结点 
	while(p!=null&&q!=null){
		if(p->next < q->next){
			pre=p;		//p大p后移 
			p = p->next;
		}else if(p->next > q->next){
			q = q->next;   //q大q后移 
		}else{    //相等的话，删除 
			pre->next = p->next;
			r=p;
			p = p->next;
			free(p);
		}
	} 
	
}

1.1用链表，长度动态变化采用链表插入删除较方便，
1.2采用顺序表，顺序表

1.2.3逆置顺序表,用引用类型，因为需要改变顺序表

void change(sqlist &L){
	for(int i=0,j=L.length-1;i<j;i++,j--){
		int temp;
		temp = L.date[i];
		L.date[i] = L.date[j];
		L.date[j] = temp;
		
	}
}

1.2.4删除顺序表i~j的元素

void change(sqlist &L,int i,int j){
	int k,delta;
	delta = j-i+1;	//删除即往前移j-i+1个位置 
	for(int a=j;a<L.length){
		L.data[k-delta] = L.data[k];
	}
	L.length- = dalta;
}  

---

---

快速排序
1.2.5将顺序表小于表头的元素反在前头，大于表头元素的放在后头

void move(sqlist &L){
	int i=0;
	int j = L.length-1;
	int temp;    //存储表头的元素
	temp = L.data[0];
	
	while(i<j){
		while(i<j&&L.data[j]>temp)    j--;  //当j指针来到比temp小的元素时停止
		
		if(i<j){
			L.data[j]=L.data[i];
			i++;
		} 
		
		while(i<j&&L.data[i]<temp)    i++;  //当i指针来到比temp大的元素时停止
		
		if(i<j){
			L.data[i]=L.data[j];
			i++;
		} 
		
		}
	L.data[i] = temp;         //将temp变量放在最终的位置	
	} 
} 

//7.18
数组前m,后n排序p35

#include<iostream> 
void form(int A[],int m,int n);
using namespace std;
int main(){
	int m=5,n=4;
	int A[9]={1,3,5,7,9,2,4,6,8};
	form(A,m,n);    //传入的数组不指定大小 
	for(int i=0;i<9;i++)
		cout<<A[i]<<endl;
}

//在c/c++中，在进行数组传参时，
//数组的元素个数默认是不作为实参传入调用函数，
//也就是说c/c++ 不允许向函数传递一个完整的数组作为参数

void form(int A[],int m,int n){
	int i,j;
	int temp;    //中间变量
	for(i=m;i<m+n;i++){    //将后n个元素插入到前n个元素中去 
		temp = A[i];    //存储的是i位置的元素，下面的for循环语句可能将i位置覆盖 
		for(j=i-1;j>=0&&temp<A[j];j--){     //将比较的过程放入for循环中 
			A[j+1] = A[j];    //元素后移以便腾出一个位置插入temp 
		}
		A[j+1] = temp;
	} 
} 

//基本操作最坏情况m次，有n个元素,时间复杂度f(mn)