2021-07-14

数据结构(C&C++)

线性表的顺序表示

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#define MaxSize 20
using namespace std;
int Bsearch(int a[],int n,int x);
int main() {
	
	return 0;
}
typedef struct {
	int data[MaxSize];
	int length;
}SqList;
bool ListInsert(SqList &L, int i,int e) {
	if (i<1 || i>L.length+1) {
		printf("Wrong Position!");
		return false;
	}
	if (L.length > MaxSize) {
		printf("Already Full!");
		return false;
	}
	for (int j = L.length; j >= i; j--) 
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;
	L.length++;
	return true;
}
bool ListDelete(SqList& L, int i, int& e) {
	if (i<1 || i>L.length) {
		printf("Wrong Position!");
		return false;
	}
	e = L.data[i - 1];
	for (int j = i; j < L.length; j++)
		L.data[j - 1] = L.data[j];
	L.length--;
	return true;
}
int LocateElement(SqList L, int e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] == e);
		return i + 1;
	}
	return 0;
}
bool Delete_Min(SqList& L, int& value) {
	if (L.length == 0) 
		return false;
	int pos = 0;
	value = L.data[0];
	for (int i = 0; i < L.length; i++) {
		if (L.data[i]<value) {
			value = L.data[i];
			pos = i;
		}
		L.data[pos] = L.data[L.length - 1];
		L.length--;
		return true;
	}
}
void Reverse(SqList &L) {
	int temp=0;
	for (int i = 0; i < L.length / 2; i++) {
		L.data[i] = temp;
		temp = L.data[L.length - i - 1];
		L.data[L.length - i - 1] = temp;
	}
}
void Delete_X(SqList& L, int x) {
	int k = 0;
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] != x) {
			L.data[k] = L.data[i];
			k++;
		}
		L.length = k;
	}
}
bool Delete_sTot(SqList& L, int s, int t) {
	if (L.length == 0 || s<0 || t>L.length - 1||s>=t)
		return false;
	int i, j;
	for (i = 0; L.data[i] < s; i++);
	for (j = i; L.data[j] <=t; j++);   //线性表连续的应用，寻找值大于t的第一个元素，用其覆盖s和t之间的元素
	for (; j < L.length; i++,j++) {
		L.data[i] = L.data[j];  //后面的元素前移
	}
	L.length = i;
	return true;
}
bool Delete_s_t(SqList& L, int s, int t) {
	if (L.length == 0 || s<0 || t>L.length - 1 || s >= t) 
		return false;
	int k = 0;  //顺序表中的元素不一定是有序的，需要记录下来
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] >= s && L.data[i] <= t)
			k++;
		else
			L.data[i - k] = L.data[i];
		L.length -= k;
		return true;
	}
}
bool Delete_Same(SqList& L) {
	if (L.length == 0)
		return false;
	int i, j;
	for (i = 0, j = 1; i < L.length; j++) 
		if (L.data[i] != L.data[j])
			L.data[++i] = L.data[j];
	L.length = i + 1;
	return true;
}
bool Merege(SqList L1, SqList L2, SqList& L3) {
	if (L1.length + L2.length > MaxSize)
		return false;
	int i = 0, j = 0, k = 0;
	while (i < L1.length && j < L2.length) {
		if (L1.data[i] < L2.data[j])
			L3.data[k++] = L1.data[i++];
		else
			L3.data[k++] = L2.data[j++];
	}
	while (i < L1.length)
		L3.data[k++] = L1.data[i++];
	while (j < L2.length)
		L3.data[k++] = L2.data[j++];
	L3.length = k;
	return true;
}

//A[m+n]，线性表m、n互换
void reverse(int a[], int left, int right, int arrSize) {
	if (left >= right || right >=arrSize)
		return;
	int mid = (left + right) / 2;
	for (int i = 0; i < mid - left; i++) {
		int tmp = a[left + i];
		a[left + i] = a[right - i];
		a[right - i] = tmp;
	}
}
void Exchange(int a[], int m, int n, int arrSize) {
	reverse(a, 0, m + n - 1, arrSize);
	reverse(a, 0, n - 1, arrSize);
	reverse(a, n, m + n - 1, arrSize);
}
void SearchExchangeInsert(SqList L, int x) {
	int low = 0, high = L.length - 1, mid;
	mid = (low + high) / 2;
	while (low<=high)
	{
		if (L.data[mid] == x)
			break;
		else if (L.data[mid] < x)
			low = mid + 1;
		else
			high = mid - 1;
	}
	if (L.data[mid] == x && mid != L.length - 1)
	{
		int tmp = L.data[mid];
		L.data[mid ] = L.data[mid+1];
		L.data[mid+1] = tmp;
	}
	if (low > high) {
		int i = 0;
		for ( i = L.length - 1; i > high; i--)
			L.data[i + 1] = L.data[i];
		L.data[i + 1] = x;
	}
}
void reserve_10(int a[], int from, int to) {
	for (int i = 0; i < (to - from + 1); i++) {
		int tmp = a[from + i];
		a[from + i] = a[to - i];
		a[to - i] = tmp;
	}
}
void Conserve(int a[], int n, int p) {
	reserve_10(a, 0, p - 1);
	reserve_10(a, p, n - 1);
	reserve_10(a, 0, n - 1);
}
int Middle_Search(int a[], int b[], int n) {
	int s1 = 0, d1 = n - 1, m1, s2 = 0, d2 = n - 1, m2;
	while (s1 != d1 || s2 != d2) {
		m1 = (s1 + d1) / 2;
		m2 = (s2 + d2) / 2;
		if (a[m1] == b[m2]) return a[m1];
		if (a[m1] < b[m2]) {
			if ((s1 + m1) % 2 == 0) {
				s1 = m1;
				d2 = m2;
			}
			else {
				s1 = m1 + 1;
				d2 = m2;
			}
		}
		else {
			if ((s2 + d2) % 2 == 0) {
				s2 = m2;
				d1 = m1;
			}
			else {
				s2 = m2 + 1;
				d1 = m1;
			}
		}
	}
	return a[s1] < b[s2] ? a[s1] : b[s2];
}
int Find_Min_Integer(int a[], int n) {
	int i, * b;
	b = (int*)malloc(sizeof(int) * n);
	memset(b, 0, sizeof(int) * n);
	for (i = 0; i < n; i++)
		if (a[i] >= 1 && a[i] <= n)
			b[a[i] - 1] = 0;
	for (i = 0; i < n; i++)
		if (b[i] == 0)
			break;
	return i + 1;
}