(数据结构)上级考试//

//1. 有序顺序表插入及合并

#include<stdio.h>
#include<malloc.h>
typedef struct {
int l;
int *a;
}list;
int insert_(list &l,int v){

if(l.l == 0){ // 线性表有 0个元素 直接插入
l.a[0] = v;
++l.l;
return 1;
}
else{
int wh;
for(wh = 0; wh < l.l; wh++){ // 找出需要插入的位置
if(l.a[wh] > v)
break;
}
for(int i = l.l-1; i >= wh; i--){ // 需要插入位置后的元素全部后移一位
l.a[i+1] = l.a[i];
}
l.a[wh] = v;
++l.l; // 不要忘记 长度加一
return 1;
}
}

void con_(list &l,list &p){
for(int i=0;i<p.l;i++)
insert_(l,p.a[i]);

}
void print(list &p){
for(int i=0;i<p.l;i++)
{
printf("%d ",p.a[i]);
}
printf("\n");
}
int main(){
list p;
p.a=(int*)malloc(sizeof(int)*1000);
p.l=0;
list q;
q.a=(int*)malloc(sizeof(int)*1000);
q.l=0;
//初始化有序表1
for(int i=1;i<=5;i++)
{
// printf("%d ",p.l);
insert_(p,i);
}
printf("有序表1\n");
print(p);
//初始化有序表2
for(int i=6;i<=10;i++)
{
// printf("%d ",p.l);
insert_(q,i);
}
printf("有序表2\n");
print(q);
con_(p,q);
printf("合并\n");
print(p);
printf("插入元素吧");
insert_(p,99);
print(p);
system("pause");
}

// 2.实现有序顺序表插入及遍历，调试成功
#include<stdio.h>
#include<malloc.h>
typedef struct {
int l;
int *a;
}list;
int insert_(list &l,int v){

if(l.l == 0){ // 线性表有 0个元素 直接插入
l.a[0] = v;
++l.l;
return 1;
}
else{
int wh;
for(wh = 0; wh < l.l; wh++){ // 找出需要插入的位置
if(l.a[wh] > v)
break;
}
for(int i = l.l-1; i >= wh; i--){ // 需要插入位置后的元素全部后移一位
l.a[i+1] = l.a[i];
}
l.a[wh] = v;
++l.l; // 不要忘记 长度加一
return 1;
}
}

void print(list &p){
for(int i=0;i<p.l;i++)
{
printf("%d ",p.a[i]);
}
printf("\n");
}
int main(){
list p;
p.a=(int*)malloc(sizeof(int)*1000);
p.l=0;
list q;
q.a=(int*)malloc(sizeof(int)*1000);
q.l=0;
//初始化有序表
for(int i=1;i<=5;i++)
{
// printf("%d ",p.l);
insert_(p,i);
}
printf("有序表1\n");
print(p);

printf("插入元素吧");
insert_(p,99);
print(p);
system("pause");
}

// 3有序顺序表建立、删除指定序号节点及遍历，调试成功

#include<stdio.h>
#include<malloc.h>
typedef struct {
int l;
int *a;
}list;
int insert_(list &l,int v){

if(l.l == 0){ // 线性表有 0个元素 直接插入
l.a[0] = v;
++l.l;
return 1;
}
else{
int wh;
for(wh = 0; wh < l.l; wh++){ // 找出需要插入的位置
if(l.a[wh] > v)
break;
}
for(int i = l.l-1; i >= wh; i--){ // 需要插入位置后的元素全部后移一位
l.a[i+1] = l.a[i];
}
l.a[wh] = v;
++l.l; // 不要忘记 长度加一
return 1;
}
}

int del_(list &l, int sta){
if(sta > l.l || sta <= 0)
return 0;
sta--;
for(int i = sta; i < l.l-1; i++)
l.a[i] = l.a[i+1];
l.l--;
return 1;
}

void print(list &p){
for(int i=0;i<p.l;i++)
{
printf("%d ",p.a[i]);
}
printf("\n");
}
int main(){
list p;
p.a=(int*)malloc(sizeof(int)*1000);
p.l=0;
list q;
q.a=(int*)malloc(sizeof(int)*1000);
q.l=0;
//初始化有序表
for(int i=1;i<=5;i++)
{
// printf("%d ",p.l);
insert_(p,i);
}
printf("有序表1\n");
print(p);

printf("删除元素吧");
del_(p,1);
print(p);
// printf("被删除元素%d\n",m);
system("pause");
}

// 4有序单链表插入及合并

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

typedef struct Node{
int data;
Node *next;
}*list,node;
void init_(list &p){
p=(node *)malloc(sizeof(node));
p->next=NULL;
}

int insert_(list & p,int v){
list l,s;
l=p;
s=(node *)malloc(sizeof(node));
if(l->next==NULL)
{
s -> data = v;
l -> next = s;
s -> next = NULL;
return 1;
}

while(((l->next)->data) < v)
{
l=l->next;
if((l->next)==NULL)
break;
}

s->data=v;
s->next=l->next;
l->next=s;
return 0;
}
int con(list & p,list &l){
list m=p,n=l;
while(m->next){
insert_(n,m->next->data);
m=m->next;
}
}
int print(list p){

while(p->next)
{

printf("%d ",p->next->data);
p=p->next;
}
printf("\n");
}
int main(){
int i,j,n;
list p;
list l;
init_(p);
init_(l);
for(i=5;i>0;i--)
{
insert_( p,i);
}
print(p);//链表1
for(i=6;i<10;i++)
{
insert_( l,i);
}
print(l);//链表2
con(l,p);
print(p);//合并

printf("输入插入元素：");
scanf("%d",&n);
insert_(p,n);
print(p);//插入后

system("pause");

}

//5 有序单链表插入及遍历
#include<stdio.h>
#include<stdlib.h>

typedef struct Node{
int data;
Node *next;
}*list,node;
void init_(list &p){
p=(node *)malloc(sizeof(node));
p->next=NULL;
}

int insert_(list & p,int v){
list l,s;
l=p;
s=(node *)malloc(sizeof(node));
if(l->next==NULL)
{
s -> data = v;
l -> next = s;
s -> next = NULL;
return 1;
}

while(((l->next)->data) < v)
{
l=l->next;
if((l->next)==NULL)
break;
}

s->data=v;
s->next=l->next;
l->next=s;
return 0;
}
int print(list p){

while(p->next)
{

printf("%d ",p->next->data);
p=p->next;
}
printf("\n");
}
int main(){
int i,j,n;
list p;
list l;
init_(p);
init_(l);
for(i=5;i>0;i--)
{
insert_( p,i);
}
print(p);//链表1
printf("输入插入元素：");
scanf("%d",&n);
insert_(p,n);
print(p);//插入后

system("pause");

}

// 6有序单链表建立、删除指定序号节点及遍历
#include<stdio.h>
#include<stdlib.h>

typedef struct Node{
int data;
Node *next;
}*list,node;

void init_(list &p){
p=(node *)malloc(sizeof(node));
p->next=NULL;
}

int insert_(list & p,int v){
list l,s;
l=p;
s=(node *)malloc(sizeof(node));
if(l->next==NULL)
{
s -> data = v;
l -> next = s;
s -> next = NULL;
return 1;
}

while(((l->next)->data) < v)
{
l=l->next;
if((l->next)==NULL)
break;
}

s->data=v;
s->next=l->next;
l->next=s;
return 0;
}
int del_(list & l,int n)
{
int i=0,m;
list p;
p=l;
while(p->next)
{
if(i==n-1)
{
m=p->next->data;
p->next=p->next->next;
}

i++;
p=p->next;
}
return m;
}

int print(list p){

while(p->next)
{

printf("%d ",p->next->data);
p=p->next;
}
printf("\n");
}
int main(){
int i,j,n;
list p;
list l;
init_(p);
init_(l);
for(i=5;i>0;i--)
{
insert_( p,i);
}
print(p);//链表1
printf("输入删除元素实际位置：");
scanf("%d",&n);
int m=del_(p,n);
print(p);//
printf("被删除元素%d\n",m);
system("pause");

}

// 7二叉树建立以及先序遍历,int型 调试成功

#include "iostream" //cout,cin
#include<malloc.h> // malloc,remalloc
#include<stdio.h>
#include<conio.h>
using namespace std;

typedef int TElemType;
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild; // 左右孩子指针
}BiTNode,*BiTree;

// 构造空二叉树
void InitBiTree(BiTree &T)
{
T=NULL;
}
// 建立二叉树
void CreateBiTree(BiTree &T)
{
TElemType ch;
cin>>ch;
if(ch==0) // 空
T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点

T->data=ch;
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树
}
}

// 先序遍历二叉树
void PreOrderTraverse(BiTree T)
{
if(T) // T不空
{

cout<<T->data<<" ";
PreOrderTraverse(T->lchild); // 再先序遍历左子树

PreOrderTraverse(T->rchild); // 最后先序遍历右子树

}
}

int main(){
BiTree p;
InitBiTree(p);
cout<<"测试二叉树的先序建立，请输入二叉树的节点数据(0代表空节点)"<<endl;
CreateBiTree(p);
cout<<"测试二叉树的遍历，先序遍历二叉树为"<<endl;
PreOrderTraverse(p);
system("pause");
return 0;
}

// 8二叉树建立以及中序遍历,int型 调试成功

#include "iostream" //cout,cin
#include<malloc.h> // malloc,remalloc
#include<stdio.h>
#include<conio.h>
using namespace std;

typedef int TElemType;
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild; // 左右孩子指针
}BiTNode,*BiTree;

// 构造空二叉树
void InitBiTree(BiTree &T)
{
T=NULL;
}
// 建立二叉树
void CreateBiTree(BiTree &T)
{
TElemType ch;
cin>>ch;
if(ch==0) // 空
T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点

T->data=ch;
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树
}
}

// 先序遍历二叉树
void PreOrderTraverse(BiTree T)
{
if(T) // T不空
{

PreOrderTraverse(T->lchild); // 再先序遍历左子树
cout<<T->data<<" ";
PreOrderTraverse(T->rchild); // 最后先序遍历右子树

}
}

int main(){
BiTree p;
InitBiTree(p);
cout<<"测试二叉树的先序建立，请输入二叉树的节点数据(0代表空节点)"<<endl;
CreateBiTree(p);
cout<<"测试二叉树的遍历，先序遍历二叉树为"<<endl;
PreOrderTraverse(p);
system("pause");
return 0;
}

// 9二叉树建立以及后序遍历,int型 调试成功

#include "iostream" //cout,cin
#include<malloc.h> // malloc,remalloc
#include<stdio.h>
#include<conio.h>
using namespace std;

typedef int TElemType;
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild; // 左右孩子指针
}BiTNode,*BiTree;

// 构造空二叉树
void InitBiTree(BiTree &T)
{
T=NULL;
}
// 建立二叉树
void CreateBiTree(BiTree &T)
{
TElemType ch;
cin>>ch;
if(ch==0) // 空
T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点

T->data=ch;
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树
}
}

// 先序遍历二叉树
void PreOrderTraverse(BiTree T)
{
if(T) // T不空
{

PreOrderTraverse(T->lchild); // 再先序遍历左子树

PreOrderTraverse(T->rchild); // 最后先序遍历右子树
cout<<T->data<<" ";
}
}

int main(){
BiTree p;
InitBiTree(p);
cout<<"测试二叉树的先序建立，请输入二叉树的节点数据(0代表空节点)"<<endl;
CreateBiTree(p);
cout<<"测试二叉树的遍历，先序遍历二叉树为"<<endl;
PreOrderTraverse(p);
system("pause");
return 0;
}

// 10二叉树求深度

#include "iostream" //cout,cin
#include<malloc.h> // malloc,remalloc
#include<stdio.h>
#include<conio.h>
using namespace std;

typedef int TElemType;
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild; // 左右孩子指针
}BiTNode,*BiTree;

// 构造空二叉树
void InitBiTree(BiTree &T)
{
T=NULL;
}
// 建立二叉树
void CreateBiTree(BiTree &T)
{
TElemType ch;
cin>>ch;
if(ch==0) // 空
T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点

T->data=ch;
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树
}
}

// 求二叉树的深度
int depth(BiTree root)
{
int ldepth,rdepth;
if(!root) return 0;
else{
ldepth = depth(root->lchild);
rdepth = depth(root->rchild);
return ldepth>rdepth?ldepth+1:rdepth+1;
}
}

int main(){
BiTree p;
InitBiTree(p);
cout<<"测试二叉树的先序建立，请输入二叉树的节点数据(0代表空节点)"<<endl;
CreateBiTree(p);
cout<<"测试二叉树的深度，二叉树的深度为"<<endl;
cout<<depth(p);
system("pause");
return 0;
}

// 11统计二叉树节点数

#include "iostream" //cout,cin
#include<malloc.h> // malloc,remalloc
#include<stdio.h>
#include<conio.h>
using namespace std;

typedef int TElemType;
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild; // 左右孩子指针
}BiTNode,*BiTree;

// 构造空二叉树
void InitBiTree(BiTree &T)
{
T=NULL;
}
// 建立二叉树
void CreateBiTree(BiTree &T)
{
TElemType ch;
cin>>ch;
if(ch==0) // 空
T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点

T->data=ch;
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树
}
}

// 统计节点数
int tmp=0;
void tj(BiTree T)
{
if(T) // T不空
{

tmp++;
tj(T->lchild); // 再先序遍历左子树

tj(T->rchild); // 最后先序遍历右子树

}
}

int main(){
BiTree p;
InitBiTree(p);
cout<<"测试二叉树的先序建立，请输入二叉树的节点数据(0代表空节点)"<<endl;
CreateBiTree(p);
cout<<"测试二叉树的节点数"<<endl;
tj(p);
cout<<tmp;
system("pause");
return 0;
}

// 12折半查找(非递归) 调试成功

#include<iostream>
#include<malloc.h>
using namespace std;

typedef int KeyType;
typedef struct // 数据元素类型
{
int key;
}ElemType;

typedef struct
{
ElemType *elem; // 数据元素存储空间基址，建表时按实际长度分配，0号单元留空
int length; // 表长度
}SSTable;

//----------------------------------------折半查找操作---------------------------------//

// 创建静态表
void Creat_Seq(SSTable &ST,int n)
{ // 操作结果：由含n个数据元素的数组r构造静态顺序查找表ST(见图9?2)
int i,k;
ST.elem=(ElemType*)calloc(n+1,sizeof(ElemType));// 动态生成n+1个数据元素空间(0号单元不用)
// if(!ST.elem)
// exit(ERROR);
for(i=1;i<=n;i++){
cin>>k;
ST.elem[i].key=k;
}
// ST.elem[i].key=r[i-1]; // 将数组r的值依次赋给ST
ST.length=n;
}

// 折半查找
int Search_Bin(SSTable ST,KeyType key)
{ // 在有序表ST中折半查找其关键字等于key的数据元素。若找到，则返回
// 该元素在表中的位置；否则返回0。算法9.2
int low,high,mid;
low=1; // 置区间初值
high=ST.length;
while(low<=high)
{
mid=(low+high)/2;
if (ST.elem[mid].key == key) // EQ(key,ST.elem[mid].key) // 找到待查元素
return mid;
else if (ST.elem[mid].key>key) // LT(key,ST.elem[mid].key)
high=mid-1; // 继续在前半区间进行查找
else
low=mid+1; // 继续在后半区间进行查找
}
return 0; // 顺序表中不存在待查元素
}

//-------------------------------main函数测试------------------------------//

int main(){
int n;
SSTable T;
cout<<"测试静态表的输入，请输入静态数据表元素的个数以及各元素"<<endl;
cin>>n;
Creat_Seq(T,n);
cout<<"静态表创建成功，请输入查找数据"<<endl;
cin >> n;
cout<<"查找的数据在"<<Search_Bin(T,n)<<endl;
system("pause");
return 0;
}
// 12折半查找(递归) 调试成功

#include<iostream>
#include<malloc.h>
using namespace std;

typedef int KeyType;
typedef struct // 数据元素类型
{
int key;
}ElemType;

typedef struct
{
ElemType *elem; // 数据元素存储空间基址，建表时按实际长度分配，0号单元留空
int length; // 表长度
}SSTable;

//----------------------------------------折半查找操作---------------------------------//

// 创建静态表
void Creat_Seq(SSTable &ST,int n)
{ // 操作结果：由含n个数据元素的数组r构造静态顺序查找表ST(见图9?2)
int i,k;
ST.elem=(ElemType*)calloc(n+1,sizeof(ElemType));// 动态生成n+1个数据元素空间(0号单元不用)
// calloc 和malloc是一样的效果，初始值calloc为0,malloc为乱值
// if(!ST.elem)
// exit(ERROR);
for(i=1;i<=n;i++){
cin>>k;
ST.elem[i].key=k;
}
// ST.elem[i].key=r[i-1]; // 将数组r的值依次赋给ST
ST.length=n;
}

// 折半查找，递归
int Search_Bin(SSTable ST,int low, int high,int key)
{
int mid;
if(low>high)
return 0; // 顺序表中不存在待查元素
else{
mid = (low+high) / 2;
if(ST.elem[mid].key==key)
return mid;
if(key>ST.elem[mid].key)
return Search_Bin(ST,mid+1,high,key); /*在序列的后半部分查找*/
else
return Search_Bin(ST,low,mid-1,key); /*在序列的前半部分查找*/
}
}

//-------------------------------main函数测试------------------------------//

int main(){
int n,k;
SSTable T;
cout<<"测试有序静态表的输入，请输入静态数据表元素的个数以及各元素"<<endl;
cin>>n;
Creat_Seq(T,n);
cout<<"静态表创建成功，请输入查找数据"<<endl;
cin >> k;
cout<<"查找的数据在第"<<Search_Bin(T,1,n,k)<<"位"<<endl;
system("pause");
return 0;
}
//13二叉排序树
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;
typedef struct tree{
int v;
tree *left,*right;
tree():left(NULL),right(NULL){}
}*root,node;
int creat_tree(root & t,int val){
if(t == NULL){
t = (node*)malloc(sizeof(node));
t -> v = val;
t -> right = t -> left = NULL;
return 1;
}
if(val == t->v)
return 0;
if(val > t -> v)
return creat_tree(t -> right, val); // 递归搜索要插入的位置， 小于该节点 一定在左侧
else
return creat_tree(t -> left, val);
}
int midorder(root &t){ // 其实 先序 中序 后序遍历 程序都差不多， 只不过跟输出的位置不一样罢了
if(t){
if(midorder(t->left)){
printf("%d ",t->v);
if(midorder(t->right))
return 1;
}
}
return 1;
}
int main (){
root t;
int n;
scanf("%d",&n);
t = NULL;
for(int i = 0; i < n; i++){
int val;
scanf("%d",&val);
creat_tree(t,val); //abd e cf g .(.之前的全部输入 包括空格)
}
midorder(t);
printf("\n");
system("pause");
return 0;
}

// 14冒泡排序

#include <stdio.h>
#include<iostream>
using namespace std;

// 冒泡排序算法
void bubblesort(int k[],int n){ /*冒泡排序*/
int i,j,tmp ,flag = 1;
for(i=1;i<=n-1 && flag == 1;i++){ /*执行n-1趟排序*/
flag = 0; // 用来判断数据已经排好序
for(j=1;j<=n-i;j++){
if(k[j]<k[j+1]){ /*数据交换*/
tmp = k[j+1];
k[j+1] = k[j];
k[j] = tmp;
flag = 1;
}
}
}
}

int main()
{
int i,n; /*初始化序列，a[0]可任意置数*/
cout<<"请输入数据个数，以及数据元素"<<endl;
cin>>n; int a[n];
for(i=1;i<=n;i++) /*显示原序列之中的元素*/
cin>>a[i];
bubblesort(a,n); /*执行冒泡排序*/
cout<<"冒泡排序后的顺序为"<<endl;
for(i=1;i<=n;i++)
cout<<a[i]<<" "; /*输出排序后的结果*/
getchar();
return 0;
}

// 15 直接选择排序
#include <stdio.h>
#define M 20
void insert_sort(int a[],int n)
//待排序元素用一个数组a表示，数组有n个元素
{
int i,j;
int temp;
for (i=1;i<n;i++) //i表示插入次数，共进行n-1次插入
{
temp=a[i]; //把待排序元素赋给temp，temp在while循环中并不改变，这样方便比较，并且它是要插入的元素
j=i-1;
//while循环的作用是将比当前元素大的元素都往后移动一个位置
while ((j>=0)&& (temp<a[j])){
a[j+1]=a[j];
j--; // 顺序比较和移动,依次将元素后移动一个位置
}
a[j+1]=temp;//元素后移后要插入的位置就空出了，找到该位置插入
}
}
int main(){
int a[M];
int i,n;
printf("请输入元素个数:\n");
scanf("%d",&n);
printf("请输入元素:\n");
for (i=0; i<n; i++)
scanf("%d",&a[i]);
insert_sort(a,n);
for(i=0;i<n;i++)
printf("%d\t",a[i]);
return 0;
}

// 16简单选择排序

#include <stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;

// 简单选择排序
void SelectSort(int r[], int length)
{ // 对记录数组r做简单选择排序，length为数组的长度
int k,i,j,x; int n=length;
for ( i=1 ; i<=n-1; ++i)
{
k = i;
for ( j=i+1 ; j<=n ; ++j)
if(r[j] < r[k] ) k=j;
if (k!=i)
{
x= r[i]; r[i]= r[k]; r[k]=x;
}

}

}

int main()
{
int i,n; /*初始化序列，a[0]可任意置数*/
cout<<"请输入数据个数，以及数据元素"<<endl;
cin>>n; int a[n];
for(i=1;i<=n;i++) /*显示原序列之中的元素*/
cin>>a[i];
SelectSort(a,n); /*执行冒泡排序*/
cout<<"选择排序后的顺序为"<<endl;
for(i=1;i<=n;i++)
cout<<a[i]<<" "; /*输出排序后的结果*/
getchar();
system("pause");
return 0;
}

时间： 2024-08-30 09:30:12

(数据结构)上级考试//的相关文章

数据结构技能考试系统

通过一个月的努力,终于把数据结构技能考试系统用C++的语言实现(其中有C语言的穿插),系统的最大优点是可以检测学生答题时是否插入了U盘,打开了word及记事本等辅助工具.此系统分为两部分,一部分是学生端,一部分是教师端. 学生端主要是学生输入学号及姓名(对此进行检测),根据学号的后四位对应的ASCII码模8求值,达到抽题的效果(也可适当改进改为IP读题),在题库中抽取两道题,随机答一道题即可,在完成作答后选择所作的试题,避免了选题后不会做的情况.抽题时显示倒计时,时间为60分钟,如若超时,允许的

厦门大学数据结构期末考试单链表问题

因为过几天要去参加厦门大学的夏令营,提前刷了下厦门大学往年的期末考试试卷. 卷中有这么一道题目: 有一个单链表,其结点的元素值以递增顺序排列,给出数据结构,并编写一个算法删除该单链表中元素值相同的结点. 算法如下: 从头到尾扫描单链表,若当前结点和后继结点的值不相同,则指针后移,若相同,则删除该后继结点. 1 #include "stdio.h" 2 3 typedef struct Node{ 4 int data; 5 struct Node *next; 6 }Node, *Li

第三部分数据结构[专业课考试3]

考试题型:问答.分析.编程(廖老师:可用自己熟悉的程序语言.伪代码均可) 总分:60分 一.栈(Stack).队列(Queue)和向量(Vector) 内容: 单链表,双向链表,环形链表,带哨兵节点的链表; 栈的基本概念和性质,栈ADT及其顺序,链接实现;栈的应用;栈与递归; 队列的基本概念和性质,队列ADT及其顺序,链接实现;队列的应用; 向量基本概念和性质;向量ADT及其数组.链接实现; 二.树 内容: 树的基本概念和术语;树的前序,中序,后序,层次序遍历; 二叉树及其性质;普通树与二叉树的

数据结构期末考试算法

1.设计一个高效的算法,从顺序表L中删除所有值为x的元素,要求时间复杂度为O(n),空间复杂度为O(1). //p71 #define MAXSIZE 100 typedef struct { ElemType elem[MAXSIZE]; int last; }SeqList; void delx(SeqList * L,ElemType x) { int i = 0; int j = 0; while(i <= L->last) { if(L->elem[i]!=x) { L->

2015数据结构上机考试题解

#include<cstdio> #define inf 0x3f3f3f3f const int maxn=10000; using namespace std; int n,m,q; int a[maxn+10]; int bs(int x){ int l=0,r=n-1; while(l<=r){ int mid=(l+r)>>1; if(a[mid]==x) return 1; else if(a[mid]>x) r=mid-1; else l=mid+1; }

数据结构上机考试（楷神版）

插入排序 #include<cstdio> using namespace std; const int maxn = 1111; int array1[maxn]; int array2[maxn]; //1 2 4 7 -1 void insert(int v){ for(int i = 0;i <= v; i++){ if(i == v){ //如果需要插入到最后一个位置 array2[i] = array1[v]; return; } if(array2[i] > arra

华南农业大学数据结构上机考试

8576 顺序线性表的基本操作 时间限制:1000MS  内存限制:1000K提交次数:9027 通过次数:2456 题型: 编程题   语言: G++;GCC Description 编写算法,创建初始化容量为LIST_INIT_SIZE的顺序表T,并实现插入.删除.遍历操作.本题目给出部分代码,请补全内容. #include<stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define LIST_INIT_SI

数据结构期末考试复习--3

删除 L 中所有值为 item 的元素 void Delete_e(SqList &L,ElemType e) {int i=0,j=L.length-1;//设置数组低.高端指针(下标). while(i<j) { while(i<j&&L.elem[i]!=e)i++; //若值不为e,右移指针. while(i<j&&L.elem[j]==e){ j--; // L.length--; }//若右端元素为item,指针左移 if(i<=

栈和队列数据结构博客园

1.本周学习总结(0--1分) 谈谈你对栈和队列结构的认识及学习体会. 体会:本章学习了栈和队列,堆栈和队列都是特殊的线性表,其数据元素以及数据元素之间的逻辑关系完全相同, 区别在于:线性表的插入和删除操作不受限制,堆栈只能在栈顶插入和删除,队列只能在队尾插入,在队头删除. 栈的特点还是非常有意思的,对于解决迷宫问题时有很好的 作用,栈的结构能保证迷宫问题中指针神时候进 去什么时候出来,通过保存从入口到当前位置的路径上走过的方块,可以保证所有位置可以原路返回.总之, 对于栈和队列的知识的初步了解