前言：我也忘了这些代码是哪里来的，也不知道为什么留在电脑里，索性直接贴出来好了
目录
链表
#include <stdio.h>
#include <assert.h>
#define MAXSIZE 10
#define SWAP(x, y, t) {t=x;x=y;y=t; }
typedef struct Sqlist{
int data[MAXSIZE];
int length;
}Sqlist;
typedef struct LNode{
int data;
struct LNode* next;
}LNode;
typedef struct DLNode{
int data;
struct DLNode *prior;
struct DLNode *next;
}DLNode;
void show(Sqlist L){
for (int i = 0; i< L.length; i++)
printf("%d ", L.data[i]);
}
void initList(Sqlist &L){ //初始化顺序表
L.length = 0;
}
int getElem(Sqlist L, int p, int &e){ //获取指定位置的元素
if (p>L.length || p<0) return 0;
e = L.data[p];
return 1;
}
int findElem(Sqlist L, int x){ //通过元素值找下标
for (int i=0; i<L.length; i++){
if (L.data[i] == x)
return i;
}
return -1;
}
int insert(Sqlist &L, int p, int x){ //插入一个元素
if (p>L.length || p<0 || L.length > MAXSIZE) return 0;
int i;
for (i=L.length; i>=p; i++) //把p给移走
L.data[i] = L.data[i-1];
L.data[p] = x;
++(L.length); //DNF: do not forget
return 1;
}
int deleteElem(Sqlist L, int x, int &e){ //删除一个元素
int p = findElem(L, x);
if (p == -1) return 0;
e = L.data[p];
for (int i = p; i<L.length-1; i++){
L.data[i] = L.data[i+1];
}
--(L.length);
return 1;
}
void reverse(Sqlist &L){ //逆置顺序表
int temp, i, j;
for (i = 0, j = L.length-1 ; i < j; ++i, --j){
temp = L.data[i];
L.data[i] = L.data[j];
L.data[j] = temp;
}
}
int deleteRange(Sqlist &L, int i, int j){ //删除下标为i-j的元素
assert(0 <= i && 0 <= j);
int delta = j+1-i;
for (int k = j+1; k < L.length-1; ++k){
L.data[k-delta] = L.data[k]; //把包括i之后的替换成j之后的
}
L.length -= delta;
return 1;
}
// 2 6 4 7 8 9 5 1 3 6
int Partition(Sqlist &L, int left, int right ){ //非递归快排
int i = left, j = right, temp;
int pivot = L.data[i];
while (i < j){
while (i < j && pivot <= L.data[j]) --j; //不加=若数列出现重复数 陷入死循环
if (i < j)
L.data[i] = L.data[j];
while (i < j && pivot > L.data[i]) ++i;
if (i < j)
L.data[j] = L.data[i];
}
L.data[j] = pivot;
return j;
}
void QuickSort(Sqlist &L, int left, int right ){
if( left >= right ) return ;
int index = Partition(L, left, right ) ;
QuickSort(L, left, index-1 ) ;
QuickSort(L, index+1, right ) ;
}
int ReQuickSort(Sqlist &L, int left, int right){ //递归快排
if (left < right){
int temp;
int i = left, j = right+1;
int pivot = L.data[left];
do{
do ++i;
while (pivot > L.data[i]);
do --j;
while (pivot < L.data[j]);
if (i < j) SWAP(L.data[i], L.data[j], temp);
} while (i < j);
SWAP(L.data[left], L.data[j], temp);
ReQuickSort(L, left, j-1);
ReQuickSort(L, j+1, right); //not i+1 is j+1
}
}
// --------------------LinkList-------------------------------
void initLinkList(LNode *list){ //初始化链表
list->next = NULL;
}
void createListR(LNode *&list, int S[], int n){ //尾插法
LNode *q,*p;
list = (LNode*)malloc(sizeof(LNode));
list->next = NULL;
p = list;
for (int i=0; i<n; i++){
q = (LNode*)malloc(sizeof(LNode));
q->data = S[i];
p->next = q;
p = p->next;
}
p->next = NULL;
}
void createListF(LNode *&list, int S[], int n){ //头插法
LNode *r;
list = (LNode*)malloc(sizeof(LNode));
list->next = NULL;
r = list;
for (int i=0; i<n; ++i){
r = (LNode*)malloc(sizeof(LNode));
r->data = S[i];
r->next = list->next;
list->next = r;
}
}
void mergeI(LNode *A, LNode *B, LNode *&C){ //合并成递增increase单链表 注意&C
LNode *a, *b, *c;
a = A->next;b = B->next;
C = A;
C->next = NULL;
free(B);
c = C;
while (a && b){
if (a->data > b->data){
c->next = b;
c = c->next;
b = b->next;
}else{
c->next = a;
c = c->next;
a = a->next;
}
}
if (a) c->next = a;
if (b) c->next = b;
}
void mergeD(LNode *A, LNode *B, LNode *&C){ //合并成递减decline单链表
LNode *a, *b, *s;
a = A->next; b = B->next;
C = A;
C->next = NULL;
free(B);
while (a && b){
if (a->data < b->data){ //两种方式都可以头插进去
s = a->next;
a->next = C->next;
C->next = a;
a = s;
}else{ //第二种
s = b;
b = b->next;
s->next = C->next;
C->next = s;
}
}
while (a){ //循环放入
s = a;
a = a->next;
s->next = C->next;
C->next = s;
}
while (b){
s = b;
b = b->next;
s->next = C->next;
C->next = s;
}
}
int findAndDelete(LNode *&list, int d){
LNode *s;
s = list; //从头结点开始查 否则s->next会跳过第一个结点
while (s->next){ //不能是s 因为 下面的if判断到最后一个结点是NULL会出错
if (s->next->data == d){
LNode *del = s->next;
s->next = del->next;
free(del);
return 1;
}
s = s->next;
if (s->next == NULL) return 0;
}
}
void deleteAtoB(LNode *&list, int a, int b){
LNode *r = list, *del;
while (r->next && r->next->data < b){
if (r->next->data > a){
del = r->next;
r->next = del->next;
free(del);
}else r = r->next;
}
}
void deleteDuplicate(LNode *list){ //删除重复元素
LNode *front = list->next; //链表有数据的结点
LNode *rear; //链表front的下一个结点
while (front->next){
rear = front->next;
if (front->data == rear->data){
front->next = rear->next;
free(rear);
}else{
front = front->next;
}
}
}
int count = 0;
void deleteMin(LNode *&list){
LNode *pre, *p, *premin, *min;
pre = list; p = pre->next; //注意pre从list开始 从list->next开始会忽略第一个
premin = pre; min = p;
while (p){
if (p->data <= min->data){
premin = pre;
min = p;
// ++count;
}
pre = p;
p = p->next;
}
premin->next = min->next;
free(min);
}
LNode* reverseList(LNode *list){ //如果带头结点必须传入 list->next
LNode *p = list->next, *q;
list->next = NULL;
while (p){ //先保存下一个结点，然后头插交换顺序，在更新到下一个结点上
q = p->next;
p->next = list->next; //这步和下一步就是头插法
list->next = p;
p = q;
}
return list;
/*if (list){
reverseList(list->next);
printf("%d ", list->data);
}*/
}
void showLinkList(LNode *list){
LNode *s;
s = list->next;
while (s){
printf("%d ", s->data);
s = s->next;
}
}
void BubbleSort(LNode *head){
LNode *q,*p, *tail;
int i = 0;
tail = NULL;
while (head->next->next != tail){
p = head;
q = head->next;
while (q->next != tail){
if (q->data > q->next->data){
p->next = q->next;
q->next = q->next->next;
p->next->next = q; //上面三步就是交换了结点顺序 手画一下就清楚了
q = p->next; //使其重新回到p后，为了后续前进操作保持一致
//如 1532 修改完后p在3上，但if结束后，两者都进一即p是3；q是5
//一开始我是想让p=p->next，直接让它是冒泡交换后的大值 但这样子会跳过好多结点
}
p = p->next;
q = q->next;
}
tail = q; //如果没有发生交换 则会退出循环
}
}
// 0 1 2 7 4 5 9 7 6 3
int main(){
printf("相信自己！加油！");
printf("\n");
/* Sqlist L;
for (int i = 0;i < 10;i++)
scanf("%d", &L.data[i]);
L.length = 10;
//show(L);printf("\n");
printf("%d", Partition(L,0,9));
QuickSort(L,0,9);
show(L);*/
int a[10] = {1, 2, 99, 5, 4, 7, 8};
int b[10] = {1, 3, 4, 9, 10, 12, 13};
LNode *A, *B, *C;
createListR(A, a, 7);
// createListR(B, b, 7);
// mergeF(A, B, C);
// printf("%d", findAndDelete(A, 1));
// deleteDuplicate(A);
// B = reverseList(A);
// deleteAtoB(A, 1, 8);
//showLinkList(A);
showLinkList(A);
printf("\n");
BubbleSort(A);
showLinkList(A);
return 1;
}树
#include <iostream>
using namespace std;
typedef struct Node
{//定义二叉树结构
char data;
struct Node *lchild,*rchild;
}*BiTree,BiTNode;
void CreateBiTree(BiTree &T)
{//先序创建二叉树
char ch;
cin>>ch;
if(ch=='#') T=NULL;
else{
T=new BiTNode;
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
}
void InOrderTraverse(BiTree T)
{//中序遍历
if(T)
{
InOrderTraverse(T->lchild);
cout<<T->data;
InOrderTraverse(T->rchild);
}
}
void PreOrderTraverse(BiTree T)
{//先序遍历
if(T)
{
cout<<T->data;
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(BiTree T)
{//后序遍历
if(T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data;
}
}
void Copy(BiTree T,BiTree &NewT)
{//二叉树的复制
if(T==NULL){
NewT=NULL;
return;
}else
{
NewT=new BiTNode;
NewT->data=T->data;
Copy(T->lchild,NewT->lchild);
Copy(T->rchild,NewT->rchild);
}
}
int Depth(BiTree T)
{//树的深度
if(T==NULL)
return 0;
else
{
int m=Depth(T->lchild);
int n=Depth(T->rchild);
if(m>n) return (m+1);
else return (n+1);
}
}
int NodeCount(BiTree T)
{//统计二叉树中结点的个数
if(T==NULL) return 0;
else return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}
int LeafCount(BiTree T)
{//统计二叉树中叶子结点的个数
if(!T) return 0;
if(!T->lchild &&!T->rchild){//如果二叉树左子树和右子树皆为空,说明该二叉树根节点为叶子节点,加1.
return 1;
}else{
return LeafCount(T->lchild)+LeafCount(T->rchild);
}
}
int Node_1_Count(BiTree T)
{//统计二叉树的度为1的结点个数
if(!T) return 0;
if((!T->lchild)&&(T->rchild)||(T->lchild)&&(!T->rchild))
return 1 + Node_1_Count(T->lchild) + Node_1_Count(T->rchild);
else
return Node_1_Count(T->lchild) + Node_1_Count(T->rchild);
}
void PrintAllPath(BiTree T, char path[], int pathlen)
{//二叉树中从每个叶子结点到根结点的路径
int i;
if(T != NULL) {
path[pathlen] = T->data; //将当前结点放入路径中
if(T->lchild == NULL && T->rchild == NULL) {//叶子结点
for(i = pathlen; i >= 0; i--)
cout << path[i] << " " ;
cout << endl;
}else{
PrintAllPath(T->lchild, path, pathlen + 1);
PrintAllPath(T->rchild, path, pathlen + 1);
}
}
}
void ExChangeTree(BiTree &T)
{//构造函数，使用递归算法进行左右结点转换
BiTree temp;
if(T!=NULL){//判断T是否为空，非空进行转换，否则不转换
temp=T->lchild;
T->lchild=T->rchild;//直接交换节点地址
T->rchild=temp;
ExChangeTree(T->lchild);
ExChangeTree(T->rchild);
}
}
void DblOrderTraverse(BiTree T)
{//二叉树的双序遍历
if(T)
{
cout<<T->data;
DblOrderTraverse(T->lchild);
cout<<T->data;//访问两遍
DblOrderTraverse(T->rchild);
}
}
int main()
{
BiTree T;
//测试例子AB#CD##E##F#GH###
cout<<"先序遍历输入(以#结束):";
CreateBiTree(T);
cout<<"中序遍历输出:";
InOrderTraverse(T);
cout<<endl<<"先序遍历输出:";
PreOrderTraverse(T);
cout<<endl<<"后序遍历输出:";
PostOrderTraverse(T);
cout<<endl<<"树的深度:"<<Depth(T);
cout<<endl<<"结点的个数:"<<NodeCount(T);
cout<<endl<<"叶结点的个数:"<<LeafCount(T);
cout<<endl<<"度为1的结点个数:"<<Node_1_Count(T);
cout<<endl<<"二叉树中从每个叶子结点到根结点的所有路径："<<endl;
char path[256];
int pathlen=0;
PrintAllPath(T,path,pathlen);//
//交换二叉树每个结点的左孩子和右孩子
BiTree tem=T;//直接复制一颗树，在不改变原树的前提下，对临时树进行交换。
ExChangeTree(tem);
cout<<"先序遍历输出交换后的结果:";
PreOrderTraverse(tem);
cout<<endl<<"双序遍历输出:";
DblOrderTraverse(T);
return 0;
}
排序
#include <stdio.h>
#define SWAP(x,y,t) {t=y;y=x;x=t;}
void InsertSort(int a[], int n){ //直接插入
int i, j;
int temp;
for (i = 1; i<n; ++i){
if (a[i] < a[i-1]){
temp = a[i];
for (j=i; j>=1 && a[j-1] > temp; --j)
a[j] = a[j-1];
a[j] = temp;
}
}
}
void BinaryInsertSort(int a[], int n){
int i, j, low, high, mid, temp;
for (i=0; i<n; ++i){
low = 0;
high = i-1;
temp = a[i];
while (low <= high){
mid = (low+high)/2;
if (a[mid] > temp)
high = mid - 1;
else
low = mid + 1;
}
for (j=i-1; j>=high+1; --j) //将i之前的元素后移
a[j+1] = a[j];
a[j+1] = temp; //在
}
}
void ShellSort(int a[], int n){
int i, j, d, temp;
for (d = n/2; d>0 ; d /= 2){
for (i = d; i<n; ++i){
if (a[i-d] > a[i] ){
temp = a[i];
for (j=i ; j>=d && temp<a[j-d]; j -= d)
a[j] = a[j-d];
a[j] = temp;
}
}
}
}
void BubbleSort(int a[], int n){
int i, j, temp, flag;
for (i = n-1; i>0; --i){
flag = 0;
for (j = 0; j<i; ++j){ //j<i是因为下标从0开始与实际位置差一
if (a[j] > a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
flag = 1;
}
}
if (!flag) return;
}
}
void SelectSort(int a[], int n){
int temp, k,i,j;
for (i=0; i<n; ++i){
k = i;
for (j=i+1; j<n; ++j)
if (a[k] > a[j])
k = j;
temp = a[i];
a[i] = a[k];
a[k] = temp;
}
}
void QuickSort(int a[], int left, int right){ //递归实现
int i, j, temp, pivot;
if (left < right){
i = left; j = right+1;
pivot = a[left];
do {
do ++i;
while (pivot > a[i]);
do --j;
while (pivot < a[j]);
if (i<j) SWAP(a[i], a[j], temp);
}while (i<j);
SWAP(a[left], a[j], temp);
QuickSort(a, left, j-1);
QuickSort(a, j+1, right);
}
}
int main(){
int a[5] = {8,1,6,3,4};
ShellSort(a,5);
for (int i=0; i<5; ++i)
printf("%d ", a[i]);
}