线性表详述

最新推荐文章于 2023-06-14 18:55:24 发布

转载最新推荐文章于 2023-06-14 18:55:24 发布 · 419 阅读

文章标签：

#list #pivot #存储 #struct #null #数据结构

数据结构学习笔记专栏收录该内容

13 篇文章

订阅专栏

1. 线性表：n个数据元素的有序集合。

线性表是一种常用的数据结构。在实际应用中，线性表都是以栈、队列、字符串、数组等特殊线性表的形式来使用的。由于这些特殊线性表都具有各自的特性，因此，掌握这些特殊线性表的特性，对于数据运算的可靠性和提高操作效率都是至关重要的。　　线性表是一个线性结构，它是一个含有n≥0个结点的有限序列，对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个终端结点没有后继但有一个前驱结点，其它的结点都有且仅有一个前驱和一个后继结点。

特征：

1．集合中必存在唯一的一个“第一元素”；
2．集合中必存在唯一的一个 “最后元素” ；
3．除最后一个元素之外，均有唯一的后继(后件)；
4．除第一个元素之外，均有唯一的前驱(前件)。

java中的List接口，就是线性表。ArrayList就是顺序线性表，LinkedList就是链表线性表。

2. 线性表的顺序表示：ArrayList

一般使用数组(C语言中的数组采用顺序存储方式。即连续地址存储)来描述。

优点：在于随机访问元素，

缺点：插入和和删除的时候，需要移动大量的元素。

c语言实现代码：

[cpp] view plain copy print ?

// Test.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <stdio.h>
#include "stdlib.h"
//宏定义
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LT(a,b) ((a)<(b))
#define N = 100
#define LIST_INIT_SIZE 100 //线性表初始空间分配量
#define LISTINCREMENT 10 //线性表空间分配的增量
typedef int Status;
typedef int ElemType;
typedef struct LNode{
ElemType *elem; //存储空间的基地址
int lenght; //当前的长度
int listsize; //当前分配的存储容量
}SqList;
/**
*构造空的线性表
*/
Status initList(SqList &L, int lenght){
if (lenght == 0) lenght = LIST_INIT_SIZE;
L.elem = (ElemType *)malloc(lenght * sizeof(ElemType));
if(!L.elem) exit(OVERFLOW); //分配存储空间失败
L.lenght = 0; //初始空表长度为0
L.listsize = lenght ;//初始存储容量为100
return OK;
}
/************************************************************************/
/* 在第i位置插入e
*/
/************************************************************************/
Status insertList(SqList &L, ElemType e, int i){
ElemType *p, *q;
if(i<0 ||i > L.lenght) return ERROR; //i值不合法
if (L.lenght >= L.listsize) {
ElemType *newbase = (ElemType *)realloc(L.elem ,(L.listsize +LISTINCREMENT)*sizeof(ElemType));
if(!newbase) return OVERFLOW; //存储分配失败
L.elem = newbase; //新基值
L.listsize += LISTINCREMENT; //增加存储容量
}
q = &L.elem[i]; //q为插入的位置
for (p = &L.elem[L.lenght]; p>=q; --p) {
*p = *(p-1); //i元素之后的元素往后移动
}
*q = e; //插入e
L.lenght +=1;
return OK;
}
/************************************************************************/
/* 快速排序
*/
/************************************************************************/
void sortList(SqList &L){
}
/************************************************************************/
/* 删除第i位置元素，并用e返回其值 */
/************************************************************************/
Status deleteListElem(SqList &L, int i, ElemType &e){
int *p, *q;
if(i<0 ||i > L.lenght) return ERROR; //i值不合法
q = &L.elem[i]; //被删除元素的位置为i，L.elem就是数组名,
e = *q; //被删除元素的值赋值给e
for (p = q; p< (L.elem + L.lenght); p++){ //元素左移
*p = *(p+1);
}
--L.lenght;
return OK;
}
/************************************************************************/
/* 快速排序
*/
/************************************************************************/
int partition(SqList &L, ElemType low, ElemType high){
ElemType pivotkey = L.elem[low]; //枢轴记录关键字
while (low < high) { //从表的两端向中间扫描
while (low < high && L.elem[high] >= pivotkey ) --high;//高端位置扫描
L.elem[low] = L.elem[high]; //交换数据，小于pivotkey移到低端
L.elem[high] = pivotkey;
while (low < high && L.elem[low] <= pivotkey ) ++low; //低端扫描
L.elem[high] = L.elem[low]; //交换数据大于pivotkey移到高端
L.elem[low] = pivotkey;
}
return low;
}
void quickSort(SqList &L, ElemType low, ElemType high){
int pivot;
if(low < high) {
pivot = partition(L, low, high);
quickSort(L, low, pivot -1); //低端子表排序
quickSort(L, pivot +1, high); //高端子表排序
}
}
/************************************************************************/
/*
合并两个线性表
*/
/************************************************************************/
void mergeList(SqList La, SqList Lb, SqList &Lc){
ElemType *pa, *pb, *pc;
Lc.listsize = La.lenght + Lb.lenght;
initList(Lc, Lc.listsize); //初始化LC\pc = Lc.elem;
Lc.lenght = Lc.listsize;
pc = Lc.elem;
pa = La.elem;
pb = Lb.elem;
while (pa <= &La.elem[La.lenght -1] && pb <= &Lb.elem[Lb.lenght -1]){
if (*pa <= *pb) *pc++ = *pa++;
else *pc++ = *pb++;
}
while(pa <= &La.elem[La.lenght -1]) *pc++ = *pa++; //插入La的剩余元素
while(pb <= &Lb.elem[Lb.lenght -1]) *pc++ = *pb++; //插入Lb的剩余元素
}
/************************************************************************/
/* 打印list
*/
/************************************************************************/
void printList(SqList L){
printf("当前值:");
for (int i =0; i<L.lenght;i++) {
printf("%d ", *(L.elem+i)); // L.elem为首地址
}
printf("\r\n");
}
void main()
{
SqList La,Lb,Lc;
ElemType e;
int init,i;
init = initList(La, LIST_INIT_SIZE);
int data[6] = {5,3,6,2,7,4};
for (i=0; i<6;i++) {
insertList(La, data[i], i);
}
printf("LA:\r\n");
printList(La);
deleteListElem(La, 3, e );
printList(La);
insertList(La, e, 3);
printList(La);
//排序
quickSort(La,0, La.lenght-1);
printList(La);
printf("LB:\r\n");
initList(Lb, LIST_INIT_SIZE);
int Bdata[5] = {1,3,2,4,6};
for (i=0; i<5;i++) {
insertList(Lb, Bdata[i], i);
}
//排序
quickSort(Lb,0, Lb.lenght-1);
printList(Lb);
mergeList(La, Lb, Lc);
printList(Lc);
}

// Test.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include "stdlib.h"
//宏定义
#define TRUE   1
#define FALSE   0
#define OK    1
#define ERROR   0
#define INFEASIBLE -1
#define OVERFLOW -2

#define LT(a,b)   ((a)<(b))
#define N = 100       

#define LIST_INIT_SIZE 100 //线性表初始空间分配量
#define LISTINCREMENT   10 //线性表空间分配的增量

typedef int Status;
typedef int ElemType;

typedef struct LNode{
	ElemType  *elem;        //存储空间的基地址
	int      lenght;		//当前的长度
	int		 listsize;      //当前分配的存储容量
}SqList;

/**
 *构造空的线性表
 */

Status initList(SqList &L, int lenght){
	if (lenght == 0) lenght = LIST_INIT_SIZE;
	L.elem = (ElemType *)malloc(lenght * sizeof(ElemType));
	if(!L.elem) exit(OVERFLOW);  //分配存储空间失败
	L.lenght = 0;				 //初始空表长度为0
	L.listsize = lenght ;//初始存储容量为100
	return OK;
}
/************************************************************************/
/* 在第i位置插入e
*/
/************************************************************************/
Status insertList(SqList &L, ElemType e, int i){
	ElemType *p,  *q;
	if(i<0 ||i > L.lenght) return ERROR;  //i值不合法
	if (L.lenght >= L.listsize) {
		ElemType *newbase = (ElemType *)realloc(L.elem ,(L.listsize +LISTINCREMENT)*sizeof(ElemType));
		if(!newbase) return OVERFLOW;	//存储分配失败  
		L.elem = newbase;				//新基值
		L.listsize += LISTINCREMENT;    //增加存储容量
	}
	q = &L.elem[i];						//q为插入的位置
	for (p = &L.elem[L.lenght]; p>=q; --p) {
		*p = *(p-1);					//i元素之后的元素往后移动
	}
	*q = e;								//插入e
	L.lenght +=1;
	return OK;

}
/************************************************************************/
/* 快速排序 
*/
/************************************************************************/
void sortList(SqList &L){
	

}
/************************************************************************/
/* 删除第i位置元素，并用e返回其值                                                                     */
/************************************************************************/
Status deleteListElem(SqList &L, int i, ElemType &e){
	int *p,  *q;
	if(i<0 ||i > L.lenght) return ERROR;  //i值不合法
	q = &L.elem[i];						  //被删除元素的位置为i，L.elem就是数组名,
	e = *q;								  //被删除元素的值赋值给e
	for (p = q; p< (L.elem + L.lenght); p++){ //元素左移
		*p = *(p+1);
	}
	--L.lenght;
	return OK;
}

/************************************************************************/
/*  快速排序
*/
/************************************************************************/

int partition(SqList &L, ElemType low, ElemType high){
	ElemType pivotkey = L.elem[low];		       //枢轴记录关键字
	while (low < high) {					 //从表的两端向中间扫描
		while (low < high &&  L.elem[high] >= pivotkey ) --high;//高端位置扫描
		L.elem[low] = L.elem[high];		//交换数据，小于pivotkey移到低端
		L.elem[high] = pivotkey;

		while (low < high && L.elem[low] <= pivotkey ) ++low;     //低端扫描
		L.elem[high] = L.elem[low];				  //交换数据 大于pivotkey移到高端
		L.elem[low] = pivotkey;									
	}
	return low;
}

void quickSort(SqList &L, ElemType low, ElemType high){
	int pivot;
	if(low < high) {										   
		pivot =  partition(L,  low,  high); 	
		quickSort(L,  low,  pivot -1);			//低端子表排序
		quickSort(L,  pivot +1, high);			//高端子表排序
	}
	
}


/************************************************************************/
/* 
合并两个线性表
*/
/************************************************************************/

void mergeList(SqList La, SqList Lb,  SqList &Lc){
	ElemType *pa, *pb, *pc;
	Lc.listsize =  La.lenght + Lb.lenght;
	initList(Lc, Lc.listsize);			//初始化LC\pc = Lc.elem;
	Lc.lenght = Lc.listsize;
	pc = Lc.elem;
	pa = La.elem;
	pb = Lb.elem;
	while (pa <= &La.elem[La.lenght -1] && pb <= &Lb.elem[Lb.lenght -1]){
		if (*pa <= *pb) *pc++ = *pa++;
		else *pc++ = *pb++;
	}
	while(pa <= &La.elem[La.lenght -1]) *pc++ = *pa++; //插入La的剩余元素
	while(pb <= &Lb.elem[Lb.lenght -1]) *pc++ = *pb++; //插入Lb的剩余元素

}

/************************************************************************/
/* 打印list
*/
/************************************************************************/
void printList(SqList L){
	printf("当前值:"); 
	for (int i =0; i<L.lenght;i++) {
		printf("%d ", *(L.elem+i)); // L.elem为首地址
	} 
	printf("\r\n"); 
}

void main()
{
	SqList La,Lb,Lc;
	ElemType e;
	int init,i;
	init = initList(La, LIST_INIT_SIZE);
	int data[6] = {5,3,6,2,7,4};
	for (i=0; i<6;i++) {
		insertList(La,  data[i],  i);
	}
	printf("LA:\r\n"); 
	printList(La);
	deleteListElem(La, 3, e );
	printList(La);
	insertList(La,  e,  3);
	printList(La);

	//排序
	quickSort(La,0, La.lenght-1);
	printList(La);

	printf("LB:\r\n"); 
	initList(Lb, LIST_INIT_SIZE);
	int Bdata[5] = {1,3,2,4,6};
	for (i=0; i<5;i++) {
		insertList(Lb,  Bdata[i],  i);
	}
	//排序
	quickSort(Lb,0, Lb.lenght-1);
	printList(Lb);

	mergeList(La, Lb,  Lc);
	printList(Lc);

}