数据结构算法题整理1

1.设计一个算法，将顺序表所有元素逆置

//顺序表数据类型定义
typedef struct {
	int data[maxSize];
	int length;
}Sqlist;
//顺序表逆置
void reverse(Sqlist &L){
	//反转顺序表L
	int i;
	for (i=0; i<L.length/2;i++) {
		int temp = L.data[i];
		L.data[i] = L.data[L.length-i-1];
		L.data[L.length-i-1] = temp;
}

2 设计一个算法，从一给定的顺序表L中删除下标i~j（i<=j,包括i,j）的所有元素，假定i、j都是合法的。

typedef struct {
	int data[maxSize];
	int length;
}Sqlist;
//下标为j+1元素起往前移动j-i个位置
void delete(Sqlist &L, int i, int j){
	int k;
	for (k=j+1;k<L.length;k++) {
		L.data[k-j+i]=L.data[k];
	}
	L.length-=j-i+1;	
}

3 有一个递增非空单链表，设计一个算法删除值域重复的结点。

typedef struct LNode{
	int data;			//数据域
	struct LNode *next; //指针域
}LNode,*LinkList;
void deleteDuplicate(LinkList &L){
	LNode *p = L->next;
	while(p && p->next){
		if(p->data == p->next->data) {
			LNode *q = p->next;
			p->next = q->next;
			free(q);
		}
		else{
			p=p->next;
		}
	}
}

那如果是用顺序表来实现呢？

typedef struct{
	int data[maxSize];
	int length;
}Sqlist;

void deleteDuplicate(Sqlist &L){
	int i;
	int j = 0; //制造相邻感
	for (i=1; i<L.length;i++){
		if(L.data[i] != L.data[i+1]){
			L.data[++j] = L.data[i];
		}
	}
	L.length = j+1;
}			

4 有一个顺序表L，其元素为整型数据，设计一个算法，将L中所有小于表头元素的整数放在前半部分，大于表头元素的整数部分放在后半部分。

typedef struct {
	int data[maxSize];
	int length;
}Sqlist;
void move(Sqlist &L) { //L要改变所以用引用型
	int temp;
	int i = 0, j = L.length-1;
	temp = L.data[i];
	while (i<j) {
		/*关键步骤开始*/
		while (i < j&&L.data[j] > temp)
			j--;
		//j从左往右扫描，当来到第一个比temp小的元素时停止,并且每走一步都要判断i是否小于j,这个判断容易遗漏。
		if (i < j) { //检测看是否已仍满足i < j，这一步同样很重要
			L.data[i] = L.data[j]; //移动元素。
			i++; //i右移一位。
		}
		while (i < j&&L.data[i] < temp) i++; //与上边的处理类似。
		if (i < j) { //与上边的处理类似。
			L.data[j] = L.data[i]; //与上边的处理类似。
			j--;
		}
		/*关键步骤结束*/
	}
	L.data[i] = temp; //将表首元素放在最终位置。
}

5 设计一个算法删除单链表L（有头结点）中的一个最小值结点

typedef struct LNode{
	int data;
	struct LNode* next;
}LNode,*LinkList;

//天勤参考答案
void deleteMin(LNode *L) {
	LNode *pre = L;
	LNode *p = L->next;
	LNode *minp = p;
	LNode *minpre = pre;
	while(p){
		if(p->data < minp->data){
			minp = p;
			minpre = pre;
		}
		pre = p;
		p = p->next;
	}
	minpre->next = minp->next;
	free(minp);
}

6 线性表逆置

typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode,*LinkList;

void reverse(LNode *L){
	LNode *p = L->next;
	L->next = NULL;
	while(p){
		//第一次循环先保留一个除头结点以外的一个结点
		//从第二次开始进行头插法
		LNode *q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}
}

7 设计一个算法，将一个头结点为A的单链表（其数据域为整数）分解成两个单链表A和B，使得A链表只含有原来链表中data域为奇数的结点，而B链表只含有原链表中data域为偶数的结点，且保持原来的相对顺序。

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode;

void split(LNode *A,LNode *&B){
	LNode *p,*q,*r;
	//申请链表B的头结点
	B = (LNode *)malloc(sizeof(LNode));
	B->next = NULL;
	r=B;
	p=A;
	while(p->next){
		if(p->next->data %2 ==0){
			q=p->next; //从A中删除
			p->next=q->next;
			q-> next = NULL; //作为null的一个标志
			r->next = q;//B增加结点
			r = q;//添加一个尾部置NULL
	}
}