【锐格】数据结构-线性表
欢迎加入NEFU计算机编程交流群：523539085
顺序表
4882
#include4314
这个merge方式用for循环思索了很久还是觉得很难实现，只好用while代替之了
#include 4880
正确输出：4 9 6 2 7
我的输出：4 6 2 7 9
但是样例上面写的又和我一致，就很迷惑
破案了，样例给错了，正确样例应该是数据里面的，还有主函数里面调用函数需要自己去调整顺序…这锐格真的让人迷惑
#include4312
这题思路想出来以后还兴奋了一下
#include4311
双指针的经典应用
#include4877
基础的增删查改的练习，但是需要辨别清楚i在0，1起点时不同的边界（debug了好久…）
#include
#include
using namespace std;
const int defaultSize = 10;
class SeqList {
protected:
int *data;
int maxSize; //表最大可容纳项数
int last; //当前表大小
void reSize(int newSize); //改变data数组空间大小
public:
SeqList(int sz = defaultSize);
SeqList(SeqList &l);
~SeqList();
int Size() const; //计算表最大可容纳表项个数
int Length() const; //计算表长度
int Search(int &x) const; //搜索x在表中位置，函数返回表项序号
bool getData(int i,int &x) const; //取第i歌表项的值，存放在x中
void setData(int i,int &x); //用x修改第i个表项的值
bool Insert(int i,int &x); //插入x在第i歌表项之后
bool Remove(int i,int &x); //删除第i歌表项，用x返回其值
bool isEmpty(); //判断表是否空
bool isFull(); //判断表是否满
void output(); // 输出顺序表
};
//write your code here
SeqList::SeqList(int sz)
{
if (sz>0) {
maxSize = sz;
last = -1;
data = new int[maxSize];
if (data == NULL)
exit(1);
}
}
SeqList::~SeqList()
{
delete []data;
}
int SeqList::Size() const
{
return maxSize;
}
bool SeqList::isFull()
{
if(last==maxSize)
return true;
else
return false;
}
int SeqList::Length() const
{
return last+1;
}
bool SeqList::getData(int i,int &x) const
{
return x=data[i-1];
}
void SeqList::setData(int i,int &x)
{
data[i-1] = x;
}
bool SeqList::Insert(int i,int &x)
{
if (last == maxSize-1)
return false;
if (i<0||i>last+1)
return false;
int j;
for (j=last;j>=i;j--)
data[j+1] = data[j];
data[i] = x;
last++;
return true;
}
bool SeqList::Remove(int i,int &x)
{
int j;
x=data[--i];
for (j=i;j<=last-1;j++)
data[j] = data[j+1];
last--;
return true;
}
// the end
void SeqList::output()
{
int i;
for (i=0;i<=last;i++)
cout << data[i] << " ";
cout << endl;
}
int main()
{
SeqList l(8);
int n,i,x;
cin >> n;
for (i=0;i> x;
if (l.isFull())
break;
l.Insert(i,x);
}
cout << l.Size() << " " << l.Length() << endl;
l.output();
l.Remove(3,n);
l.setData(2,n);
l.getData(1,n);
cout << n << endl;
l.output();
return 0;
}
4866(约瑟夫环问题)
本题比较重要，所以着重理解了一下（过程用注释标注）
#include
#include
/*利用链表实现*/
typedef struct link{
int data;
struct link *next;
}link_s, *link_p;
void createList(link_p &head, int num)
{
if (num < 1)
{
head = NULL;
return;
}
head = (link_p)malloc(sizeof(link_s));
head->data = 1;
head->next = NULL;
link_p new_node = head;
for (int i = 2; i < num+1; i++)
{
new_node->next = (link_p)malloc(sizeof(link_s));
new_node = new_node->next;
new_node->data = i;
new_node->next = NULL;
}
new_node->next = head; /*把最后一个节点指向头结点，构成循环链表*/
return;
}
void output(link_p head)
{
int i = 0;
link_p p_node = head;
while (p_node && i < 100)
{
printf("%d->", p_node->data);
p_node = p_node->next;
i++;
}
return;
}
/*实现功能从1至N开始顺序循环数数，每数到M输出该数值*/
void Josephus(link_p head, int num)
{
int i = 1, remove_num = 1;
link_p p_node = head;
link_p p_temp = NULL;
while (p_node)
{
if (num - 1 == i)
{
if (p_node == p_node->next) /*剩下最后一个节点时，直接打印*/
{
printf("%d ", p_node->data);
free(p_node);
p_node = NULL;
break;
}
i = 1;
printf("%d ", p_node->next->data); /*找到第M-1个节点,打印第M个节点*/
p_temp = p_node->next->next; /*保存第M+1个节点地址*/
free(p_node->next); /*释放第M个节点地址*/
p_node->next = p_temp; /*第M-1个节点指向第M+1个节点*/
p_node= p_node->next; /*p_node指向第M+1个节点*/
remove_num++;
}
else
{
i++;
p_node = p_node->next;
}
}
return ;
}
int main(void)
{
int n = 0, m = 0;
scanf("%d %d", &n, &m);
getchar();
link_p lk = NULL;
createList(lk, n);
Josephus(lk, m);
return 0;
}
单链表
4331
一开始太粗心了，没看清题意，原来这是个循环链表…还以为是什么高级算法对着初始化部分研究了半天
#include 4329
很有意思的一个思路
-
定义双指针指针p和q ；
-
先让p进行移动直到正数第K个数 ；
-
然后q指针开始跟随p指针一起移动 ；
-
直至“”p“”指针遍历到链表末尾 ；
-
此时“”q“”指针指的就是倒数第k个数
其实应当就是当p走过k个数之后，p和q就相对于倒数第k个数对称了，最后得到的就是答案
#include 4320
数据结构的基本练习，相当于读取链表并且进行了一次头插法，大概流程形如
L-NULL
L-1-NULL
L-2-1-NULL
L-5-…-2-1-NULL
以此来达到倒转的目的
#include 4319
属于是前面思维超前了，直接复制前一题的代码就能交…
#include 4885
debug的大胜利
首先这道题要求最后结果微非递增有序，由于本人智力有限，所以实在想不出什么能够直接给两个原非递减的单链表经过一次遍历就直接按照非递增形式存储的方法，所以只能先以非递减形式存储后再进行reverse（这段太好用了），但是中间有个小插曲，就是两个链表中间会有相同数字的处理比较棘手，调试了很久，一开始直接写的是
pc->next = pa;
pc = pa;
pc->next = pb;
pc = pb;
pa = pa->next;
//temp = pb;
pb = pb->next;
感觉逻辑上也没什么问题，就是按照前后文一致的给链表尾部插入节点，然后尾指针后移，但是调试结果显示链表的循环结束不了了。。。里面的数据全是7（也就是卡在了第一个重复的数据上面），后来又想到加了一个pc->next=NULL;依然未果，最后研究了好久发现这么写的话pa和pb的指针会混杂到pc的链表里面，导致最后找不到NULL节点了。。（一直在互相指针），这也是本题设计思路的原则，即要想用老空间存新内容，那么就要在新空间尾节点向后拓展的同时老空间的头节点往后移动，每次都是增减一个数据才能保证完整保存，而且要让pa，pb，pc互不干扰（也就是说其实他们就是三个链表，所以他们三个之间的元素不应该有交集），比如从pa给到pc的节点，那么这个节点就应该从pa里面剥离出去，只和pc有关，而不在pa，pb的节点里，这段思路很有意思，望读者仔细思考
#include
using namespace std;
struct Node {
int data;
Node* next;
};
class List {
private:
Node* first;
public:
List();
~List();
void makeEmpty();
Node* getHead();
void setHead() { first->next = NULL; }
int Length();
void create(int a[], int n);
void output();
};
List::List() {
first = new Node();
first->next = NULL;
}
List::~List() {
//makeEmpty();
//makeEmpty()函数有缺陷，无法删除头结点导致hb的时候出错
}
int List::Length() {
int i = 0;
Node* temp = first->next;
while (temp != NULL) {
i++;
temp = temp->next;
}
return i;
}
Node* List::getHead() {
return first;
}
void List::create(int a[], int n) {
makeEmpty();
Node* temp = first;
int i;
for (i = 0; i < n; i++) {
Node* t = new Node();
t->data = a[i];
t->next = NULL;
temp->next = t;
temp = temp->next;
}
}
void List::makeEmpty() {
Node* q;
while (first->next != NULL) {
q = first->next;
first->next = q->next;
delete q;
}
}
void List::output() {
Node* temp = first->next;
while (temp != NULL) {
cout << temp->data << " ";
temp = temp->next;
}
}
//write your code here
//less
void mergeList(List &ha,List &hb) {
Node* pa, * pb, * pc; //work pointer
pa = ha.getHead()->next;
pb = hb.getHead()->next;
pc = ha.getHead();
while (pa != NULL && pb != NULL) {
//cout<<"--1"<data < pb->data) {
pc->next = pa;
pc = pa;
pa = pa->next;
}
else if (pa->data == pb->data) {
pc->next = pa;
pc = pa;
pa = pa->next;
//temp = pb;
pc->next = pb;
pc = pb;
pb = pb->next;
//delete temp;
}
else {
pc->next = pb;
pc = pb;
pb = pb->next;
}
}
if (pa) {
pc->next = pa;
}
if (pb) {
pc->next = pb;
}
}
void reverseList(List &ha)
{
// write your code here
Node *first=ha.getHead();
Node *tmp=first->next;
Node *p;
first->next=NULL;
while(tmp!=NULL)
{
p=tmp->next;
tmp->next=first->next;
first->next=tmp;
tmp=p;
}
}
int main() {
List ha, hb;
int a[8];
int b[6];
int i;
for (i = 0; i < 8; i++)
cin >> a[i];
for (i = 0; i < 6; i++)
cin >> b[i];
ha.create(a, 8);
hb.create(b, 6);
mergeList(ha, hb);
reverseList(ha);
ha.output();
return 0;
}
4317
标准的链表功能函数编写
#include
cnt++;
if(cnt==i)
{
return p;
}
p=p->next;
}
return NULL;
}
pNode max(pNode head)
{
// write your code here
Node *p=head->next, *maxp;
int maxnum=0;
while(p!=NULL)
{
if(p->data>maxnum)
{
maxp=p;
maxnum=p->data;
}
p=p->next;
}
return maxp;
}
int number(pNode head, int x)
{
// write your code here
Node *p=head->next;
int tot=0;
while(p!=NULL)
{
if(p->data==x) tot++;
p=p->next;
}
return tot;
}
void create(pNode head, int a[],int n)
{
// write your code here
Node* temp = head;
for (int i = 0; i < n; i++) {
Node* t = (Node*)malloc(sizeof(Node));
t->data = a[i];
t->next = NULL;
temp->next = t;
temp = temp->next;
}
}
void output(pNode head)
{
pNode first = head;
pNode temp = first->next;
while (temp!=NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
}
int main()
{
pNode head = (struct Node*)malloc(sizeof(struct Node));
int a[10];
int i;
for(i=0;i<10;i++)
{
scanf("%d", a+i);
}
create(head, a, 10);
printf("%d\n", Locate(head, 3)->data);
printf("%d\n", max(head)->data);
printf("%d\n", number(head, 7));
output(head);
getchar();
return 0;
}
4883
头插法，为啥把基础题放到后面了…
#include
#include
using namespace std;
struct Node {
int data;
Node *next;
};
class List {
private:
Node *first;
public:
List();
~List();
void makeEmpty();
void inputFront(int endTag);
void output();
};
List::List()
{
first = new Node();
first->next = NULL;
}
List::~List()
{
makeEmpty();
}
void List::makeEmpty()
{
Node *q;
while (first->next!=NULL) {
q = first->next;
first->next = q->next;
delete q;
}
}
void List::inputFront(int endTag)
{
//write your code here
int x;
while(cin>>x && x!=endTag)
{
Node *p=(Node*)malloc(sizeof(Node));
p->data=x;
p->next=first->next;
first->next=p;
}
}
void List::output()
{
Node *temp = first->next;
while (temp!=NULL) {
cout << temp->data << " ";
temp = temp->next;
}
}
int main()
{
List l;
l.inputFront(-1); //结束符为-1
l.output();
return 0;
}
4867
后面应该都是链表带交互的应用题
#include
#include
using namespace std;
struct Lnode {
int data;
Lnode *next;
};
void initLinklist(Lnode *&head) {
int input, n;
scanf("%d", &n);
while (n--) {
scanf("%d", &input);
Lnode *p = new Lnode;
p->data = input;
p->next = head->next;
head->next = p;
}
}
int getData(Lnode *&head) {
int pos;
scanf("%d", &pos);
Lnode *p = head;
while (pos-- && p)
p = p->next;
if (p)
printf("%d\n", p->data);
else
puts("get fail");
}
int insertData(Lnode *&head) {
int pos, x;
scanf("%d%d", &pos, &x);
Lnode *p = head;
--pos;
while (pos-- && p)
p = p->next;
if (p) {
Lnode *temp = new Lnode;
temp->data = x;
temp->next = p->next;
p->next = temp;
puts("insert OK");
} else
puts("insert fail");
}
int deleteNode(Lnode *&head) {
int pos;
scanf("%d", &pos);
Lnode *p = head;
--pos;
while (pos-- && p->next)
p = p->next;
if (p->next) {
Lnode *q = p->next;
p->next = q->next;
delete(q);
puts("delete OK");
} else
puts("delete fail");
}
void showLinklist(Lnode *&head) {
Lnode *p = head->next;
if (p) {
while (p) {
printf("%d ", p->data);
p = p->next;
}
putchar('\n');
} else
puts("Link list is empty");
}
int main() {
int n, m;
char input[100];
Lnode *head = new Lnode;
head->next = nullptr;
initLinklist(head);
scanf("%d", &m);
while (m--) {
scanf("%s", input);
if (!strcmp(input, "show"))
showLinklist(head);
else if (!strcmp(input, "get"))
getData(head);
else if (!strcmp(input, "insert"))
insertData(head);
else if (!strcmp(input, "delete"))
deleteNode(head);
}
return 0;
}
4865
#include 4864
#include 4863
#include 循环链表和双向链表
4330
#include4895
sym==true;//这段答案要求分号是我没想到的
p=p->rLink;
4861
#include4859
#include4858
顺序表原题
#include4857
这题更是重量级…太逆天了
#include上机实验
4319
#include 4314
#include 4329
#include