数据结构算法设计题
作者：互联网
线性表
1.已知长度为n的线性表采用顺序存储结构。写一个算法，删除线性表中所有值为x的元素。
方法一:用k记录顺序表L中等于x的元素个数，边扫描L边统计k, 并将不等于x的元素前移k个位置，最后修改L的长度。
void del_x_1(SqList &l, ElemType x)
{
int k = 0, i = 0;
while (i < L.length)
{
if (L.data[i] == x)
{
k++;
}
else
{
L.data[i - k] = L.data[i];
}
i++;
}
L.length = L.length - k;
}
方法二：用k记录顺序表L中不等于x的元素个数(即需要保存的元素个数), 边扫描L边统计k,并将不等于x的元素向前移动k个位置，最后修改L的长度。
void del_x_2(SqList &l, ElemType x)
{
int k=0;
for(i=0;i<L.length;i++)
{
if(L.data[i]!=x)
{
L.data[k]=L.data[i];
k++;
}
}
L.length=k;
}
2.设计一个高效算法，将顺序表L的所有元素逆置。
算法思想:扫描顺序表L的前半部分元素，对于元素L.datai, 将其与后半部分的对应元素L.data[L.length-i-1]进行交换。
void Reverse(SqList &L)
{
ElemType temp;
for (i = 0; i < L.length / 2; i++)
{
temp = L.data[i];
L.data[i] = L.data[L.length - i - 1];
L.data[L.length - i - 1] = temp;
}
}
3.统计出单链表 HL中结点的值等于给定值X的结点数。
int CountX(LNode *HL, ElemType x)
{
int i = 0;
LNode *p = HL; // i为计数器
while (p != NULL)
{
if (P->data == x)
{
i++;
}
p = p->next;
} // while,出循环时 i中的值即为 x结点个数
return i;
} // CountX
4.设有两个集合 A和集合 B，要求设计生成集合 C=A∩B的算法，其中集合 A、B和 C用链式存储结构表示 。
typedef struct node
{
int data;
struct node *next;
} lklist;
void intersection(lklist *ha, lklist *hb, lklist *&hc)
{
lklist *p, *q, *t;
for (p = ha, hc = 0; p != 0; p = p->next)
{
for (q = hb; q != 0; q = q->next)
{
if (q->data == p->data)
{
break;
}
}
if (q != 0)
{
t = (lklist *)malloc(sizeof(lklist));
t->data = p->data;
t->next = hc;
hc = t;
}
}
}
5.设计在单链表中删除值相同的多余结点的算法
typedef int datatype;
typedef struct node
{
datatype data;
struct node *next;
} lklist;
void delredundant(lklist *&head)
{
lklist *p, *q, *s;
for (p = head; p != 0; p = p->next)
{
for (q = p->next, s = q; q != 0;)
{
if (q->data == p->data)
{
s->next = q->next;
free(q);
q = s->next;
}
else
{
s = q, q = q->next;
}
}
}
}
6.设单链表中有仅三类字符的数据元素(大写字母、数字和其它字符)，要求利用原单链表中结点空间设计出三个单链表的算法，使每个单链表只包含同类字符。
typedef char datatype;
typedef struct node
{
datatype data;
struct node *next;
} lklist;
void split(lklist *head, lklist *&ha, lklist *&hb, lklist *&hc)
{
lklist *p;
ha = 0, hb = 0, hc = 0;
for (p = head; p != 0; p = head)
{
head = p->next;
p->next = 0;
if (p->data >= 'A' && p->data <= 'Z')
{
p->next = ha;
ha = p;
}
else if (p->data >= '0' && p->data <= '9')
{
p->next = hb;
hb = p;
}
else
{
p->next = hc;
hc = p;
}
}
}
7.设计两个有序单链表的合并排序算法。
void mergelklist(lklist *ha, lklist *hb, lklist *&hc)
{
lklist *s = hc = 0;
while (ha != 0 && hb != 0)
if (ha->data < hb->data)
{
if (s == 0)
{
hc = s = ha;
}
else
{
s->next = ha;
s = ha;
}
ha = ha->next;
}
else
{
if (s == 0)
{
hc = s = hb;
}
else
{
s->next = hb;
s = hb;
}
hb = hb->next;
}
if (ha == 0)
{
s->next = hb;
}
else
{
s->next = ha;
}
}
8.设计判断单链表中元素是否是递增的算法。
int isriselk(lklist *head)
{
if (head == 0 || head->next == 0)
{
return (1);
}
else
{
for (q = head, p = head->next; p != 0; q = p, p = p->next)
{
if (q->data > p->data)
{
return (0);
}
}
}
return (1);
}
串
9.设计在顺序存储结构上实现求子串算法。
void substring(chars[], longstart, longcount, chart[])
{
long i, j, length = strlen(s);
if (start < 1 || start > length)
{
printf("The copy position is wrong");
}
else if (start + count - 1 > length)
{
printf("Too characters to be copied");
}
else
{
for (i = start - 1, j = 0; i < start + count - 1; i++, j++)
{
t[j] = s[i];
}
t[j] = '\0';
}
}
数组
10.设计将所有奇数移到所有偶数之前的算法
void quickpass(int r[], int s, int t)
{
int i = s, j = t, x = r[s];
while (i < j)
{
while (i < j && r[j] % 2 == 0)
{
j = j - 1;
}
if (i < j)
{
r[i] = r[j];
i = i + 1;
}
while (i < j && r[i] % 2 == 1)
{
i = i + 1;
}
if (i < j)
{
r[j] = r[i];
j = j - 1;
}
}
r[i] = x;
}
树和二叉树
11.设计一个求结点 x在二叉树中的双亲结点算法。
typedef struct node
{
datatype data;
struct node *lchild, *rchild;
} bitree;
bitree *q[20];
int r = 0, f = 0, flag = 0;
void preorder(bitree *bt, char x)
{
if (bt != 0 && flag == 0)
if (bt->data == x)
{
flag = 1;
return;
}
else
{
r = (r + 1) % 20;
q[r] = bt;
preorder(bt->lchild, x);
preorder(bt->rchild, x);
}
}
void parent(bitree *bt, char x)
{
int i;
preorder(bt, x);
for (i = f + 1; i <= r; i++)
if (q[i]->lchild->data == x || q[i]->rchild->data)
{
break;
}
if (flag == 0)
{
printf("not found x\n");
}
else if (i <= r)
{
printf("%c", bt->data);
}
else
{
printf("not parent");
}
}
12.设计在链式存储结构上交换二叉树中所有结点左右子树的算法。
typedef struct node
{
int data;
struct node *lchild, *rchild;
} bitree;
void swapbitree(bitree *bt)
{
bitree *p;
if (bt == 0)
{
return;
}
swapbitree(bt->lchild);
swapbitree(bt->rchild);
p = bt->lchild;
bt->lchild = bt->rchild;
bt->rchild = p;
}
13.在链式存储结构上建立一棵二叉排序树。
#define n 10
typedef struct node
{
int key;
struct node *lchild, *rchild;
} bitree;
void bstinsert(bitree *&bt, intkey)
{
if (bt == 0)
{
bt = (bitree *)malloc(sizeof(bitree));
bt->key = key;
bt->lchild = bt->rchild = 0;
}
else if (bt->key > key)
{
bstinsert(bt->lchild, key);
}
else
{
bstinsert(bt->rchild, key);
}
}
void createbsttree(bitree *&bt)
{
int i;
for (i = 1; i <= n; i++)
{
bstinsert(bt, random(100));
}
}
14.设计判断两个二叉树是否相同的算法。
typedef struct node
{
datatype data;
struct node *lchild, *rchild;
} bitree;
int judgebitree(bitree *bt1, bitree *bt2)
{
if (bt1 == 0 && bt2 == 0)
{
return (1);
}
else if (bt1 == 0 || bt2 == 0 || bt1->data != bt2->data)
{
return (0);
}
else
{
return (judgebitree(bt1->lchild, bt2->lchild) * judgebitree(bt1->rchild, bt2->rchild));
}
}
15.设计判断二叉树是否为二叉排序树的算法。
int minnum = -32768, flag = 1;
typedef struct node
{
int key;
struct node *lchild, *rchild;
} bitree;
void inorder(bitree *bt)
{
if (bt != 0)
{
inorder(bt->lchild);
if (minnum > bt->key)
{
flag = 0;
}
minnum = bt->key;
inorder(bt->rchild);
}
}
16.设计一个在链式存储结构上统计二叉树中结点个数的算法。
void countnode(bitree *bt, int &count)
{
if (bt != 0)
{
count++;
countnode(bt->lchild, count);
countnode(bt->rchild, count);
}
}
17.设计计算二叉树中所有结点值之和的算法。
void sum(bitree *bt, int &s)
{
if (bt != 0)
{
s = s + bt->data;
sum(bt->lchild, s);
sum(bt->rchild, s);
}
}
图
18.设计一个算法将无向图的邻接矩阵转为对应邻接表的算法。
typedef struct
{
int vertex[m];
int edge[m][m];
} gadjmatrix;
typedef struct node1
{
int info;
int adjvertex;
struct node1 *nextarc;
} glinklistnode;
typedef struct node2
{
int vertexinfo;
glinklistnode *firstarc;
} glinkheadnode;
void adjmatrixtoadjlist(gadjmatrix g1[], glinkheadnode g2[])
{
int i, j;
glinklistnode *p;
for (i = 0; i <= n - 1; i++)
{
g2[i].firstarc = 0;
}
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= n - 1; j++)
{
if (g1.edge[i][j] == 1)
{
p = (glinklistnode *)malloc(sizeof(glinklistnode));
p->adjvertex = j;
p->nextarc = g[i].firstarc;
g[i].firstarc = p;
p = (glinklistnode *)malloc(sizeof(glinklistnode));
p->adjvertex = i;
p->nextarc = g[j].firstarc;
g[j].firstarc = p;
}
}
}
}
查找
19．设计在顺序有序表中实现二分查找的算法。
struct record
{
int key;
int others;
};
int bisearch(struct recordr[], int k)
{
int low = 0, mid, high = n - 1;
while (low <= high)
{
mid = (low + high) / 2;
if (r[mid].key == k)
{
return (mid + 1);
}
else if (r[mid].key > k)
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}
return (0);
}
排序
20.设有一组初始记录关键字序列（K1，K2，…，Kn），要求设计一个算法能够在 O(n)的时间复杂度内将线性表划分成两部分，其中左半部分的每个关键字均小于 Ki，右半部分的每个关键字均大于等于 Ki。
void quickpass(int r[], int s, int t)
{
int i = s, j = t, x = r[s];
while (i < j)
{
while (i < j && r[j] > x)
{
j = j - 1;
}
if (i < j)
{
r[i] = r[j];
i = i + 1;
}
while (i < j && r[i] < x)
{
i = i + 1;
}
if (i < j)
{
r[j] = r[i];
j = j - 1;
}
}
r[i] = x;
}
21．在链式存储结构上设计直接插入排序算法
void straightinsertsort(lklist *&head)
{
lklist *s, *p, *q;
int t;
if (head == 0 || head->next == 0)
{
return;
}
else
{
for (q = head, p = head->next; p != 0; p = q->next)
{
for (s = head; s != q->next; s = s->next)
{
if (s->data > p->data)
{
break;
}
}
if (s == q->next)
{
q = p;
}
else
{
q->next = p->next;
p->next = s->next;
s->next = p;
t = p->data;
p->data = s->data;
s->data = t;
}
}
}
}
22.设计在链式结构上实现简单选择排序算法。
void simpleselectsorlklist(lklist *&head)
{
lklist *p, *q, *s;
int min, t;
if (head == 0 || head->next == 0)
{
return;
}
for (q = head; q != 0; q = q->next)
{
min = q->data;
s = q;
for (p = q->next; p != 0; p = p->next)
{
if (min > p->data)
{
min = p->data;
s = p;
}
}
if (s != q)
{
t = s->data;
s->data = q->data;
q->data = t;
}
}
}
23.设计求结点在二叉排序树中层次的算法。
int lev = 0;
typedef struct node
{
int key;
struct node *lchild, *rchild;
} bitree;
void level(bitree *bt, int x)
{
if (bt != 0)
{
lev++;
if (bt->key == x)
{
return;
}
else if (bt->key > x)
{
level(bt->lchild, x);
}
else
{
level(bt->rchild, x);
}
}
}
24.设计在链式存储结构上合并排序的算法。
void mergelklist(lklist *ha, lklist *hb, lklist *&hc)
{
lklist *s = hc = 0;
while (ha != 0 && hb != 0)
{
if (ha->data < hb->data)
{
if (s == 0)
{
hc = s = ha;
}
else
{
s->next = ha;
s = ha;
}
ha = ha->next;
}
else
{
if (s == 0)
{
hc = s = hb;
}
else
{
s->next = hb;
s = hb;
}
hb = hb->next;
}
}
if (ha == 0)
{
s->next = hb;
}
else
{
s->next = ha;
}
}
25.设计在二叉排序树上查找结点 X的算法。
bitree *bstsearch1(bitree *t, int key)
{
bitree *p = t;
while (p != 0)
if (p->key == key)
{
return (p);
}
else if (p->key > key)
{
p = p->lchild;
}
else
{
p = p->rchild;
}
return (0);
}
26.设关键字序列(k1，k2，…，kn-1)是堆，设计算法将关键字序列(k1，k2，…，kn-1，x)调整为堆。
void adjustheap(int r[], int n)
{
int j = n, i = j / 2, temp = r[j - 1];
while (i >= 1)
{
if (temp >= r[i - 1])
{
break;
}
else
{
r[j - 1] = r[i - 1];
j = i;
i = i / 2;
}
}
r[j - 1] = temp;
}
标签：int,else,next,bt,算法,lklist,设计,数据结构,data 来源： https://blog.csdn.net/weixin_51571728/article/details/122832972