《数据结构与算法》 第2章 线性表——习题

1.请编写一个倒置顺序表的算法，要求算法的时间复杂性为O(n)，空间复杂性为O(1)。n是顺序表的长度。

#include <stdio.h>
#define MAXN 100
void turn(int List[],int *p_len)
{
if (*p_len<0||*p_len>MAXN)
printf("数组越界");
else{
for (int i=0;i<=*p_len/2;i++)
{
int tmp = List[i];
List[i] = List[*p_len-i-1];
List[*p_len-i-1] = tmp;
}
}
}

int main()
{
int st[MAXN] = {1,2,3,4,5,6,7,8,9,0};
int n = 10;
turn(st,&n);
int i=0;
while (i<10)  {
printf("%d",st[i]);
i++;
}

return 1;
}

2.请编写一个求线性表长度的算法，假定线性表存储为单链表；

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
char data;
struct node *next;
}NODE;

int LinkLen(NODE *L)
{
int k = 0;
while (L) {
k++;
L = L->next;
}
return k;
}

int main()
{
NODE *a,*b,*c;
a = (NODE*)malloc(sizeof(NODE));
b = (NODE*)malloc(sizeof(NODE));
c = (NODE*)malloc(sizeof(NODE));
a->next = b;
b->next = c;
c->next = NULL;
int k = LinkLen(a);
printf("%d",k);
}

3.对单链表重做习题 1；

无表头：

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
int data;
struct node *next;
}NODE;

NODE* TurnLink(NODE *head)
{
NODE *HEAD = NULL;
NODE *p;
while(head){
p = head;
head = head->next;
p->next = HEAD;
HEAD = p;
}
return HEAD;
}

int main()
{
NODE *a,*b,*c;
a = (NODE*)malloc(sizeof(NODE));
b = (NODE*)malloc(sizeof(NODE));
c = (NODE*)malloc(sizeof(NODE));
a->data = 1;
a->next = b;
b->data = 2;
b->next = c;
c->data = 3;
c->next = NULL;
NODE* k = TurnLink(a);
printf("%d",k->data);
}

4.在整数线性表上也可以定义字典序。对任意两个线性表 A=（a0,a1,…,am）,B= (b1,b2,…,bn),其中的数据元素均为整数。
（1）若m=n，且ai = bi（i=0,1，……，m-1），则定义A=B；
（2）若m<n，且ai = bi（i=0,1，……，m-1），则定义A<B；b
（3）若A和B不属于上述两种情况，则必定存在j，使j<min(m,n),ai=bi(i=0,1,…，j-1）,aj≠bj。此时若aj<bj,则定义A<B;否则，定义A>B;
请编写一个算法，判定两个顺序表的大小。若A<B，则返回-1；若A=B，则返回0；若A>B，则返回1。

typedef struct LIST {
int list[MAXN];
int k;
}List;

int test (List a,List b)
{
if (a->k == b->k) {
int time;
for (int i = 0;i<a->k;i++)
if (a->list[i] == b->list[i] )
time++;
if (time == a->k) return 0;
}
if (a->k < b->k) {
int time;
for (int i = 0;i<a->k;i++)
if (a->list[i] == b->list[i] )
time++;
if (time == a->k) return -1;
}
for (int j=0;j<m&&j<n;j++) {
if (a->list[j]<b->list[j]) return -1;
if (a->list[j]>b->list[j]) return 1;
}
}

5.对单链表重做习题4；

int test (NODE *a,NODE *b)
{
int alin = 0,blin = 0;
NODE *pa = a;
NODE *pb = b;
while (pa) {
pa = pa->next;
alin++;
}
pa = a;
while (pb) {
pb = pb->next;
blin++;
}
pb = b;
if (alin == blin) {
int time;
while ((pa->data == pb->data)&&(!pa && !pb)){
pa = pa->next;
pb = pb->next;
time++;
}
if (time == alin) return 0;
}
pa =a,pb =b;
if (alin < blin) {
while ((pa->data == pb->data)&&(!pa && !pb)){
pa = pa->next;
pb = pb->next;
time++;
}
if (time == alin) return -1;
}
pa =a,pb =b;
while (pa->data == pb->data) {
pa = pa->next;
pb = pb->next;
}
if (pa->data<pb->data) return -1;
else return 1;
}

typedef struct node {
int data;
struct node *next;
}NODE;

6.请编写一个算法，删除顺序表中的重复元素。分析你的算法的时间复杂性。
时间复杂性 : O(n^2).

int SqListDelete(int[] list,int *p_len,int i)
{
int j;
if(i<0||i>=*p_len)
return 0;
for (j=i+1;j<*p_len;j++)
list[j-1]=list[j];
(*p_len)--;
}
void Delete (int[] list,int k) {
for (int i=0;i<k;i++) {
for (int j=i+1;j<k;j++) {
if (list[i]==list[j]) {
SqListDelete(list,&k,j);
}
}
}
}

7.请编写一个算法，在单链表中，把值为a的结点插在值为b的结点前面；若链表中没有值为b的结点，则把值为a的结点插在链表的尾部。

typedef struct node{
int data;
struct node *next;
}NODE;

void test7(NODE *head,int a,int b)
{
NODE *p1 = head,p2 = head->next,q1,q2;
if (p1) {
while (p2) {
if (p2->data==a){
break;
}
p1 = p2;
p2 = p2->next;
}
if (!p2) return 0;
q1 = head;
q2 = q->next;
while (q2) {
if (q2->data==b){
p1->next = p2->next;
q1->next = p2;
p2->next = q2;
return 0;
}
q1 = q2;
q2 = q2->next;
}
}
return 0;
}

8.请编写一个算法，将一个带表头的单链表A分解成两个同样结构的链表B和C。其中B的结点是A中值小于零的结点，C的结点是A中值大于零的结点。假设A中存放的是整型数值。

typedef struct node{
int data;
struct node *next;
}NODE;

NODE* test8(NODE *A)
{
NODE *B,*C,a,b,c;
B = (NODE*)malloc(sizeof(NODE));
C = (NODE*)malloc(sizeof(NODE));
B->next = NULL;
C->next = NULL;
a = A;
b = B;
c = C;
while (a->next) {
if (a->next->data<0) {
b->next = a;
b = b->next;
a->next = b->next;
b->next = NULL;
}
else if (a->next->data>0) {
c->next = a;
c = c->next;
a->next = c->next;
c->next = NULL;
}
a = a->next;
}
return B,C;
}

9.设有一个单向循环链表，其中，每个节点含三个域：prior、data和next，data为数据域，next为指向后继结点的指针，prior也是指针，但其值为空（NULL）。试编写一个算法，将此单向循环链表改造为双向循环链表，使prior指向前驱结点。

typedef struct node{
int data;
struct node *next;
struct node *prior;
}NODE;

NODE* test9(NODE *head)
{
NODE *p = head;
NODE *q = head->next;
while (q->prior) {
q->prior = p;
p = q;
q = q->next;
}
}

10.请编写一个算法，将两个带表头的有序循环链表归并成一个带表头的有序循环链表。
出题的SB，不写按什么顺序存储。这里就按照是从小到大吧。

typedef struct node{
int data;
struct node *next;
}NODE;

NODE* test10(NODE *a,NODE *b)
{
NODE *boos = (NODE*)malloc(sizeof(NODE));
boos->next = NULL:
NODE *boos1 = boss;
NODE *p1 = a->next;
NODE *q1 = b->next;
while(!p1 && !p2) {
if (p1->data>q1->data){
boos1->next = p1;
boos1 = boos1->next;
p1 = p1->next;
}
else {
boos1->next = q1;
boos1 = boos1->next;
q1 = q1->next;
}
if (!p1){
boos1->next = q1;
while(q1){
boos1 = q1;
q1 = q1->next;
}
boos1->next = boos->next;
}
else{
boos1->next = p1;
while(p1){
boos1 = p1;
p1 = p1->next;
}
boos1->next = boos->next;
}
return boos;

}

11.假设多项式F(x)表示为带表头的有序单链表，请编写一个求F(x0)的值的算法，x0是任意给定的一个浮点数。