2022_天勤数据结构高分笔记_第二章_算法

3、将顺序表的所有元素逆置

void exchange(List &L,int low,int high){			//顺序表置换方法
	while(low<high){
		L.data[low] = L.data[low]+L.data[high];
		L.data[high] = L.data[low]-L.data[high];
		L.data[low] =L.data[low]-L.data[high];
		low+=1;
		high-=1;
}
}

4、在顺序表中删除下标i~j的所有元素，假定i和j都是合法的。

void delete_data(List &L,int i,int j){				//删除指定下标方法
	int k;
	for(k=j+1;k<L.length;k++){
		L.data[k-j+i-1]=L.data[k];
	}
	L.length = L.length-j+i-1;
}

5、将L中小于表头的元素向前移，大于的向后移动

void sort_data(List &L){					//小于表头的元素向前移动，大于的向后移动
	int temp = L.data[0];
	int i = 0;
	int j = L.length-1;
	while(i<j){
	while(i<j&&temp<L.data[j]) j--;
	if(i<j){
		L.data[i] = L.data[j];
		i++;
	}
	while(i<j&&temp>L.data[i]) i++;
	if(i<j){
		L.data[j] = L.data[i];
		j--;
	}
	}
	L.data[i] = temp;
}

6、删除一个递增的链表中的重复值域

void delete_increaing_node(Node *&n){
	Node *p,*q;
	p = n->next;
	while(p->next!=NULL){
		p->next;
		if(p->next->data==p->data){
			q=p->next;
			p->next=p->next->next;
			free(q);
		}
		else{
			p = p->next;
		}
		
	}
}

7、删除单链表中的最小值

void delete_low_node(Node *&n){
	Node *p,*q;
	p = n->next;
	int low = p->data;
	q = n;
	while(p->next!=NULL){
		if(p->next->data<low){
			low = p->next->data;
			q = p;
		}
		p=p->next;
	}
		p=q->next;
		q->next=p->next;
		free(p);
}

8、逆置链表

void exchange_node(Node *&n){
	Node *p,*q;
	p = n->next;
	n->next=NULL;
	while(p!=NULL){
		q = p->next;
		p->next=n->next;
		n->next=p;
		p = q;
	}
}

9、A链表分解为奇数A链表，偶数B链表

void part_node(Node *&A,Node *&B){			//A链表分解为奇数A链表，偶数B链表
	B=(Node *)malloc(sizeof(Node));
	B->next=NULL;
	Node *p,*q,*r;
	r = B;
	p = A;
	while(p->next!=NULL){
		if(p->next->data%2==0){
			q = p->next;
			p->next = p->next->next;
			r->next = q;
			r = q;
		}
		else{
			p=p->next;
		}
	}
}

思考题

1、取一个i变量和一个int数组，取出最小的元素

int find_list(int A[],int N){
	int i=A[0]*10;
	for(i;i%10<N;i++){
		if(A[i%10]<i/10){
			i = A[i%10]*10+i%10;
		}
	}
	return i/10;
}

2、逆序打印单链表的数据，指针指向开始结点

void bk_node(Node *N){
	if(N!=NULL){
		bk_node(N->next);
		cout<<N->data<<endl;
	}
}

3、判断两个链表是否相等

int equal_node(Node *A,Node *B){
	Node *p,*q;
	p = A->next;
	q = B->next;
	while(p!=NULL&&q!=NULL){
		if(p->data!=q->data){
			return 0;
		}
		else{
			p=p->next;
			q=q->next;
		}
	}
	if(p!=NULL||q!=NULL){
		return 0;
	}
	else{
		return 1;
	}
}